kpriv/pkgsrc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
pkgsrc/lang/mercury/PLIST

4802 lines
215 KiB
Text
Raw Normal View History

lang/mercury: move HTML documentation to share/doc/mercury/html
2018-02-18 06:30:55 +01:00
@comment $NetBSD: PLIST,v 1.15 2018/02/18 05:30:55 rillig Exp $
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
bin/c2init
bin/canonical_grade
bin/info_to_mdb
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
bin/mcov
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
bin/mdb
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
bin/mdb.bat
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
bin/mdemangle
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
bin/mdice
bin/mdprof
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
bin/mdprof_cgi
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
bin/mdprof_create_feedback
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
bin/mdprof_dump
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
bin/mdprof_report_feedback
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
bin/mdprof_test
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
bin/mercury.bat
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
bin/mercury_compile
bin/mercury_config
bin/mercury_profile
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
bin/mercury_update_interface
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
bin/mfiltercc
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
bin/mfilterjavac
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
bin/mgnuc
bin/mkfifo_using_mknod
bin/mkinit
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
bin/mkinit_erl
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
bin/ml
bin/mmake
bin/mmc
bin/mprof
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
bin/mprof.bat
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
bin/mprof_merge_runs
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
bin/mslice
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
bin/mtags
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
bin/mtc
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
bin/mtc_diff
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
bin/mtc_union
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
bin/prepare_install_dir
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
bin/vpath_find
List the info files directly in the PLIST, and honor PKGINFODIR and PKGMANDIR.
2006-04-05 08:27:41 +02:00
info/mercury.info
info/mercury_faq.info
info/mercury_library.info
info/mercury_ref.info
info/mercury_trans_guide.info
info/mercury_user_guide.info
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/conf/Mercury.config
lib/mercury/conf/mercury_conf.h
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/array.mh
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/array2d.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/assoc_list.mh
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/backjump.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/bag.mh
lib/mercury/inc/benchmarking.mh
lib/mercury/inc/bimap.mh
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/bit_buffer.mh
lib/mercury/inc/bit_buffer.read.mh
lib/mercury/inc/bit_buffer.write.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/bitmap.mh
lib/mercury/inc/bool.mh
lib/mercury/inc/bt_array.mh
lib/mercury/inc/builtin.mh
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/calendar.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/char.mh
lib/mercury/inc/construct.mh
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/cord.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/counter.mh
lib/mercury/inc/deconstruct.mh
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/digraph.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/dir.mh
lib/mercury/inc/enum.mh
lib/mercury/inc/eqvclass.mh
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/erlang_builtin.mh
lib/mercury/inc/erlang_rtti_implementation.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/exception.mh
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/inc/fat_sparse_bitset.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/float.mh
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/gc.h
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/gc.mh
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/gc_config_macros.h
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/gc_inline.h
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/gc_mark.h
lib/mercury/inc/gc_pthread_redirects.h
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/gc_tiny_fl.h
lib/mercury/inc/gc_version.h
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/getopt.mh
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/getopt_io.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/hash_table.mh
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/injection.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/int.mh
lib/mercury/inc/integer.mh
lib/mercury/inc/io.mh
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/lazy.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/lexer.mh
lib/mercury/inc/library.mh
lib/mercury/inc/list.mh
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/machdeps/alpha_regs.h
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/machdeps/arm_regs.h
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/machdeps/i386_regs.h
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/machdeps/ia64_regs.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/machdeps/mips_regs.h
lib/mercury/inc/machdeps/no_regs.h
lib/mercury/inc/machdeps/pa_regs.h
lib/mercury/inc/machdeps/rs6000_regs.h
lib/mercury/inc/machdeps/sparc_regs.h
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/machdeps/x86_64_regs.h
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/map.mh
lib/mercury/inc/math.mh
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/maybe.mh
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/mdb.browse.mh
lib/mercury/inc/mdb.browser_info.mh
lib/mercury/inc/mdb.browser_term.mh
lib/mercury/inc/mdb.collect_lib.mh
lib/mercury/inc/mdb.cterm.mh
lib/mercury/inc/mdb.debugger_interface.mh
lib/mercury/inc/mdb.declarative_analyser.mh
lib/mercury/inc/mdb.declarative_debugger.mh
lib/mercury/inc/mdb.declarative_edt.mh
lib/mercury/inc/mdb.declarative_execution.mh
lib/mercury/inc/mdb.declarative_oracle.mh
lib/mercury/inc/mdb.declarative_tree.mh
lib/mercury/inc/mdb.declarative_user.mh
lib/mercury/inc/mdb.diff.mh
lib/mercury/inc/mdb.dl.mh
lib/mercury/inc/mdb.frame.mh
lib/mercury/inc/mdb.help.mh
lib/mercury/inc/mdb.interactive_query.mh
lib/mercury/inc/mdb.io_action.mh
lib/mercury/inc/mdb.listing.mh
lib/mercury/inc/mdb.mh
lib/mercury/inc/mdb.name_mangle.mh
lib/mercury/inc/mdb.parse.mh
lib/mercury/inc/mdb.sized_pretty.mh
lib/mercury/inc/mdb.term_rep.mh
lib/mercury/inc/mdb.util.mh
lib/mercury/inc/mdbcomp.feedback.automatic_parallelism.mh
lib/mercury/inc/mdbcomp.feedback.mh
lib/mercury/inc/mdbcomp.goal_path.mh
lib/mercury/inc/mdbcomp.mh
lib/mercury/inc/mdbcomp.prim_data.mh
lib/mercury/inc/mdbcomp.program_representation.mh
lib/mercury/inc/mdbcomp.rtti_access.mh
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/inc/mdbcomp.shared_utilities.mh
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/mdbcomp.slice_and_dice.mh
lib/mercury/inc/mdbcomp.trace_counts.mh
lib/mercury/inc/mer_browser.mh
lib/mercury/inc/mer_mdbcomp.mh
lib/mercury/inc/mer_ssdb.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/mer_std.mh
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury.h
lib/mercury/inc/mercury_accurate_gc.h
lib/mercury/inc/mercury_agc_debug.h
lib/mercury/inc/mercury_array_macros.h
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/mercury_atomic_ops.h
lib/mercury/inc/mercury_backjump.h
lib/mercury/inc/mercury_bitmap.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_bootstrap.h
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/mercury_builtin_types.h
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/mercury_builtin_types_proc_layouts.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_calls.h
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/mercury_complexity.h
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/mercury_conf_bootstrap.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_conf_param.h
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/mercury_construct.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_context.h
lib/mercury/inc/mercury_debug.h
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/mercury_deconstruct.h
lib/mercury/inc/mercury_deconstruct_macros.h
lib/mercury/inc/mercury_deep_call_port_body.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_deep_copy.h
lib/mercury/inc/mercury_deep_copy_body.h
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/mercury_deep_leave_port_body.h
lib/mercury/inc/mercury_deep_profiling.h
lib/mercury/inc/mercury_deep_profiling_hand.h
lib/mercury/inc/mercury_deep_rec_depth_actions.h
lib/mercury/inc/mercury_deep_rec_depth_body.h
lib/mercury/inc/mercury_deep_redo_port_body.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_dlist.h
lib/mercury/inc/mercury_dummy.h
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/mercury_dword.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_engine.h
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/mercury_event_parser.h
lib/mercury/inc/mercury_event_scanner.h
lib/mercury/inc/mercury_event_spec.h
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/mercury_exception_catch_body.h
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/mercury_expanding_array.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_file.h
lib/mercury/inc/mercury_float.h
lib/mercury/inc/mercury_getopt.h
lib/mercury/inc/mercury_goto.h
lib/mercury/inc/mercury_grade.h
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/mercury_hand_compare_body.h
lib/mercury/inc/mercury_hand_unify_body.h
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/mercury_hash_lookup_or_add_body.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_hash_table.h
lib/mercury/inc/mercury_heap.h
lib/mercury/inc/mercury_heap_profile.h
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/mercury_hgc.h
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/mercury_hlc_types.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_ho_call.h
lib/mercury/inc/mercury_imp.h
lib/mercury/inc/mercury_init.h
lib/mercury/inc/mercury_label.h
lib/mercury/inc/mercury_layout_util.h
lib/mercury/inc/mercury_library_types.h
lib/mercury/inc/mercury_make_type_info_body.h
lib/mercury/inc/mercury_memory.h
lib/mercury/inc/mercury_memory_handlers.h
lib/mercury/inc/mercury_memory_zones.h
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/mercury_minimal_model.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_misc.h
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/mercury_ml_arg_body.h
lib/mercury/inc/mercury_ml_deconstruct_body.h
lib/mercury/inc/mercury_ml_expand_body.h
lib/mercury/inc/mercury_ml_functor_body.h
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/mercury_mm_own_stacks.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_overflow.h
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/mercury_par_builtin.h
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/mercury_proc_id.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_prof.h
lib/mercury/inc/mercury_prof_mem.h
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/mercury_prof_time.h
lib/mercury/inc/mercury_profiling_builtin.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_reg_workarounds.h
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/mercury_region.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_regs.h
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/mercury_runtime_util.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_signal.h
lib/mercury/inc/mercury_stack_layout.h
lib/mercury/inc/mercury_stack_trace.h
lib/mercury/inc/mercury_stacks.h
lib/mercury/inc/mercury_std.h
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/mercury_stm.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_string.h
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/mercury_table_int_fix_index_body.h
lib/mercury/inc/mercury_table_int_start_index_body.h
lib/mercury/inc/mercury_table_type_body.h
lib/mercury/inc/mercury_table_typeinfo_body.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_tabling.h
lib/mercury/inc/mercury_tabling_macros.h
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/mercury_tabling_preds.h
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/mercury_tabling_stats_defs.h
lib/mercury/inc/mercury_tabling_stats_nodefs.h
lib/mercury/inc/mercury_tabling_stats_undefs.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_tags.h
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/mercury_term_size.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_thread.h
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/mercury_threadscope.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_timing.h
lib/mercury/inc/mercury_trace.h
lib/mercury/inc/mercury_trace_alias.h
lib/mercury/inc/mercury_trace_base.h
lib/mercury/inc/mercury_trace_browse.h
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/mercury_trace_cmd_backward.h
lib/mercury/inc/mercury_trace_cmd_breakpoint.h
lib/mercury/inc/mercury_trace_cmd_browsing.h
lib/mercury/inc/mercury_trace_cmd_dd.h
lib/mercury/inc/mercury_trace_cmd_developer.h
lib/mercury/inc/mercury_trace_cmd_exp.h
lib/mercury/inc/mercury_trace_cmd_help.h
lib/mercury/inc/mercury_trace_cmd_misc.h
lib/mercury/inc/mercury_trace_cmd_parameter.h
lib/mercury/inc/mercury_trace_cmd_queries.h
lib/mercury/inc/mercury_trace_cmd_table_io.h
lib/mercury/inc/mercury_trace_cmds.h
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/mercury_trace_command_queue.h
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/mercury_trace_completion.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_trace_declarative.h
lib/mercury/inc/mercury_trace_external.h
lib/mercury/inc/mercury_trace_help.h
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/mercury_trace_hold_vars.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_trace_internal.h
lib/mercury/inc/mercury_trace_readline.h
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/mercury_trace_source.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_trace_spy.h
lib/mercury/inc/mercury_trace_tables.h
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/mercury_trace_term.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_trace_util.h
lib/mercury/inc/mercury_trace_vars.h
lib/mercury/inc/mercury_trail.h
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/mercury_type_desc.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_type_info.h
lib/mercury/inc/mercury_type_tables.h
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/mercury_typeclass_info.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_types.h
lib/mercury/inc/mercury_unify_compare_body.h
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/mercury_univ.h
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/mercury_windows.h
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/inc/mercury_wrapper.h
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/mercury_wsdeque.h
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/multi_map.mh
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/mutvar.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/ops.mh
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/pair.mh
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/par_builtin.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/parser.mh
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/parsing_utils.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/pprint.mh
lib/mercury/inc/pqueue.mh
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/pretty_printer.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/private/gc_hdrs.h
lib/mercury/inc/private/gc_locks.h
lib/mercury/inc/private/gc_priv.h
lib/mercury/inc/private/gcconfig.h
lib/mercury/inc/private_builtin.mh
lib/mercury/inc/profiling_builtin.mh
lib/mercury/inc/prolog.mh
lib/mercury/inc/queue.mh
lib/mercury/inc/random.mh
lib/mercury/inc/rational.mh
lib/mercury/inc/rbtree.mh
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/region_builtin.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/require.mh
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/robdd.mh
lib/mercury/inc/rtree.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/rtti_implementation.mh
lib/mercury/inc/set.mh
lib/mercury/inc/set_bbbtree.mh
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/set_ctree234.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/set_ordlist.mh
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/set_tree234.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/set_unordlist.mh
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/solutions.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/sparse_bitset.mh
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/ssdb.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/stack.mh
lib/mercury/inc/std_util.mh
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/stm_builtin.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/store.mh
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/stream.mh
lib/mercury/inc/stream.string_writer.mh
lib/mercury/inc/string.builder.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/string.mh
lib/mercury/inc/table_builtin.mh
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/table_statistics.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/term.mh
lib/mercury/inc/term_io.mh
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/term_size_prof_builtin.mh
lib/mercury/inc/term_to_xml.mh
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/inc/test_bitset.mh
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/thread.channel.mh
lib/mercury/inc/thread.mh
lib/mercury/inc/thread.mvar.mh
lib/mercury/inc/thread.semaphore.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/time.mh
lib/mercury/inc/tree234.mh
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/inc/tree_bitset.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/type_desc.mh
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/unit.mh
lib/mercury/inc/univ.mh
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/inc/varset.mh
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/inc/version_array.mh
lib/mercury/inc/version_array2d.mh
lib/mercury/inc/version_bitmap.mh
lib/mercury/inc/version_hash_table.mh
lib/mercury/inc/version_store.mh
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/Mercury/int0s
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/Mercury/int2s
lib/mercury/ints/Mercury/int3s
lib/mercury/ints/Mercury/ints
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/Mercury/mihs
lib/mercury/ints/Mercury/module_deps
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/Mercury/opts
lib/mercury/ints/Mercury/trans_opts
lib/mercury/ints/array.int
lib/mercury/ints/array.int2
lib/mercury/ints/array.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/array.mh
lib/mercury/ints/array.mih
lib/mercury/ints/array.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/array.opt
lib/mercury/ints/array.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/array2d.int
lib/mercury/ints/array2d.int2
lib/mercury/ints/array2d.int3
lib/mercury/ints/array2d.mh
lib/mercury/ints/array2d.mih
lib/mercury/ints/array2d.module_dep
lib/mercury/ints/array2d.opt
lib/mercury/ints/array2d.trans_opt
Update to Mercury 14.01.1 NEWS for Mercury 14.01.1 ------------------------ This is a bug-fix release. * The function string.string/1 and related functions now handle version arrays properly. * Fix resource leaks in dir fold predicates. * The mfilterjavac program is now generated with the correct file extension on Windows. * A problem that caused compilation of the Boehm GC to fail on 64-bit openSUSE 13.1 systems has been fixed. (Github issue #14) * The documentation now builds correctly on Cygwin systems. * The script configure_mingw_cross now supports 64-bit Windows targets. * We have added workarounds for problems with (arguably broken) system headers on MinGW and MinGW64 systems. * The MinGW port now builds in the absence of POSIX threads library. * Low-level C parallel grades now work on Windows instead of crashing at startup. (Bug #338) * We now use thread-safe alternatives to strerror(). (Bug #340) * We have added the configure option --enable-gc-mmap. * We configure Boehm GC to use mmap in threaded grades on Linux to avoid conflicts with glibc malloc leading to memory corruption. * A problem that caused string.format/[23] to sometimes return incorrect results when formatting floats with the 'g' conversion specifier has been fixed. This bug only affected the non-C backends. (Bug #342) * string.format now handles special float values (i.e. nan, inf, and -inf) correctly with the non-C backends. * A bug that caused io.write_float/[34] to append ".0" to float special values has been fixed. This bug affected the C and C# backends. * In the C# and Java grades, the predicate string.from_char_list now implements the documented behaviour for input lists containing null characters (i.e. it throws an exception). Likewise, for string.from_reverse_char_list in the C# grade. * We have fixed a problem that caused `mmc --make' to attempt to install libraries in non-existent grades. Changes to the Mercury compiler: * The compiler now supports stripping of executables in a separate post-link step. The new options, --strip-executable-command, --strip-executable-shared-flags and --strip-executable-static-flags are used to control this. (This is now the default on Mac OS X systems.) NEWS for Mercury 14.01 ---------------------- Changes to the Mercury language: * Repeated type variables may now occur in the heads of type class instances. For example, instance declarations like the following are now allowed: :- instance foo(list(T), map(T, T)). Changes to the Mercury standard library: * We have added the function cord.condense/1. * The following functions in the standard library's cord module now use constant stack space: foldl/3, foldl_pred/4. * We have added the following predicates to the array and version_array modules: is_empty/1, all_true/2 and all_false/2. * We have added the following predicates and functions to the map module: det_min_key/1, det_max_key/1, foldl2_values/6 and foldl3_values/8. * We have added the following predicates to the list module: foldr2/6, foldr3/8, det_take/3 and map_foldr/5. * We have added the following predicates to the bag module: foldl/4 and foldl2/6. * We have added the following predicates to the assoc_list module: foldl2_values/6 and foldl3_values/8. * We have added the following predicates and functions to the pqueue module: is_empty/1, peek/3, peek_key/2, peek_value/2, det_peek/3, merge/3, det_peek_key/1 and det_peek_value/1. * We have added the predicate bimap.equal/2. * We have added the following predicates to the int module: fold_up3/9 and fold_down3/9. Changes to the Mercury compiler: * On Mac OS X systems the compiler is now configured use the version of the host system as the default value for the deployment target. A new configuration option, `--with-macosx-deployment-target', allows an alternative value to be selected at configuration time. Portability improvements: * We have made the implementation compatible with GCC 4.8 and Visual Studio 2013. * We have made the implementation compatible with OS X 10.9. Changes to the extras distribution: * We've added a library that provides support for accessing the function trail from Mercury code.
2015-01-04 20:37:02 +01:00
lib/mercury/ints/asm_fast.gc.debug.stseg/Mercury/opts
lib/mercury/ints/asm_fast.gc.debug.stseg/Mercury/trans_opts
lib/mercury/ints/asm_fast.gc.debug.stseg/array.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/array.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/array2d.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/array2d.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/assoc_list.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/assoc_list.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/backjump.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/backjump.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/bag.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/bag.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/benchmarking.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/benchmarking.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/bimap.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/bimap.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/bit_buffer.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/bit_buffer.read.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/bit_buffer.read.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/bit_buffer.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/bit_buffer.write.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/bit_buffer.write.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/bitmap.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/bitmap.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/bool.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/bool.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/bt_array.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/bt_array.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/builtin.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/builtin.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/calendar.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/calendar.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/char.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/char.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/construct.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/construct.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/cord.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/cord.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/counter.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/counter.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/deconstruct.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/deconstruct.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/digraph.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/digraph.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/dir.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/dir.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/enum.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/enum.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/eqvclass.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/eqvclass.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/erlang_builtin.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/erlang_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/erlang_rtti_implementation.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/erlang_rtti_implementation.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/exception.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/exception.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/fat_sparse_bitset.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/fat_sparse_bitset.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/float.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/float.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/gc.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/gc.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/getopt.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/getopt.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/getopt_io.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/getopt_io.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/hash_table.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/hash_table.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/injection.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/injection.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/int.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/int.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/integer.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/integer.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/io.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/io.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/lazy.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/lazy.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/lexer.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/lexer.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/library.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/library.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/list.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/list.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/map.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/map.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/math.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/math.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/maybe.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/maybe.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/mer_std.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/mer_std.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/multi_map.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/multi_map.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/mutvar.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/mutvar.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/ops.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/ops.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/pair.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/pair.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/par_builtin.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/par_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/parser.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/parser.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/parsing_utils.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/parsing_utils.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/pprint.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/pprint.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/pqueue.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/pqueue.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/pretty_printer.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/pretty_printer.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/private_builtin.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/private_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/profiling_builtin.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/profiling_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/prolog.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/prolog.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/queue.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/queue.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/random.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/random.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/rational.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/rational.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/rbtree.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/rbtree.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/region_builtin.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/region_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/require.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/require.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/robdd.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/robdd.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/rtree.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/rtree.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/rtti_implementation.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/rtti_implementation.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/set.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/set.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/set_bbbtree.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/set_bbbtree.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/set_ctree234.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/set_ctree234.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/set_ordlist.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/set_ordlist.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/set_tree234.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/set_tree234.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/set_unordlist.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/set_unordlist.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/solutions.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/solutions.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/sparse_bitset.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/sparse_bitset.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/stack.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/stack.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/std_util.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/std_util.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/stm_builtin.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/stm_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/store.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/store.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/stream.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/stream.string_writer.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/stream.string_writer.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/stream.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/string.builder.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/string.builder.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/string.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/string.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/table_builtin.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/table_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/table_statistics.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/table_statistics.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/term.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/term.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/term_io.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/term_io.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/term_size_prof_builtin.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/term_size_prof_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/term_to_xml.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/term_to_xml.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/test_bitset.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/test_bitset.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/thread.channel.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/thread.channel.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/thread.mvar.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/thread.mvar.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/thread.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/thread.semaphore.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/thread.semaphore.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/thread.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/time.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/time.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/tree234.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/tree234.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/tree_bitset.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/tree_bitset.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/type_desc.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/type_desc.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/unit.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/unit.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/univ.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/univ.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/varset.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/varset.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/version_array.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/version_array.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/version_array2d.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/version_array2d.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/version_bitmap.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/version_bitmap.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/version_hash_table.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/version_hash_table.trans_opt
lib/mercury/ints/asm_fast.gc.debug.stseg/version_store.opt
lib/mercury/ints/asm_fast.gc.debug.stseg/version_store.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/Mercury/opts
lib/mercury/ints/asm_fast.gc.decldebug.stseg/Mercury/trans_opts
lib/mercury/ints/asm_fast.gc.decldebug.stseg/array.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/array.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/array2d.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/array2d.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/assoc_list.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/assoc_list.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/backjump.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/backjump.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/bag.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/bag.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/benchmarking.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/benchmarking.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/bimap.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/bimap.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/bit_buffer.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/bit_buffer.read.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/bit_buffer.read.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/bit_buffer.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/bit_buffer.write.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/bit_buffer.write.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/bitmap.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/bitmap.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/bool.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/bool.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/bt_array.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/bt_array.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/builtin.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/builtin.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/calendar.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/calendar.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/char.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/char.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/construct.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/construct.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/cord.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/cord.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/counter.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/counter.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/deconstruct.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/deconstruct.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/digraph.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/digraph.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/dir.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/dir.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/enum.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/enum.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/eqvclass.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/eqvclass.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/erlang_builtin.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/erlang_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/erlang_rtti_implementation.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/erlang_rtti_implementation.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/exception.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/exception.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/fat_sparse_bitset.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/fat_sparse_bitset.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/float.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/float.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/gc.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/gc.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/getopt.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/getopt.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/getopt_io.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/getopt_io.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/hash_table.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/hash_table.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/injection.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/injection.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/int.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/int.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/integer.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/integer.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/io.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/io.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/lazy.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/lazy.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/lexer.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/lexer.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/library.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/library.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/list.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/list.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/map.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/map.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/math.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/math.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/maybe.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/maybe.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/mer_std.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/mer_std.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/multi_map.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/multi_map.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/mutvar.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/mutvar.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/ops.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/ops.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/pair.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/pair.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/par_builtin.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/par_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/parser.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/parser.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/parsing_utils.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/parsing_utils.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/pprint.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/pprint.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/pqueue.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/pqueue.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/pretty_printer.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/pretty_printer.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/private_builtin.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/private_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/profiling_builtin.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/profiling_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/prolog.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/prolog.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/queue.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/queue.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/random.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/random.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/rational.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/rational.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/rbtree.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/rbtree.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/region_builtin.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/region_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/require.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/require.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/robdd.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/robdd.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/rtree.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/rtree.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/rtti_implementation.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/rtti_implementation.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/set.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/set.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/set_bbbtree.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/set_bbbtree.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/set_ctree234.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/set_ctree234.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/set_ordlist.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/set_ordlist.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/set_tree234.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/set_tree234.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/set_unordlist.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/set_unordlist.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/solutions.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/solutions.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/sparse_bitset.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/sparse_bitset.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/stack.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/stack.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/std_util.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/std_util.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/stm_builtin.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/stm_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/store.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/store.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/stream.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/stream.string_writer.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/stream.string_writer.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/stream.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/string.builder.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/string.builder.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/string.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/string.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/table_builtin.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/table_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/table_statistics.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/table_statistics.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/term.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/term.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/term_io.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/term_io.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/term_size_prof_builtin.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/term_size_prof_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/term_to_xml.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/term_to_xml.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/test_bitset.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/test_bitset.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/thread.channel.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/thread.channel.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/thread.mvar.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/thread.mvar.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/thread.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/thread.semaphore.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/thread.semaphore.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/thread.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/time.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/time.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/tree234.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/tree234.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/tree_bitset.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/tree_bitset.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/type_desc.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/type_desc.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/unit.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/unit.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/univ.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/univ.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/varset.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/varset.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/version_array.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/version_array.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/version_array2d.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/version_array2d.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/version_bitmap.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/version_bitmap.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/version_hash_table.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/version_hash_table.trans_opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/version_store.opt
lib/mercury/ints/asm_fast.gc.decldebug.stseg/version_store.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/Mercury/opts
lib/mercury/ints/asm_fast.gc.memprof/Mercury/trans_opts
lib/mercury/ints/asm_fast.gc.memprof/array.opt
lib/mercury/ints/asm_fast.gc.memprof/array.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.memprof/array2d.opt
lib/mercury/ints/asm_fast.gc.memprof/array2d.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/assoc_list.opt
lib/mercury/ints/asm_fast.gc.memprof/assoc_list.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.memprof/backjump.opt
lib/mercury/ints/asm_fast.gc.memprof/backjump.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/bag.opt
lib/mercury/ints/asm_fast.gc.memprof/bag.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/benchmarking.opt
lib/mercury/ints/asm_fast.gc.memprof/benchmarking.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/bimap.opt
lib/mercury/ints/asm_fast.gc.memprof/bimap.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.memprof/bit_buffer.opt
lib/mercury/ints/asm_fast.gc.memprof/bit_buffer.read.opt
lib/mercury/ints/asm_fast.gc.memprof/bit_buffer.read.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/bit_buffer.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/bit_buffer.write.opt
lib/mercury/ints/asm_fast.gc.memprof/bit_buffer.write.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/bitmap.opt
lib/mercury/ints/asm_fast.gc.memprof/bitmap.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/bool.opt
lib/mercury/ints/asm_fast.gc.memprof/bool.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/bt_array.opt
lib/mercury/ints/asm_fast.gc.memprof/bt_array.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/builtin.opt
lib/mercury/ints/asm_fast.gc.memprof/builtin.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.memprof/calendar.opt
lib/mercury/ints/asm_fast.gc.memprof/calendar.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/char.opt
lib/mercury/ints/asm_fast.gc.memprof/char.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/construct.opt
lib/mercury/ints/asm_fast.gc.memprof/construct.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.memprof/cord.opt
lib/mercury/ints/asm_fast.gc.memprof/cord.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/counter.opt
lib/mercury/ints/asm_fast.gc.memprof/counter.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/deconstruct.opt
lib/mercury/ints/asm_fast.gc.memprof/deconstruct.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.memprof/digraph.opt
lib/mercury/ints/asm_fast.gc.memprof/digraph.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/dir.opt
lib/mercury/ints/asm_fast.gc.memprof/dir.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/enum.opt
lib/mercury/ints/asm_fast.gc.memprof/enum.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/eqvclass.opt
lib/mercury/ints/asm_fast.gc.memprof/eqvclass.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.memprof/erlang_builtin.opt
lib/mercury/ints/asm_fast.gc.memprof/erlang_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/erlang_rtti_implementation.opt
lib/mercury/ints/asm_fast.gc.memprof/erlang_rtti_implementation.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/exception.opt
lib/mercury/ints/asm_fast.gc.memprof/exception.trans_opt
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/ints/asm_fast.gc.memprof/fat_sparse_bitset.opt
lib/mercury/ints/asm_fast.gc.memprof/fat_sparse_bitset.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/float.opt
lib/mercury/ints/asm_fast.gc.memprof/float.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/gc.opt
lib/mercury/ints/asm_fast.gc.memprof/gc.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/getopt.opt
lib/mercury/ints/asm_fast.gc.memprof/getopt.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.memprof/getopt_io.opt
lib/mercury/ints/asm_fast.gc.memprof/getopt_io.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/hash_table.opt
lib/mercury/ints/asm_fast.gc.memprof/hash_table.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.memprof/injection.opt
lib/mercury/ints/asm_fast.gc.memprof/injection.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/int.opt
lib/mercury/ints/asm_fast.gc.memprof/int.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/integer.opt
lib/mercury/ints/asm_fast.gc.memprof/integer.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/io.opt
lib/mercury/ints/asm_fast.gc.memprof/io.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.memprof/lazy.opt
lib/mercury/ints/asm_fast.gc.memprof/lazy.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/lexer.opt
lib/mercury/ints/asm_fast.gc.memprof/lexer.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/library.opt
lib/mercury/ints/asm_fast.gc.memprof/library.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/list.opt
lib/mercury/ints/asm_fast.gc.memprof/list.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/map.opt
lib/mercury/ints/asm_fast.gc.memprof/map.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/math.opt
lib/mercury/ints/asm_fast.gc.memprof/math.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.memprof/maybe.opt
lib/mercury/ints/asm_fast.gc.memprof/maybe.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/mer_std.opt
lib/mercury/ints/asm_fast.gc.memprof/mer_std.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/multi_map.opt
lib/mercury/ints/asm_fast.gc.memprof/multi_map.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.memprof/mutvar.opt
lib/mercury/ints/asm_fast.gc.memprof/mutvar.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/ops.opt
lib/mercury/ints/asm_fast.gc.memprof/ops.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.memprof/pair.opt
lib/mercury/ints/asm_fast.gc.memprof/pair.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.memprof/par_builtin.opt
lib/mercury/ints/asm_fast.gc.memprof/par_builtin.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/parser.opt
lib/mercury/ints/asm_fast.gc.memprof/parser.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.memprof/parsing_utils.opt
lib/mercury/ints/asm_fast.gc.memprof/parsing_utils.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/pprint.opt
lib/mercury/ints/asm_fast.gc.memprof/pprint.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/pqueue.opt
lib/mercury/ints/asm_fast.gc.memprof/pqueue.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.memprof/pretty_printer.opt
lib/mercury/ints/asm_fast.gc.memprof/pretty_printer.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/private_builtin.opt
lib/mercury/ints/asm_fast.gc.memprof/private_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/profiling_builtin.opt
lib/mercury/ints/asm_fast.gc.memprof/profiling_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/prolog.opt
lib/mercury/ints/asm_fast.gc.memprof/prolog.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/queue.opt
lib/mercury/ints/asm_fast.gc.memprof/queue.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/random.opt
lib/mercury/ints/asm_fast.gc.memprof/random.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/rational.opt
lib/mercury/ints/asm_fast.gc.memprof/rational.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/rbtree.opt
lib/mercury/ints/asm_fast.gc.memprof/rbtree.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.memprof/region_builtin.opt
lib/mercury/ints/asm_fast.gc.memprof/region_builtin.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/require.opt
lib/mercury/ints/asm_fast.gc.memprof/require.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.memprof/robdd.opt
lib/mercury/ints/asm_fast.gc.memprof/robdd.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/rtree.opt
lib/mercury/ints/asm_fast.gc.memprof/rtree.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/rtti_implementation.opt
lib/mercury/ints/asm_fast.gc.memprof/rtti_implementation.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/set.opt
lib/mercury/ints/asm_fast.gc.memprof/set.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/set_bbbtree.opt
lib/mercury/ints/asm_fast.gc.memprof/set_bbbtree.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.memprof/set_ctree234.opt
lib/mercury/ints/asm_fast.gc.memprof/set_ctree234.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/set_ordlist.opt
lib/mercury/ints/asm_fast.gc.memprof/set_ordlist.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.memprof/set_tree234.opt
lib/mercury/ints/asm_fast.gc.memprof/set_tree234.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/set_unordlist.opt
lib/mercury/ints/asm_fast.gc.memprof/set_unordlist.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.memprof/solutions.opt
lib/mercury/ints/asm_fast.gc.memprof/solutions.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/sparse_bitset.opt
lib/mercury/ints/asm_fast.gc.memprof/sparse_bitset.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/stack.opt
lib/mercury/ints/asm_fast.gc.memprof/stack.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/std_util.opt
lib/mercury/ints/asm_fast.gc.memprof/std_util.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.memprof/stm_builtin.opt
lib/mercury/ints/asm_fast.gc.memprof/stm_builtin.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/store.opt
lib/mercury/ints/asm_fast.gc.memprof/store.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.memprof/stream.opt
lib/mercury/ints/asm_fast.gc.memprof/stream.string_writer.opt
lib/mercury/ints/asm_fast.gc.memprof/stream.string_writer.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/stream.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/string.builder.opt
lib/mercury/ints/asm_fast.gc.memprof/string.builder.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/string.opt
lib/mercury/ints/asm_fast.gc.memprof/string.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/table_builtin.opt
lib/mercury/ints/asm_fast.gc.memprof/table_builtin.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.memprof/table_statistics.opt
lib/mercury/ints/asm_fast.gc.memprof/table_statistics.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/term.opt
lib/mercury/ints/asm_fast.gc.memprof/term.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/term_io.opt
lib/mercury/ints/asm_fast.gc.memprof/term_io.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.memprof/term_size_prof_builtin.opt
lib/mercury/ints/asm_fast.gc.memprof/term_size_prof_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/term_to_xml.opt
lib/mercury/ints/asm_fast.gc.memprof/term_to_xml.trans_opt
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/ints/asm_fast.gc.memprof/test_bitset.opt
lib/mercury/ints/asm_fast.gc.memprof/test_bitset.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.memprof/thread.channel.opt
lib/mercury/ints/asm_fast.gc.memprof/thread.channel.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/thread.mvar.opt
lib/mercury/ints/asm_fast.gc.memprof/thread.mvar.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/thread.opt
lib/mercury/ints/asm_fast.gc.memprof/thread.semaphore.opt
lib/mercury/ints/asm_fast.gc.memprof/thread.semaphore.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/thread.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/time.opt
lib/mercury/ints/asm_fast.gc.memprof/time.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/tree234.opt
lib/mercury/ints/asm_fast.gc.memprof/tree234.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.memprof/tree_bitset.opt
lib/mercury/ints/asm_fast.gc.memprof/tree_bitset.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/type_desc.opt
lib/mercury/ints/asm_fast.gc.memprof/type_desc.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.memprof/unit.opt
lib/mercury/ints/asm_fast.gc.memprof/unit.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/univ.opt
lib/mercury/ints/asm_fast.gc.memprof/univ.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.memprof/varset.opt
lib/mercury/ints/asm_fast.gc.memprof/varset.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.memprof/version_array.opt
lib/mercury/ints/asm_fast.gc.memprof/version_array.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/version_array2d.opt
lib/mercury/ints/asm_fast.gc.memprof/version_array2d.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/version_bitmap.opt
lib/mercury/ints/asm_fast.gc.memprof/version_bitmap.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/version_hash_table.opt
lib/mercury/ints/asm_fast.gc.memprof/version_hash_table.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/version_store.opt
lib/mercury/ints/asm_fast.gc.memprof/version_store.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/Mercury/opts
lib/mercury/ints/asm_fast.gc.prof/Mercury/trans_opts
lib/mercury/ints/asm_fast.gc.prof/array.opt
lib/mercury/ints/asm_fast.gc.prof/array.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.prof/array2d.opt
lib/mercury/ints/asm_fast.gc.prof/array2d.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/assoc_list.opt
lib/mercury/ints/asm_fast.gc.prof/assoc_list.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.prof/backjump.opt
lib/mercury/ints/asm_fast.gc.prof/backjump.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/bag.opt
lib/mercury/ints/asm_fast.gc.prof/bag.trans_opt
lib/mercury/ints/asm_fast.gc.prof/benchmarking.opt
lib/mercury/ints/asm_fast.gc.prof/benchmarking.trans_opt
lib/mercury/ints/asm_fast.gc.prof/bimap.opt
lib/mercury/ints/asm_fast.gc.prof/bimap.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.prof/bit_buffer.opt
lib/mercury/ints/asm_fast.gc.prof/bit_buffer.read.opt
lib/mercury/ints/asm_fast.gc.prof/bit_buffer.read.trans_opt
lib/mercury/ints/asm_fast.gc.prof/bit_buffer.trans_opt
lib/mercury/ints/asm_fast.gc.prof/bit_buffer.write.opt
lib/mercury/ints/asm_fast.gc.prof/bit_buffer.write.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/bitmap.opt
lib/mercury/ints/asm_fast.gc.prof/bitmap.trans_opt
lib/mercury/ints/asm_fast.gc.prof/bool.opt
lib/mercury/ints/asm_fast.gc.prof/bool.trans_opt
lib/mercury/ints/asm_fast.gc.prof/bt_array.opt
lib/mercury/ints/asm_fast.gc.prof/bt_array.trans_opt
lib/mercury/ints/asm_fast.gc.prof/builtin.opt
lib/mercury/ints/asm_fast.gc.prof/builtin.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.prof/calendar.opt
lib/mercury/ints/asm_fast.gc.prof/calendar.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/char.opt
lib/mercury/ints/asm_fast.gc.prof/char.trans_opt
lib/mercury/ints/asm_fast.gc.prof/construct.opt
lib/mercury/ints/asm_fast.gc.prof/construct.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.prof/cord.opt
lib/mercury/ints/asm_fast.gc.prof/cord.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/counter.opt
lib/mercury/ints/asm_fast.gc.prof/counter.trans_opt
lib/mercury/ints/asm_fast.gc.prof/deconstruct.opt
lib/mercury/ints/asm_fast.gc.prof/deconstruct.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.prof/digraph.opt
lib/mercury/ints/asm_fast.gc.prof/digraph.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/dir.opt
lib/mercury/ints/asm_fast.gc.prof/dir.trans_opt
lib/mercury/ints/asm_fast.gc.prof/enum.opt
lib/mercury/ints/asm_fast.gc.prof/enum.trans_opt
lib/mercury/ints/asm_fast.gc.prof/eqvclass.opt
lib/mercury/ints/asm_fast.gc.prof/eqvclass.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.prof/erlang_builtin.opt
lib/mercury/ints/asm_fast.gc.prof/erlang_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.prof/erlang_rtti_implementation.opt
lib/mercury/ints/asm_fast.gc.prof/erlang_rtti_implementation.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/exception.opt
lib/mercury/ints/asm_fast.gc.prof/exception.trans_opt
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/ints/asm_fast.gc.prof/fat_sparse_bitset.opt
lib/mercury/ints/asm_fast.gc.prof/fat_sparse_bitset.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/float.opt
lib/mercury/ints/asm_fast.gc.prof/float.trans_opt
lib/mercury/ints/asm_fast.gc.prof/gc.opt
lib/mercury/ints/asm_fast.gc.prof/gc.trans_opt
lib/mercury/ints/asm_fast.gc.prof/getopt.opt
lib/mercury/ints/asm_fast.gc.prof/getopt.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.prof/getopt_io.opt
lib/mercury/ints/asm_fast.gc.prof/getopt_io.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/hash_table.opt
lib/mercury/ints/asm_fast.gc.prof/hash_table.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.prof/injection.opt
lib/mercury/ints/asm_fast.gc.prof/injection.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/int.opt
lib/mercury/ints/asm_fast.gc.prof/int.trans_opt
lib/mercury/ints/asm_fast.gc.prof/integer.opt
lib/mercury/ints/asm_fast.gc.prof/integer.trans_opt
lib/mercury/ints/asm_fast.gc.prof/io.opt
lib/mercury/ints/asm_fast.gc.prof/io.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.prof/lazy.opt
lib/mercury/ints/asm_fast.gc.prof/lazy.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/lexer.opt
lib/mercury/ints/asm_fast.gc.prof/lexer.trans_opt
lib/mercury/ints/asm_fast.gc.prof/library.opt
lib/mercury/ints/asm_fast.gc.prof/library.trans_opt
lib/mercury/ints/asm_fast.gc.prof/list.opt
lib/mercury/ints/asm_fast.gc.prof/list.trans_opt
lib/mercury/ints/asm_fast.gc.prof/map.opt
lib/mercury/ints/asm_fast.gc.prof/map.trans_opt
lib/mercury/ints/asm_fast.gc.prof/math.opt
lib/mercury/ints/asm_fast.gc.prof/math.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.prof/maybe.opt
lib/mercury/ints/asm_fast.gc.prof/maybe.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/mer_std.opt
lib/mercury/ints/asm_fast.gc.prof/mer_std.trans_opt
lib/mercury/ints/asm_fast.gc.prof/multi_map.opt
lib/mercury/ints/asm_fast.gc.prof/multi_map.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.prof/mutvar.opt
lib/mercury/ints/asm_fast.gc.prof/mutvar.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/ops.opt
lib/mercury/ints/asm_fast.gc.prof/ops.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.prof/pair.opt
lib/mercury/ints/asm_fast.gc.prof/pair.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.prof/par_builtin.opt
lib/mercury/ints/asm_fast.gc.prof/par_builtin.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/parser.opt
lib/mercury/ints/asm_fast.gc.prof/parser.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.prof/parsing_utils.opt
lib/mercury/ints/asm_fast.gc.prof/parsing_utils.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/pprint.opt
lib/mercury/ints/asm_fast.gc.prof/pprint.trans_opt
lib/mercury/ints/asm_fast.gc.prof/pqueue.opt
lib/mercury/ints/asm_fast.gc.prof/pqueue.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.prof/pretty_printer.opt
lib/mercury/ints/asm_fast.gc.prof/pretty_printer.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/private_builtin.opt
lib/mercury/ints/asm_fast.gc.prof/private_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.prof/profiling_builtin.opt
lib/mercury/ints/asm_fast.gc.prof/profiling_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.prof/prolog.opt
lib/mercury/ints/asm_fast.gc.prof/prolog.trans_opt
lib/mercury/ints/asm_fast.gc.prof/queue.opt
lib/mercury/ints/asm_fast.gc.prof/queue.trans_opt
lib/mercury/ints/asm_fast.gc.prof/random.opt
lib/mercury/ints/asm_fast.gc.prof/random.trans_opt
lib/mercury/ints/asm_fast.gc.prof/rational.opt
lib/mercury/ints/asm_fast.gc.prof/rational.trans_opt
lib/mercury/ints/asm_fast.gc.prof/rbtree.opt
lib/mercury/ints/asm_fast.gc.prof/rbtree.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.prof/region_builtin.opt
lib/mercury/ints/asm_fast.gc.prof/region_builtin.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/require.opt
lib/mercury/ints/asm_fast.gc.prof/require.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.prof/robdd.opt
lib/mercury/ints/asm_fast.gc.prof/robdd.trans_opt
lib/mercury/ints/asm_fast.gc.prof/rtree.opt
lib/mercury/ints/asm_fast.gc.prof/rtree.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/rtti_implementation.opt
lib/mercury/ints/asm_fast.gc.prof/rtti_implementation.trans_opt
lib/mercury/ints/asm_fast.gc.prof/set.opt
lib/mercury/ints/asm_fast.gc.prof/set.trans_opt
lib/mercury/ints/asm_fast.gc.prof/set_bbbtree.opt
lib/mercury/ints/asm_fast.gc.prof/set_bbbtree.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.prof/set_ctree234.opt
lib/mercury/ints/asm_fast.gc.prof/set_ctree234.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/set_ordlist.opt
lib/mercury/ints/asm_fast.gc.prof/set_ordlist.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.prof/set_tree234.opt
lib/mercury/ints/asm_fast.gc.prof/set_tree234.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/set_unordlist.opt
lib/mercury/ints/asm_fast.gc.prof/set_unordlist.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.prof/solutions.opt
lib/mercury/ints/asm_fast.gc.prof/solutions.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/sparse_bitset.opt
lib/mercury/ints/asm_fast.gc.prof/sparse_bitset.trans_opt
lib/mercury/ints/asm_fast.gc.prof/stack.opt
lib/mercury/ints/asm_fast.gc.prof/stack.trans_opt
lib/mercury/ints/asm_fast.gc.prof/std_util.opt
lib/mercury/ints/asm_fast.gc.prof/std_util.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.prof/stm_builtin.opt
lib/mercury/ints/asm_fast.gc.prof/stm_builtin.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/store.opt
lib/mercury/ints/asm_fast.gc.prof/store.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.prof/stream.opt
lib/mercury/ints/asm_fast.gc.prof/stream.string_writer.opt
lib/mercury/ints/asm_fast.gc.prof/stream.string_writer.trans_opt
lib/mercury/ints/asm_fast.gc.prof/stream.trans_opt
lib/mercury/ints/asm_fast.gc.prof/string.builder.opt
lib/mercury/ints/asm_fast.gc.prof/string.builder.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/string.opt
lib/mercury/ints/asm_fast.gc.prof/string.trans_opt
lib/mercury/ints/asm_fast.gc.prof/table_builtin.opt
lib/mercury/ints/asm_fast.gc.prof/table_builtin.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.prof/table_statistics.opt
lib/mercury/ints/asm_fast.gc.prof/table_statistics.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/term.opt
lib/mercury/ints/asm_fast.gc.prof/term.trans_opt
lib/mercury/ints/asm_fast.gc.prof/term_io.opt
lib/mercury/ints/asm_fast.gc.prof/term_io.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.prof/term_size_prof_builtin.opt
lib/mercury/ints/asm_fast.gc.prof/term_size_prof_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.prof/term_to_xml.opt
lib/mercury/ints/asm_fast.gc.prof/term_to_xml.trans_opt
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/ints/asm_fast.gc.prof/test_bitset.opt
lib/mercury/ints/asm_fast.gc.prof/test_bitset.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.prof/thread.channel.opt
lib/mercury/ints/asm_fast.gc.prof/thread.channel.trans_opt
lib/mercury/ints/asm_fast.gc.prof/thread.mvar.opt
lib/mercury/ints/asm_fast.gc.prof/thread.mvar.trans_opt
lib/mercury/ints/asm_fast.gc.prof/thread.opt
lib/mercury/ints/asm_fast.gc.prof/thread.semaphore.opt
lib/mercury/ints/asm_fast.gc.prof/thread.semaphore.trans_opt
lib/mercury/ints/asm_fast.gc.prof/thread.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/time.opt
lib/mercury/ints/asm_fast.gc.prof/time.trans_opt
lib/mercury/ints/asm_fast.gc.prof/tree234.opt
lib/mercury/ints/asm_fast.gc.prof/tree234.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.prof/tree_bitset.opt
lib/mercury/ints/asm_fast.gc.prof/tree_bitset.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/type_desc.opt
lib/mercury/ints/asm_fast.gc.prof/type_desc.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.prof/unit.opt
lib/mercury/ints/asm_fast.gc.prof/unit.trans_opt
lib/mercury/ints/asm_fast.gc.prof/univ.opt
lib/mercury/ints/asm_fast.gc.prof/univ.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc.prof/varset.opt
lib/mercury/ints/asm_fast.gc.prof/varset.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc.prof/version_array.opt
lib/mercury/ints/asm_fast.gc.prof/version_array.trans_opt
lib/mercury/ints/asm_fast.gc.prof/version_array2d.opt
lib/mercury/ints/asm_fast.gc.prof/version_array2d.trans_opt
lib/mercury/ints/asm_fast.gc.prof/version_bitmap.opt
lib/mercury/ints/asm_fast.gc.prof/version_bitmap.trans_opt
lib/mercury/ints/asm_fast.gc.prof/version_hash_table.opt
lib/mercury/ints/asm_fast.gc.prof/version_hash_table.trans_opt
lib/mercury/ints/asm_fast.gc.prof/version_store.opt
lib/mercury/ints/asm_fast.gc.prof/version_store.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.profdeep/Mercury/opts
lib/mercury/ints/asm_fast.gc.profdeep/Mercury/trans_opts
lib/mercury/ints/asm_fast.gc.profdeep/array.opt
lib/mercury/ints/asm_fast.gc.profdeep/array.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/array2d.opt
lib/mercury/ints/asm_fast.gc.profdeep/array2d.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/assoc_list.opt
lib/mercury/ints/asm_fast.gc.profdeep/assoc_list.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/backjump.opt
lib/mercury/ints/asm_fast.gc.profdeep/backjump.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/bag.opt
lib/mercury/ints/asm_fast.gc.profdeep/bag.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/benchmarking.opt
lib/mercury/ints/asm_fast.gc.profdeep/benchmarking.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/bimap.opt
lib/mercury/ints/asm_fast.gc.profdeep/bimap.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/bit_buffer.opt
lib/mercury/ints/asm_fast.gc.profdeep/bit_buffer.read.opt
lib/mercury/ints/asm_fast.gc.profdeep/bit_buffer.read.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/bit_buffer.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/bit_buffer.write.opt
lib/mercury/ints/asm_fast.gc.profdeep/bit_buffer.write.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/bitmap.opt
lib/mercury/ints/asm_fast.gc.profdeep/bitmap.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/bool.opt
lib/mercury/ints/asm_fast.gc.profdeep/bool.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/bt_array.opt
lib/mercury/ints/asm_fast.gc.profdeep/bt_array.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/builtin.opt
lib/mercury/ints/asm_fast.gc.profdeep/builtin.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/calendar.opt
lib/mercury/ints/asm_fast.gc.profdeep/calendar.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/char.opt
lib/mercury/ints/asm_fast.gc.profdeep/char.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/construct.opt
lib/mercury/ints/asm_fast.gc.profdeep/construct.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/cord.opt
lib/mercury/ints/asm_fast.gc.profdeep/cord.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/counter.opt
lib/mercury/ints/asm_fast.gc.profdeep/counter.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/deconstruct.opt
lib/mercury/ints/asm_fast.gc.profdeep/deconstruct.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/digraph.opt
lib/mercury/ints/asm_fast.gc.profdeep/digraph.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/dir.opt
lib/mercury/ints/asm_fast.gc.profdeep/dir.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/enum.opt
lib/mercury/ints/asm_fast.gc.profdeep/enum.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/eqvclass.opt
lib/mercury/ints/asm_fast.gc.profdeep/eqvclass.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/erlang_builtin.opt
lib/mercury/ints/asm_fast.gc.profdeep/erlang_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/erlang_rtti_implementation.opt
lib/mercury/ints/asm_fast.gc.profdeep/erlang_rtti_implementation.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/exception.opt
lib/mercury/ints/asm_fast.gc.profdeep/exception.trans_opt
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/ints/asm_fast.gc.profdeep/fat_sparse_bitset.opt
lib/mercury/ints/asm_fast.gc.profdeep/fat_sparse_bitset.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.profdeep/float.opt
lib/mercury/ints/asm_fast.gc.profdeep/float.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/gc.opt
lib/mercury/ints/asm_fast.gc.profdeep/gc.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/getopt.opt
lib/mercury/ints/asm_fast.gc.profdeep/getopt.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/getopt_io.opt
lib/mercury/ints/asm_fast.gc.profdeep/getopt_io.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/hash_table.opt
lib/mercury/ints/asm_fast.gc.profdeep/hash_table.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/injection.opt
lib/mercury/ints/asm_fast.gc.profdeep/injection.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/int.opt
lib/mercury/ints/asm_fast.gc.profdeep/int.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/integer.opt
lib/mercury/ints/asm_fast.gc.profdeep/integer.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/io.opt
lib/mercury/ints/asm_fast.gc.profdeep/io.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/lazy.opt
lib/mercury/ints/asm_fast.gc.profdeep/lazy.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/lexer.opt
lib/mercury/ints/asm_fast.gc.profdeep/lexer.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/library.opt
lib/mercury/ints/asm_fast.gc.profdeep/library.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/list.opt
lib/mercury/ints/asm_fast.gc.profdeep/list.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/map.opt
lib/mercury/ints/asm_fast.gc.profdeep/map.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/math.opt
lib/mercury/ints/asm_fast.gc.profdeep/math.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/maybe.opt
lib/mercury/ints/asm_fast.gc.profdeep/maybe.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/mer_std.opt
lib/mercury/ints/asm_fast.gc.profdeep/mer_std.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/multi_map.opt
lib/mercury/ints/asm_fast.gc.profdeep/multi_map.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/mutvar.opt
lib/mercury/ints/asm_fast.gc.profdeep/mutvar.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/ops.opt
lib/mercury/ints/asm_fast.gc.profdeep/ops.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/pair.opt
lib/mercury/ints/asm_fast.gc.profdeep/pair.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/par_builtin.opt
lib/mercury/ints/asm_fast.gc.profdeep/par_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/parser.opt
lib/mercury/ints/asm_fast.gc.profdeep/parser.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/parsing_utils.opt
lib/mercury/ints/asm_fast.gc.profdeep/parsing_utils.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/pprint.opt
lib/mercury/ints/asm_fast.gc.profdeep/pprint.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/pqueue.opt
lib/mercury/ints/asm_fast.gc.profdeep/pqueue.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/pretty_printer.opt
lib/mercury/ints/asm_fast.gc.profdeep/pretty_printer.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/private_builtin.opt
lib/mercury/ints/asm_fast.gc.profdeep/private_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/profiling_builtin.opt
lib/mercury/ints/asm_fast.gc.profdeep/profiling_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/prolog.opt
lib/mercury/ints/asm_fast.gc.profdeep/prolog.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/queue.opt
lib/mercury/ints/asm_fast.gc.profdeep/queue.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/random.opt
lib/mercury/ints/asm_fast.gc.profdeep/random.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/rational.opt
lib/mercury/ints/asm_fast.gc.profdeep/rational.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/rbtree.opt
lib/mercury/ints/asm_fast.gc.profdeep/rbtree.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/region_builtin.opt
lib/mercury/ints/asm_fast.gc.profdeep/region_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/require.opt
lib/mercury/ints/asm_fast.gc.profdeep/require.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/robdd.opt
lib/mercury/ints/asm_fast.gc.profdeep/robdd.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/rtree.opt
lib/mercury/ints/asm_fast.gc.profdeep/rtree.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/rtti_implementation.opt
lib/mercury/ints/asm_fast.gc.profdeep/rtti_implementation.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/set.opt
lib/mercury/ints/asm_fast.gc.profdeep/set.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/set_bbbtree.opt
lib/mercury/ints/asm_fast.gc.profdeep/set_bbbtree.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/set_ctree234.opt
lib/mercury/ints/asm_fast.gc.profdeep/set_ctree234.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/set_ordlist.opt
lib/mercury/ints/asm_fast.gc.profdeep/set_ordlist.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/set_tree234.opt
lib/mercury/ints/asm_fast.gc.profdeep/set_tree234.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/set_unordlist.opt
lib/mercury/ints/asm_fast.gc.profdeep/set_unordlist.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/solutions.opt
lib/mercury/ints/asm_fast.gc.profdeep/solutions.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/sparse_bitset.opt
lib/mercury/ints/asm_fast.gc.profdeep/sparse_bitset.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/stack.opt
lib/mercury/ints/asm_fast.gc.profdeep/stack.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/std_util.opt
lib/mercury/ints/asm_fast.gc.profdeep/std_util.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/stm_builtin.opt
lib/mercury/ints/asm_fast.gc.profdeep/stm_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/store.opt
lib/mercury/ints/asm_fast.gc.profdeep/store.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/stream.opt
lib/mercury/ints/asm_fast.gc.profdeep/stream.string_writer.opt
lib/mercury/ints/asm_fast.gc.profdeep/stream.string_writer.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/stream.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/string.builder.opt
lib/mercury/ints/asm_fast.gc.profdeep/string.builder.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/string.opt
lib/mercury/ints/asm_fast.gc.profdeep/string.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/table_builtin.opt
lib/mercury/ints/asm_fast.gc.profdeep/table_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/table_statistics.opt
lib/mercury/ints/asm_fast.gc.profdeep/table_statistics.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/term.opt
lib/mercury/ints/asm_fast.gc.profdeep/term.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/term_io.opt
lib/mercury/ints/asm_fast.gc.profdeep/term_io.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/term_size_prof_builtin.opt
lib/mercury/ints/asm_fast.gc.profdeep/term_size_prof_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/term_to_xml.opt
lib/mercury/ints/asm_fast.gc.profdeep/term_to_xml.trans_opt
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/ints/asm_fast.gc.profdeep/test_bitset.opt
lib/mercury/ints/asm_fast.gc.profdeep/test_bitset.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.profdeep/thread.channel.opt
lib/mercury/ints/asm_fast.gc.profdeep/thread.channel.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/thread.mvar.opt
lib/mercury/ints/asm_fast.gc.profdeep/thread.mvar.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/thread.opt
lib/mercury/ints/asm_fast.gc.profdeep/thread.semaphore.opt
lib/mercury/ints/asm_fast.gc.profdeep/thread.semaphore.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/thread.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/time.opt
lib/mercury/ints/asm_fast.gc.profdeep/time.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/tree234.opt
lib/mercury/ints/asm_fast.gc.profdeep/tree234.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/tree_bitset.opt
lib/mercury/ints/asm_fast.gc.profdeep/tree_bitset.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/type_desc.opt
lib/mercury/ints/asm_fast.gc.profdeep/type_desc.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/unit.opt
lib/mercury/ints/asm_fast.gc.profdeep/unit.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/univ.opt
lib/mercury/ints/asm_fast.gc.profdeep/univ.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/varset.opt
lib/mercury/ints/asm_fast.gc.profdeep/varset.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/version_array.opt
lib/mercury/ints/asm_fast.gc.profdeep/version_array.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/version_array2d.opt
lib/mercury/ints/asm_fast.gc.profdeep/version_array2d.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/version_bitmap.opt
lib/mercury/ints/asm_fast.gc.profdeep/version_bitmap.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/version_hash_table.opt
lib/mercury/ints/asm_fast.gc.profdeep/version_hash_table.trans_opt
lib/mercury/ints/asm_fast.gc.profdeep/version_store.opt
lib/mercury/ints/asm_fast.gc.profdeep/version_store.trans_opt
Update to Mercury 14.01.1 NEWS for Mercury 14.01.1 ------------------------ This is a bug-fix release. * The function string.string/1 and related functions now handle version arrays properly. * Fix resource leaks in dir fold predicates. * The mfilterjavac program is now generated with the correct file extension on Windows. * A problem that caused compilation of the Boehm GC to fail on 64-bit openSUSE 13.1 systems has been fixed. (Github issue #14) * The documentation now builds correctly on Cygwin systems. * The script configure_mingw_cross now supports 64-bit Windows targets. * We have added workarounds for problems with (arguably broken) system headers on MinGW and MinGW64 systems. * The MinGW port now builds in the absence of POSIX threads library. * Low-level C parallel grades now work on Windows instead of crashing at startup. (Bug #338) * We now use thread-safe alternatives to strerror(). (Bug #340) * We have added the configure option --enable-gc-mmap. * We configure Boehm GC to use mmap in threaded grades on Linux to avoid conflicts with glibc malloc leading to memory corruption. * A problem that caused string.format/[23] to sometimes return incorrect results when formatting floats with the 'g' conversion specifier has been fixed. This bug only affected the non-C backends. (Bug #342) * string.format now handles special float values (i.e. nan, inf, and -inf) correctly with the non-C backends. * A bug that caused io.write_float/[34] to append ".0" to float special values has been fixed. This bug affected the C and C# backends. * In the C# and Java grades, the predicate string.from_char_list now implements the documented behaviour for input lists containing null characters (i.e. it throws an exception). Likewise, for string.from_reverse_char_list in the C# grade. * We have fixed a problem that caused `mmc --make' to attempt to install libraries in non-existent grades. Changes to the Mercury compiler: * The compiler now supports stripping of executables in a separate post-link step. The new options, --strip-executable-command, --strip-executable-shared-flags and --strip-executable-static-flags are used to control this. (This is now the default on Mac OS X systems.) NEWS for Mercury 14.01 ---------------------- Changes to the Mercury language: * Repeated type variables may now occur in the heads of type class instances. For example, instance declarations like the following are now allowed: :- instance foo(list(T), map(T, T)). Changes to the Mercury standard library: * We have added the function cord.condense/1. * The following functions in the standard library's cord module now use constant stack space: foldl/3, foldl_pred/4. * We have added the following predicates to the array and version_array modules: is_empty/1, all_true/2 and all_false/2. * We have added the following predicates and functions to the map module: det_min_key/1, det_max_key/1, foldl2_values/6 and foldl3_values/8. * We have added the following predicates to the list module: foldr2/6, foldr3/8, det_take/3 and map_foldr/5. * We have added the following predicates to the bag module: foldl/4 and foldl2/6. * We have added the following predicates to the assoc_list module: foldl2_values/6 and foldl3_values/8. * We have added the following predicates and functions to the pqueue module: is_empty/1, peek/3, peek_key/2, peek_value/2, det_peek/3, merge/3, det_peek_key/1 and det_peek_value/1. * We have added the predicate bimap.equal/2. * We have added the following predicates to the int module: fold_up3/9 and fold_down3/9. Changes to the Mercury compiler: * On Mac OS X systems the compiler is now configured use the version of the host system as the default value for the deployment target. A new configuration option, `--with-macosx-deployment-target', allows an alternative value to be selected at configuration time. Portability improvements: * We have made the implementation compatible with GCC 4.8 and Visual Studio 2013. * We have made the implementation compatible with OS X 10.9. Changes to the extras distribution: * We've added a library that provides support for accessing the function trail from Mercury code.
2015-01-04 20:37:02 +01:00
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/Mercury/opts
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/Mercury/trans_opts
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/array.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/array.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/array2d.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/array2d.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/assoc_list.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/assoc_list.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/backjump.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/backjump.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/bag.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/bag.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/benchmarking.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/benchmarking.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/bimap.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/bimap.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/bit_buffer.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/bit_buffer.read.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/bit_buffer.read.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/bit_buffer.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/bit_buffer.write.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/bit_buffer.write.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/bitmap.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/bitmap.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/bool.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/bool.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/bt_array.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/bt_array.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/builtin.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/builtin.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/calendar.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/calendar.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/char.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/char.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/construct.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/construct.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/cord.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/cord.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/counter.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/counter.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/deconstruct.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/deconstruct.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/digraph.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/digraph.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/dir.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/dir.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/enum.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/enum.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/eqvclass.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/eqvclass.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/erlang_builtin.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/erlang_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/erlang_rtti_implementation.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/erlang_rtti_implementation.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/exception.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/exception.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/fat_sparse_bitset.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/fat_sparse_bitset.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/float.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/float.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/gc.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/gc.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/getopt.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/getopt.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/getopt_io.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/getopt_io.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/hash_table.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/hash_table.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/injection.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/injection.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/int.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/int.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/integer.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/integer.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/io.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/io.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/lazy.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/lazy.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/lexer.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/lexer.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/library.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/library.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/list.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/list.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/map.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/map.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/math.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/math.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/maybe.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/maybe.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/mer_std.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/mer_std.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/multi_map.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/multi_map.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/mutvar.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/mutvar.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/ops.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/ops.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/pair.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/pair.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/par_builtin.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/par_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/parser.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/parser.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/parsing_utils.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/parsing_utils.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/pprint.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/pprint.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/pqueue.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/pqueue.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/pretty_printer.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/pretty_printer.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/private_builtin.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/private_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/profiling_builtin.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/profiling_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/prolog.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/prolog.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/queue.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/queue.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/random.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/random.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/rational.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/rational.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/rbtree.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/rbtree.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/region_builtin.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/region_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/require.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/require.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/robdd.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/robdd.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/rtree.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/rtree.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/rtti_implementation.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/rtti_implementation.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/set.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/set.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/set_bbbtree.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/set_bbbtree.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/set_ctree234.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/set_ctree234.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/set_ordlist.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/set_ordlist.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/set_tree234.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/set_tree234.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/set_unordlist.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/set_unordlist.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/solutions.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/solutions.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/sparse_bitset.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/sparse_bitset.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/stack.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/stack.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/std_util.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/std_util.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/stm_builtin.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/stm_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/store.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/store.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/stream.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/stream.string_writer.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/stream.string_writer.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/stream.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/string.builder.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/string.builder.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/string.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/string.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/table_builtin.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/table_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/table_statistics.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/table_statistics.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/term.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/term.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/term_io.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/term_io.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/term_size_prof_builtin.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/term_size_prof_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/term_to_xml.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/term_to_xml.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/test_bitset.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/test_bitset.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/thread.channel.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/thread.channel.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/thread.mvar.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/thread.mvar.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/thread.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/thread.semaphore.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/thread.semaphore.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/thread.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/time.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/time.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/tree234.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/tree234.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/tree_bitset.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/tree_bitset.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/type_desc.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/type_desc.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/unit.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/unit.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/univ.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/univ.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/varset.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/varset.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/version_array.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/version_array.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/version_array2d.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/version_array2d.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/version_bitmap.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/version_bitmap.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/version_hash_table.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/version_hash_table.trans_opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/version_store.opt
lib/mercury/ints/asm_fast.gc.trseg.debug.stseg/version_store.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.trseg/Mercury/opts
lib/mercury/ints/asm_fast.gc.trseg/Mercury/trans_opts
lib/mercury/ints/asm_fast.gc.trseg/array.opt
lib/mercury/ints/asm_fast.gc.trseg/array.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/array2d.opt
lib/mercury/ints/asm_fast.gc.trseg/array2d.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/assoc_list.opt
lib/mercury/ints/asm_fast.gc.trseg/assoc_list.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/backjump.opt
lib/mercury/ints/asm_fast.gc.trseg/backjump.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/bag.opt
lib/mercury/ints/asm_fast.gc.trseg/bag.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/benchmarking.opt
lib/mercury/ints/asm_fast.gc.trseg/benchmarking.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/bimap.opt
lib/mercury/ints/asm_fast.gc.trseg/bimap.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/bit_buffer.opt
lib/mercury/ints/asm_fast.gc.trseg/bit_buffer.read.opt
lib/mercury/ints/asm_fast.gc.trseg/bit_buffer.read.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/bit_buffer.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/bit_buffer.write.opt
lib/mercury/ints/asm_fast.gc.trseg/bit_buffer.write.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/bitmap.opt
lib/mercury/ints/asm_fast.gc.trseg/bitmap.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/bool.opt
lib/mercury/ints/asm_fast.gc.trseg/bool.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/bt_array.opt
lib/mercury/ints/asm_fast.gc.trseg/bt_array.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/builtin.opt
lib/mercury/ints/asm_fast.gc.trseg/builtin.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/calendar.opt
lib/mercury/ints/asm_fast.gc.trseg/calendar.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/char.opt
lib/mercury/ints/asm_fast.gc.trseg/char.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/construct.opt
lib/mercury/ints/asm_fast.gc.trseg/construct.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/cord.opt
lib/mercury/ints/asm_fast.gc.trseg/cord.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/counter.opt
lib/mercury/ints/asm_fast.gc.trseg/counter.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/deconstruct.opt
lib/mercury/ints/asm_fast.gc.trseg/deconstruct.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/digraph.opt
lib/mercury/ints/asm_fast.gc.trseg/digraph.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/dir.opt
lib/mercury/ints/asm_fast.gc.trseg/dir.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/enum.opt
lib/mercury/ints/asm_fast.gc.trseg/enum.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/eqvclass.opt
lib/mercury/ints/asm_fast.gc.trseg/eqvclass.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/erlang_builtin.opt
lib/mercury/ints/asm_fast.gc.trseg/erlang_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/erlang_rtti_implementation.opt
lib/mercury/ints/asm_fast.gc.trseg/erlang_rtti_implementation.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/exception.opt
lib/mercury/ints/asm_fast.gc.trseg/exception.trans_opt
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/ints/asm_fast.gc.trseg/fat_sparse_bitset.opt
lib/mercury/ints/asm_fast.gc.trseg/fat_sparse_bitset.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.trseg/float.opt
lib/mercury/ints/asm_fast.gc.trseg/float.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/gc.opt
lib/mercury/ints/asm_fast.gc.trseg/gc.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/getopt.opt
lib/mercury/ints/asm_fast.gc.trseg/getopt.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/getopt_io.opt
lib/mercury/ints/asm_fast.gc.trseg/getopt_io.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/hash_table.opt
lib/mercury/ints/asm_fast.gc.trseg/hash_table.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/injection.opt
lib/mercury/ints/asm_fast.gc.trseg/injection.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/int.opt
lib/mercury/ints/asm_fast.gc.trseg/int.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/integer.opt
lib/mercury/ints/asm_fast.gc.trseg/integer.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/io.opt
lib/mercury/ints/asm_fast.gc.trseg/io.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/lazy.opt
lib/mercury/ints/asm_fast.gc.trseg/lazy.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/lexer.opt
lib/mercury/ints/asm_fast.gc.trseg/lexer.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/library.opt
lib/mercury/ints/asm_fast.gc.trseg/library.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/list.opt
lib/mercury/ints/asm_fast.gc.trseg/list.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/map.opt
lib/mercury/ints/asm_fast.gc.trseg/map.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/math.opt
lib/mercury/ints/asm_fast.gc.trseg/math.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/maybe.opt
lib/mercury/ints/asm_fast.gc.trseg/maybe.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/mer_std.opt
lib/mercury/ints/asm_fast.gc.trseg/mer_std.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/multi_map.opt
lib/mercury/ints/asm_fast.gc.trseg/multi_map.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/mutvar.opt
lib/mercury/ints/asm_fast.gc.trseg/mutvar.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/ops.opt
lib/mercury/ints/asm_fast.gc.trseg/ops.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/pair.opt
lib/mercury/ints/asm_fast.gc.trseg/pair.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/par_builtin.opt
lib/mercury/ints/asm_fast.gc.trseg/par_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/parser.opt
lib/mercury/ints/asm_fast.gc.trseg/parser.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/parsing_utils.opt
lib/mercury/ints/asm_fast.gc.trseg/parsing_utils.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/pprint.opt
lib/mercury/ints/asm_fast.gc.trseg/pprint.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/pqueue.opt
lib/mercury/ints/asm_fast.gc.trseg/pqueue.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/pretty_printer.opt
lib/mercury/ints/asm_fast.gc.trseg/pretty_printer.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/private_builtin.opt
lib/mercury/ints/asm_fast.gc.trseg/private_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/profiling_builtin.opt
lib/mercury/ints/asm_fast.gc.trseg/profiling_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/prolog.opt
lib/mercury/ints/asm_fast.gc.trseg/prolog.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/queue.opt
lib/mercury/ints/asm_fast.gc.trseg/queue.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/random.opt
lib/mercury/ints/asm_fast.gc.trseg/random.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/rational.opt
lib/mercury/ints/asm_fast.gc.trseg/rational.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/rbtree.opt
lib/mercury/ints/asm_fast.gc.trseg/rbtree.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/region_builtin.opt
lib/mercury/ints/asm_fast.gc.trseg/region_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/require.opt
lib/mercury/ints/asm_fast.gc.trseg/require.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/robdd.opt
lib/mercury/ints/asm_fast.gc.trseg/robdd.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/rtree.opt
lib/mercury/ints/asm_fast.gc.trseg/rtree.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/rtti_implementation.opt
lib/mercury/ints/asm_fast.gc.trseg/rtti_implementation.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/set.opt
lib/mercury/ints/asm_fast.gc.trseg/set.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/set_bbbtree.opt
lib/mercury/ints/asm_fast.gc.trseg/set_bbbtree.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/set_ctree234.opt
lib/mercury/ints/asm_fast.gc.trseg/set_ctree234.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/set_ordlist.opt
lib/mercury/ints/asm_fast.gc.trseg/set_ordlist.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/set_tree234.opt
lib/mercury/ints/asm_fast.gc.trseg/set_tree234.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/set_unordlist.opt
lib/mercury/ints/asm_fast.gc.trseg/set_unordlist.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/solutions.opt
lib/mercury/ints/asm_fast.gc.trseg/solutions.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/sparse_bitset.opt
lib/mercury/ints/asm_fast.gc.trseg/sparse_bitset.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/stack.opt
lib/mercury/ints/asm_fast.gc.trseg/stack.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/std_util.opt
lib/mercury/ints/asm_fast.gc.trseg/std_util.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/stm_builtin.opt
lib/mercury/ints/asm_fast.gc.trseg/stm_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/store.opt
lib/mercury/ints/asm_fast.gc.trseg/store.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/stream.opt
lib/mercury/ints/asm_fast.gc.trseg/stream.string_writer.opt
lib/mercury/ints/asm_fast.gc.trseg/stream.string_writer.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/stream.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/string.builder.opt
lib/mercury/ints/asm_fast.gc.trseg/string.builder.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/string.opt
lib/mercury/ints/asm_fast.gc.trseg/string.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/table_builtin.opt
lib/mercury/ints/asm_fast.gc.trseg/table_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/table_statistics.opt
lib/mercury/ints/asm_fast.gc.trseg/table_statistics.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/term.opt
lib/mercury/ints/asm_fast.gc.trseg/term.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/term_io.opt
lib/mercury/ints/asm_fast.gc.trseg/term_io.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/term_size_prof_builtin.opt
lib/mercury/ints/asm_fast.gc.trseg/term_size_prof_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/term_to_xml.opt
lib/mercury/ints/asm_fast.gc.trseg/term_to_xml.trans_opt
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/ints/asm_fast.gc.trseg/test_bitset.opt
lib/mercury/ints/asm_fast.gc.trseg/test_bitset.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc.trseg/thread.channel.opt
lib/mercury/ints/asm_fast.gc.trseg/thread.channel.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/thread.mvar.opt
lib/mercury/ints/asm_fast.gc.trseg/thread.mvar.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/thread.opt
lib/mercury/ints/asm_fast.gc.trseg/thread.semaphore.opt
lib/mercury/ints/asm_fast.gc.trseg/thread.semaphore.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/thread.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/time.opt
lib/mercury/ints/asm_fast.gc.trseg/time.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/tree234.opt
lib/mercury/ints/asm_fast.gc.trseg/tree234.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/tree_bitset.opt
lib/mercury/ints/asm_fast.gc.trseg/tree_bitset.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/type_desc.opt
lib/mercury/ints/asm_fast.gc.trseg/type_desc.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/unit.opt
lib/mercury/ints/asm_fast.gc.trseg/unit.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/univ.opt
lib/mercury/ints/asm_fast.gc.trseg/univ.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/varset.opt
lib/mercury/ints/asm_fast.gc.trseg/varset.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/version_array.opt
lib/mercury/ints/asm_fast.gc.trseg/version_array.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/version_array2d.opt
lib/mercury/ints/asm_fast.gc.trseg/version_array2d.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/version_bitmap.opt
lib/mercury/ints/asm_fast.gc.trseg/version_bitmap.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/version_hash_table.opt
lib/mercury/ints/asm_fast.gc.trseg/version_hash_table.trans_opt
lib/mercury/ints/asm_fast.gc.trseg/version_store.opt
lib/mercury/ints/asm_fast.gc.trseg/version_store.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/Mercury/opts
lib/mercury/ints/asm_fast.gc/Mercury/trans_opts
lib/mercury/ints/asm_fast.gc/array.opt
lib/mercury/ints/asm_fast.gc/array.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc/array2d.opt
lib/mercury/ints/asm_fast.gc/array2d.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/assoc_list.opt
lib/mercury/ints/asm_fast.gc/assoc_list.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc/backjump.opt
lib/mercury/ints/asm_fast.gc/backjump.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/bag.opt
lib/mercury/ints/asm_fast.gc/bag.trans_opt
lib/mercury/ints/asm_fast.gc/benchmarking.opt
lib/mercury/ints/asm_fast.gc/benchmarking.trans_opt
lib/mercury/ints/asm_fast.gc/bimap.opt
lib/mercury/ints/asm_fast.gc/bimap.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc/bit_buffer.opt
lib/mercury/ints/asm_fast.gc/bit_buffer.read.opt
lib/mercury/ints/asm_fast.gc/bit_buffer.read.trans_opt
lib/mercury/ints/asm_fast.gc/bit_buffer.trans_opt
lib/mercury/ints/asm_fast.gc/bit_buffer.write.opt
lib/mercury/ints/asm_fast.gc/bit_buffer.write.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/bitmap.opt
lib/mercury/ints/asm_fast.gc/bitmap.trans_opt
lib/mercury/ints/asm_fast.gc/bool.opt
lib/mercury/ints/asm_fast.gc/bool.trans_opt
lib/mercury/ints/asm_fast.gc/bt_array.opt
lib/mercury/ints/asm_fast.gc/bt_array.trans_opt
lib/mercury/ints/asm_fast.gc/builtin.opt
lib/mercury/ints/asm_fast.gc/builtin.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc/calendar.opt
lib/mercury/ints/asm_fast.gc/calendar.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/char.opt
lib/mercury/ints/asm_fast.gc/char.trans_opt
lib/mercury/ints/asm_fast.gc/construct.opt
lib/mercury/ints/asm_fast.gc/construct.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc/cord.opt
lib/mercury/ints/asm_fast.gc/cord.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/counter.opt
lib/mercury/ints/asm_fast.gc/counter.trans_opt
lib/mercury/ints/asm_fast.gc/deconstruct.opt
lib/mercury/ints/asm_fast.gc/deconstruct.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc/digraph.opt
lib/mercury/ints/asm_fast.gc/digraph.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/dir.opt
lib/mercury/ints/asm_fast.gc/dir.trans_opt
lib/mercury/ints/asm_fast.gc/enum.opt
lib/mercury/ints/asm_fast.gc/enum.trans_opt
lib/mercury/ints/asm_fast.gc/eqvclass.opt
lib/mercury/ints/asm_fast.gc/eqvclass.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc/erlang_builtin.opt
lib/mercury/ints/asm_fast.gc/erlang_builtin.trans_opt
lib/mercury/ints/asm_fast.gc/erlang_rtti_implementation.opt
lib/mercury/ints/asm_fast.gc/erlang_rtti_implementation.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/exception.opt
lib/mercury/ints/asm_fast.gc/exception.trans_opt
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/ints/asm_fast.gc/fat_sparse_bitset.opt
lib/mercury/ints/asm_fast.gc/fat_sparse_bitset.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/float.opt
lib/mercury/ints/asm_fast.gc/float.trans_opt
lib/mercury/ints/asm_fast.gc/gc.opt
lib/mercury/ints/asm_fast.gc/gc.trans_opt
lib/mercury/ints/asm_fast.gc/getopt.opt
lib/mercury/ints/asm_fast.gc/getopt.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc/getopt_io.opt
lib/mercury/ints/asm_fast.gc/getopt_io.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/hash_table.opt
lib/mercury/ints/asm_fast.gc/hash_table.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc/injection.opt
lib/mercury/ints/asm_fast.gc/injection.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/int.opt
lib/mercury/ints/asm_fast.gc/int.trans_opt
lib/mercury/ints/asm_fast.gc/integer.opt
lib/mercury/ints/asm_fast.gc/integer.trans_opt
lib/mercury/ints/asm_fast.gc/io.opt
lib/mercury/ints/asm_fast.gc/io.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc/lazy.opt
lib/mercury/ints/asm_fast.gc/lazy.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/lexer.opt
lib/mercury/ints/asm_fast.gc/lexer.trans_opt
lib/mercury/ints/asm_fast.gc/library.opt
lib/mercury/ints/asm_fast.gc/library.trans_opt
lib/mercury/ints/asm_fast.gc/list.opt
lib/mercury/ints/asm_fast.gc/list.trans_opt
lib/mercury/ints/asm_fast.gc/map.opt
lib/mercury/ints/asm_fast.gc/map.trans_opt
lib/mercury/ints/asm_fast.gc/math.opt
lib/mercury/ints/asm_fast.gc/math.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc/maybe.opt
lib/mercury/ints/asm_fast.gc/maybe.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/mer_std.opt
lib/mercury/ints/asm_fast.gc/mer_std.trans_opt
lib/mercury/ints/asm_fast.gc/multi_map.opt
lib/mercury/ints/asm_fast.gc/multi_map.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc/mutvar.opt
lib/mercury/ints/asm_fast.gc/mutvar.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/ops.opt
lib/mercury/ints/asm_fast.gc/ops.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc/pair.opt
lib/mercury/ints/asm_fast.gc/pair.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc/par_builtin.opt
lib/mercury/ints/asm_fast.gc/par_builtin.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/parser.opt
lib/mercury/ints/asm_fast.gc/parser.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc/parsing_utils.opt
lib/mercury/ints/asm_fast.gc/parsing_utils.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/pprint.opt
lib/mercury/ints/asm_fast.gc/pprint.trans_opt
lib/mercury/ints/asm_fast.gc/pqueue.opt
lib/mercury/ints/asm_fast.gc/pqueue.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc/pretty_printer.opt
lib/mercury/ints/asm_fast.gc/pretty_printer.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/private_builtin.opt
lib/mercury/ints/asm_fast.gc/private_builtin.trans_opt
lib/mercury/ints/asm_fast.gc/profiling_builtin.opt
lib/mercury/ints/asm_fast.gc/profiling_builtin.trans_opt
lib/mercury/ints/asm_fast.gc/prolog.opt
lib/mercury/ints/asm_fast.gc/prolog.trans_opt
lib/mercury/ints/asm_fast.gc/queue.opt
lib/mercury/ints/asm_fast.gc/queue.trans_opt
lib/mercury/ints/asm_fast.gc/random.opt
lib/mercury/ints/asm_fast.gc/random.trans_opt
lib/mercury/ints/asm_fast.gc/rational.opt
lib/mercury/ints/asm_fast.gc/rational.trans_opt
lib/mercury/ints/asm_fast.gc/rbtree.opt
lib/mercury/ints/asm_fast.gc/rbtree.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc/region_builtin.opt
lib/mercury/ints/asm_fast.gc/region_builtin.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/require.opt
lib/mercury/ints/asm_fast.gc/require.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc/robdd.opt
lib/mercury/ints/asm_fast.gc/robdd.trans_opt
lib/mercury/ints/asm_fast.gc/rtree.opt
lib/mercury/ints/asm_fast.gc/rtree.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/rtti_implementation.opt
lib/mercury/ints/asm_fast.gc/rtti_implementation.trans_opt
lib/mercury/ints/asm_fast.gc/set.opt
lib/mercury/ints/asm_fast.gc/set.trans_opt
lib/mercury/ints/asm_fast.gc/set_bbbtree.opt
lib/mercury/ints/asm_fast.gc/set_bbbtree.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc/set_ctree234.opt
lib/mercury/ints/asm_fast.gc/set_ctree234.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/set_ordlist.opt
lib/mercury/ints/asm_fast.gc/set_ordlist.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc/set_tree234.opt
lib/mercury/ints/asm_fast.gc/set_tree234.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/set_unordlist.opt
lib/mercury/ints/asm_fast.gc/set_unordlist.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc/solutions.opt
lib/mercury/ints/asm_fast.gc/solutions.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/sparse_bitset.opt
lib/mercury/ints/asm_fast.gc/sparse_bitset.trans_opt
lib/mercury/ints/asm_fast.gc/stack.opt
lib/mercury/ints/asm_fast.gc/stack.trans_opt
lib/mercury/ints/asm_fast.gc/std_util.opt
lib/mercury/ints/asm_fast.gc/std_util.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc/stm_builtin.opt
lib/mercury/ints/asm_fast.gc/stm_builtin.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/store.opt
lib/mercury/ints/asm_fast.gc/store.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc/stream.opt
lib/mercury/ints/asm_fast.gc/stream.string_writer.opt
lib/mercury/ints/asm_fast.gc/stream.string_writer.trans_opt
lib/mercury/ints/asm_fast.gc/stream.trans_opt
lib/mercury/ints/asm_fast.gc/string.builder.opt
lib/mercury/ints/asm_fast.gc/string.builder.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/string.opt
lib/mercury/ints/asm_fast.gc/string.trans_opt
lib/mercury/ints/asm_fast.gc/table_builtin.opt
lib/mercury/ints/asm_fast.gc/table_builtin.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc/table_statistics.opt
lib/mercury/ints/asm_fast.gc/table_statistics.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/term.opt
lib/mercury/ints/asm_fast.gc/term.trans_opt
lib/mercury/ints/asm_fast.gc/term_io.opt
lib/mercury/ints/asm_fast.gc/term_io.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc/term_size_prof_builtin.opt
lib/mercury/ints/asm_fast.gc/term_size_prof_builtin.trans_opt
lib/mercury/ints/asm_fast.gc/term_to_xml.opt
lib/mercury/ints/asm_fast.gc/term_to_xml.trans_opt
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/ints/asm_fast.gc/test_bitset.opt
lib/mercury/ints/asm_fast.gc/test_bitset.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc/thread.channel.opt
lib/mercury/ints/asm_fast.gc/thread.channel.trans_opt
lib/mercury/ints/asm_fast.gc/thread.mvar.opt
lib/mercury/ints/asm_fast.gc/thread.mvar.trans_opt
lib/mercury/ints/asm_fast.gc/thread.opt
lib/mercury/ints/asm_fast.gc/thread.semaphore.opt
lib/mercury/ints/asm_fast.gc/thread.semaphore.trans_opt
lib/mercury/ints/asm_fast.gc/thread.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/time.opt
lib/mercury/ints/asm_fast.gc/time.trans_opt
lib/mercury/ints/asm_fast.gc/tree234.opt
lib/mercury/ints/asm_fast.gc/tree234.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/asm_fast.gc/tree_bitset.opt
lib/mercury/ints/asm_fast.gc/tree_bitset.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/type_desc.opt
lib/mercury/ints/asm_fast.gc/type_desc.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc/unit.opt
lib/mercury/ints/asm_fast.gc/unit.trans_opt
lib/mercury/ints/asm_fast.gc/univ.opt
lib/mercury/ints/asm_fast.gc/univ.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/asm_fast.gc/varset.opt
lib/mercury/ints/asm_fast.gc/varset.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/asm_fast.gc/version_array.opt
lib/mercury/ints/asm_fast.gc/version_array.trans_opt
lib/mercury/ints/asm_fast.gc/version_array2d.opt
lib/mercury/ints/asm_fast.gc/version_array2d.trans_opt
lib/mercury/ints/asm_fast.gc/version_bitmap.opt
lib/mercury/ints/asm_fast.gc/version_bitmap.trans_opt
lib/mercury/ints/asm_fast.gc/version_hash_table.opt
lib/mercury/ints/asm_fast.gc/version_hash_table.trans_opt
lib/mercury/ints/asm_fast.gc/version_store.opt
lib/mercury/ints/asm_fast.gc/version_store.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/assoc_list.int
lib/mercury/ints/assoc_list.int2
lib/mercury/ints/assoc_list.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/assoc_list.mh
lib/mercury/ints/assoc_list.mih
lib/mercury/ints/assoc_list.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/assoc_list.opt
lib/mercury/ints/assoc_list.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/backjump.int
lib/mercury/ints/backjump.int2
lib/mercury/ints/backjump.int3
lib/mercury/ints/backjump.mh
lib/mercury/ints/backjump.mih
lib/mercury/ints/backjump.module_dep
lib/mercury/ints/backjump.opt
lib/mercury/ints/backjump.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/bag.int
lib/mercury/ints/bag.int2
lib/mercury/ints/bag.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/bag.mh
lib/mercury/ints/bag.mih
lib/mercury/ints/bag.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/bag.opt
lib/mercury/ints/bag.trans_opt
lib/mercury/ints/benchmarking.int
lib/mercury/ints/benchmarking.int2
lib/mercury/ints/benchmarking.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/benchmarking.mh
lib/mercury/ints/benchmarking.mih
lib/mercury/ints/benchmarking.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/benchmarking.opt
lib/mercury/ints/benchmarking.trans_opt
lib/mercury/ints/bimap.int
lib/mercury/ints/bimap.int2
lib/mercury/ints/bimap.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/bimap.mh
lib/mercury/ints/bimap.mih
lib/mercury/ints/bimap.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/bimap.opt
lib/mercury/ints/bimap.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/bit_buffer.int
lib/mercury/ints/bit_buffer.int0
lib/mercury/ints/bit_buffer.int2
lib/mercury/ints/bit_buffer.int3
lib/mercury/ints/bit_buffer.mh
lib/mercury/ints/bit_buffer.mih
lib/mercury/ints/bit_buffer.module_dep
lib/mercury/ints/bit_buffer.opt
lib/mercury/ints/bit_buffer.read.int
lib/mercury/ints/bit_buffer.read.int2
lib/mercury/ints/bit_buffer.read.int3
lib/mercury/ints/bit_buffer.read.mh
lib/mercury/ints/bit_buffer.read.mih
lib/mercury/ints/bit_buffer.read.module_dep
lib/mercury/ints/bit_buffer.read.opt
lib/mercury/ints/bit_buffer.read.trans_opt
lib/mercury/ints/bit_buffer.trans_opt
lib/mercury/ints/bit_buffer.write.int
lib/mercury/ints/bit_buffer.write.int2
lib/mercury/ints/bit_buffer.write.int3
lib/mercury/ints/bit_buffer.write.mh
lib/mercury/ints/bit_buffer.write.mih
lib/mercury/ints/bit_buffer.write.module_dep
lib/mercury/ints/bit_buffer.write.opt
lib/mercury/ints/bit_buffer.write.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/bitmap.int
lib/mercury/ints/bitmap.int2
lib/mercury/ints/bitmap.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/bitmap.mh
lib/mercury/ints/bitmap.mih
lib/mercury/ints/bitmap.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/bitmap.opt
lib/mercury/ints/bitmap.trans_opt
lib/mercury/ints/bool.int
lib/mercury/ints/bool.int2
lib/mercury/ints/bool.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/bool.mh
lib/mercury/ints/bool.mih
lib/mercury/ints/bool.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/bool.opt
lib/mercury/ints/bool.trans_opt
lib/mercury/ints/bt_array.int
lib/mercury/ints/bt_array.int2
lib/mercury/ints/bt_array.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/bt_array.mh
lib/mercury/ints/bt_array.mih
lib/mercury/ints/bt_array.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/bt_array.opt
lib/mercury/ints/bt_array.trans_opt
lib/mercury/ints/builtin.int
lib/mercury/ints/builtin.int2
lib/mercury/ints/builtin.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/builtin.mh
lib/mercury/ints/builtin.mih
lib/mercury/ints/builtin.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/builtin.opt
lib/mercury/ints/builtin.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/calendar.int
lib/mercury/ints/calendar.int2
lib/mercury/ints/calendar.int3
lib/mercury/ints/calendar.mh
lib/mercury/ints/calendar.mih
lib/mercury/ints/calendar.module_dep
lib/mercury/ints/calendar.opt
lib/mercury/ints/calendar.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/char.int
lib/mercury/ints/char.int2
lib/mercury/ints/char.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/char.mh
lib/mercury/ints/char.mih
lib/mercury/ints/char.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/char.opt
lib/mercury/ints/char.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/construct.int
lib/mercury/ints/construct.int2
lib/mercury/ints/construct.int3
lib/mercury/ints/construct.mh
lib/mercury/ints/construct.mih
lib/mercury/ints/construct.module_dep
lib/mercury/ints/construct.opt
lib/mercury/ints/construct.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/cord.int
lib/mercury/ints/cord.int2
lib/mercury/ints/cord.int3
lib/mercury/ints/cord.mh
lib/mercury/ints/cord.mih
lib/mercury/ints/cord.module_dep
lib/mercury/ints/cord.opt
lib/mercury/ints/cord.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/counter.int
lib/mercury/ints/counter.int2
lib/mercury/ints/counter.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/counter.mh
lib/mercury/ints/counter.mih
lib/mercury/ints/counter.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/counter.opt
lib/mercury/ints/counter.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/deconstruct.int
lib/mercury/ints/deconstruct.int2
lib/mercury/ints/deconstruct.int3
lib/mercury/ints/deconstruct.mh
lib/mercury/ints/deconstruct.mih
lib/mercury/ints/deconstruct.module_dep
lib/mercury/ints/deconstruct.opt
lib/mercury/ints/deconstruct.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/digraph.int
lib/mercury/ints/digraph.int2
lib/mercury/ints/digraph.int3
lib/mercury/ints/digraph.mh
lib/mercury/ints/digraph.mih
lib/mercury/ints/digraph.module_dep
lib/mercury/ints/digraph.opt
lib/mercury/ints/digraph.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/dir.int
lib/mercury/ints/dir.int2
lib/mercury/ints/dir.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/dir.mh
lib/mercury/ints/dir.mih
lib/mercury/ints/dir.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/dir.opt
lib/mercury/ints/dir.trans_opt
lib/mercury/ints/enum.int
lib/mercury/ints/enum.int2
lib/mercury/ints/enum.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/enum.mh
lib/mercury/ints/enum.mih
lib/mercury/ints/enum.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/enum.opt
lib/mercury/ints/enum.trans_opt
lib/mercury/ints/eqvclass.int
lib/mercury/ints/eqvclass.int2
lib/mercury/ints/eqvclass.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/eqvclass.mh
lib/mercury/ints/eqvclass.mih
lib/mercury/ints/eqvclass.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/eqvclass.opt
lib/mercury/ints/eqvclass.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/erlang_builtin.int
lib/mercury/ints/erlang_builtin.int2
lib/mercury/ints/erlang_builtin.int3
lib/mercury/ints/erlang_builtin.mh
lib/mercury/ints/erlang_builtin.mih
lib/mercury/ints/erlang_builtin.module_dep
lib/mercury/ints/erlang_builtin.opt
lib/mercury/ints/erlang_builtin.trans_opt
lib/mercury/ints/erlang_rtti_implementation.int
lib/mercury/ints/erlang_rtti_implementation.int2
lib/mercury/ints/erlang_rtti_implementation.int3
lib/mercury/ints/erlang_rtti_implementation.mh
lib/mercury/ints/erlang_rtti_implementation.mih
lib/mercury/ints/erlang_rtti_implementation.module_dep
lib/mercury/ints/erlang_rtti_implementation.opt
lib/mercury/ints/erlang_rtti_implementation.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/exception.int
lib/mercury/ints/exception.int2
lib/mercury/ints/exception.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/exception.mh
lib/mercury/ints/exception.mih
lib/mercury/ints/exception.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/exception.opt
lib/mercury/ints/exception.trans_opt
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/ints/fat_sparse_bitset.int
lib/mercury/ints/fat_sparse_bitset.int2
lib/mercury/ints/fat_sparse_bitset.int3
lib/mercury/ints/fat_sparse_bitset.mh
lib/mercury/ints/fat_sparse_bitset.mih
lib/mercury/ints/fat_sparse_bitset.module_dep
lib/mercury/ints/fat_sparse_bitset.opt
lib/mercury/ints/fat_sparse_bitset.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/float.int
lib/mercury/ints/float.int2
lib/mercury/ints/float.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/float.mh
lib/mercury/ints/float.mih
lib/mercury/ints/float.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/float.opt
lib/mercury/ints/float.trans_opt
lib/mercury/ints/gc.int
lib/mercury/ints/gc.int2
lib/mercury/ints/gc.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/gc.mh
lib/mercury/ints/gc.mih
lib/mercury/ints/gc.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/gc.opt
lib/mercury/ints/gc.trans_opt
lib/mercury/ints/getopt.int
lib/mercury/ints/getopt.int2
lib/mercury/ints/getopt.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/getopt.mh
lib/mercury/ints/getopt.mih
lib/mercury/ints/getopt.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/getopt.opt
lib/mercury/ints/getopt.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/getopt_io.int
lib/mercury/ints/getopt_io.int2
lib/mercury/ints/getopt_io.int3
lib/mercury/ints/getopt_io.mh
lib/mercury/ints/getopt_io.mih
lib/mercury/ints/getopt_io.module_dep
lib/mercury/ints/getopt_io.opt
lib/mercury/ints/getopt_io.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/hash_table.int
lib/mercury/ints/hash_table.int2
lib/mercury/ints/hash_table.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hash_table.mh
lib/mercury/ints/hash_table.mih
lib/mercury/ints/hash_table.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/hash_table.opt
lib/mercury/ints/hash_table.trans_opt
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/ints/hlc.gc.pregen/Mercury/opts
lib/mercury/ints/hlc.gc.pregen/Mercury/trans_opts
lib/mercury/ints/hlc.gc.pregen/array.opt
lib/mercury/ints/hlc.gc.pregen/array.trans_opt
lib/mercury/ints/hlc.gc.pregen/array2d.opt
lib/mercury/ints/hlc.gc.pregen/array2d.trans_opt
lib/mercury/ints/hlc.gc.pregen/assoc_list.opt
lib/mercury/ints/hlc.gc.pregen/assoc_list.trans_opt
lib/mercury/ints/hlc.gc.pregen/backjump.opt
lib/mercury/ints/hlc.gc.pregen/backjump.trans_opt
lib/mercury/ints/hlc.gc.pregen/bag.opt
lib/mercury/ints/hlc.gc.pregen/bag.trans_opt
lib/mercury/ints/hlc.gc.pregen/benchmarking.opt
lib/mercury/ints/hlc.gc.pregen/benchmarking.trans_opt
lib/mercury/ints/hlc.gc.pregen/bimap.opt
lib/mercury/ints/hlc.gc.pregen/bimap.trans_opt
lib/mercury/ints/hlc.gc.pregen/bit_buffer.opt
lib/mercury/ints/hlc.gc.pregen/bit_buffer.read.opt
lib/mercury/ints/hlc.gc.pregen/bit_buffer.read.trans_opt
lib/mercury/ints/hlc.gc.pregen/bit_buffer.trans_opt
lib/mercury/ints/hlc.gc.pregen/bit_buffer.write.opt
lib/mercury/ints/hlc.gc.pregen/bit_buffer.write.trans_opt
lib/mercury/ints/hlc.gc.pregen/bitmap.opt
lib/mercury/ints/hlc.gc.pregen/bitmap.trans_opt
lib/mercury/ints/hlc.gc.pregen/bool.opt
lib/mercury/ints/hlc.gc.pregen/bool.trans_opt
lib/mercury/ints/hlc.gc.pregen/bt_array.opt
lib/mercury/ints/hlc.gc.pregen/bt_array.trans_opt
lib/mercury/ints/hlc.gc.pregen/builtin.opt
lib/mercury/ints/hlc.gc.pregen/builtin.trans_opt
lib/mercury/ints/hlc.gc.pregen/calendar.opt
lib/mercury/ints/hlc.gc.pregen/calendar.trans_opt
lib/mercury/ints/hlc.gc.pregen/char.opt
lib/mercury/ints/hlc.gc.pregen/char.trans_opt
lib/mercury/ints/hlc.gc.pregen/construct.opt
lib/mercury/ints/hlc.gc.pregen/construct.trans_opt
lib/mercury/ints/hlc.gc.pregen/cord.opt
lib/mercury/ints/hlc.gc.pregen/cord.trans_opt
lib/mercury/ints/hlc.gc.pregen/counter.opt
lib/mercury/ints/hlc.gc.pregen/counter.trans_opt
lib/mercury/ints/hlc.gc.pregen/deconstruct.opt
lib/mercury/ints/hlc.gc.pregen/deconstruct.trans_opt
lib/mercury/ints/hlc.gc.pregen/digraph.opt
lib/mercury/ints/hlc.gc.pregen/digraph.trans_opt
lib/mercury/ints/hlc.gc.pregen/dir.opt
lib/mercury/ints/hlc.gc.pregen/dir.trans_opt
lib/mercury/ints/hlc.gc.pregen/enum.opt
lib/mercury/ints/hlc.gc.pregen/enum.trans_opt
lib/mercury/ints/hlc.gc.pregen/eqvclass.opt
lib/mercury/ints/hlc.gc.pregen/eqvclass.trans_opt
lib/mercury/ints/hlc.gc.pregen/erlang_builtin.opt
lib/mercury/ints/hlc.gc.pregen/erlang_builtin.trans_opt
lib/mercury/ints/hlc.gc.pregen/erlang_rtti_implementation.opt
lib/mercury/ints/hlc.gc.pregen/erlang_rtti_implementation.trans_opt
lib/mercury/ints/hlc.gc.pregen/exception.opt
lib/mercury/ints/hlc.gc.pregen/exception.trans_opt
lib/mercury/ints/hlc.gc.pregen/fat_sparse_bitset.opt
lib/mercury/ints/hlc.gc.pregen/fat_sparse_bitset.trans_opt
lib/mercury/ints/hlc.gc.pregen/float.opt
lib/mercury/ints/hlc.gc.pregen/float.trans_opt
lib/mercury/ints/hlc.gc.pregen/gc.opt
lib/mercury/ints/hlc.gc.pregen/gc.trans_opt
lib/mercury/ints/hlc.gc.pregen/getopt.opt
lib/mercury/ints/hlc.gc.pregen/getopt.trans_opt
lib/mercury/ints/hlc.gc.pregen/getopt_io.opt
lib/mercury/ints/hlc.gc.pregen/getopt_io.trans_opt
lib/mercury/ints/hlc.gc.pregen/hash_table.opt
lib/mercury/ints/hlc.gc.pregen/hash_table.trans_opt
lib/mercury/ints/hlc.gc.pregen/injection.opt
lib/mercury/ints/hlc.gc.pregen/injection.trans_opt
lib/mercury/ints/hlc.gc.pregen/int.opt
lib/mercury/ints/hlc.gc.pregen/int.trans_opt
lib/mercury/ints/hlc.gc.pregen/integer.opt
lib/mercury/ints/hlc.gc.pregen/integer.trans_opt
lib/mercury/ints/hlc.gc.pregen/io.opt
lib/mercury/ints/hlc.gc.pregen/io.trans_opt
lib/mercury/ints/hlc.gc.pregen/lazy.opt
lib/mercury/ints/hlc.gc.pregen/lazy.trans_opt
lib/mercury/ints/hlc.gc.pregen/lexer.opt
lib/mercury/ints/hlc.gc.pregen/lexer.trans_opt
lib/mercury/ints/hlc.gc.pregen/library.opt
lib/mercury/ints/hlc.gc.pregen/library.trans_opt
lib/mercury/ints/hlc.gc.pregen/list.opt
lib/mercury/ints/hlc.gc.pregen/list.trans_opt
lib/mercury/ints/hlc.gc.pregen/map.opt
lib/mercury/ints/hlc.gc.pregen/map.trans_opt
lib/mercury/ints/hlc.gc.pregen/math.opt
lib/mercury/ints/hlc.gc.pregen/math.trans_opt
lib/mercury/ints/hlc.gc.pregen/maybe.opt
lib/mercury/ints/hlc.gc.pregen/maybe.trans_opt
lib/mercury/ints/hlc.gc.pregen/mer_std.opt
lib/mercury/ints/hlc.gc.pregen/mer_std.trans_opt
lib/mercury/ints/hlc.gc.pregen/multi_map.opt
lib/mercury/ints/hlc.gc.pregen/multi_map.trans_opt
lib/mercury/ints/hlc.gc.pregen/mutvar.opt
lib/mercury/ints/hlc.gc.pregen/mutvar.trans_opt
lib/mercury/ints/hlc.gc.pregen/ops.opt
lib/mercury/ints/hlc.gc.pregen/ops.trans_opt
lib/mercury/ints/hlc.gc.pregen/pair.opt
lib/mercury/ints/hlc.gc.pregen/pair.trans_opt
lib/mercury/ints/hlc.gc.pregen/par_builtin.opt
lib/mercury/ints/hlc.gc.pregen/par_builtin.trans_opt
lib/mercury/ints/hlc.gc.pregen/parser.opt
lib/mercury/ints/hlc.gc.pregen/parser.trans_opt
lib/mercury/ints/hlc.gc.pregen/parsing_utils.opt
lib/mercury/ints/hlc.gc.pregen/parsing_utils.trans_opt
lib/mercury/ints/hlc.gc.pregen/pprint.opt
lib/mercury/ints/hlc.gc.pregen/pprint.trans_opt
lib/mercury/ints/hlc.gc.pregen/pqueue.opt
lib/mercury/ints/hlc.gc.pregen/pqueue.trans_opt
lib/mercury/ints/hlc.gc.pregen/pretty_printer.opt
lib/mercury/ints/hlc.gc.pregen/pretty_printer.trans_opt
lib/mercury/ints/hlc.gc.pregen/private_builtin.opt
lib/mercury/ints/hlc.gc.pregen/private_builtin.trans_opt
lib/mercury/ints/hlc.gc.pregen/profiling_builtin.opt
lib/mercury/ints/hlc.gc.pregen/profiling_builtin.trans_opt
lib/mercury/ints/hlc.gc.pregen/prolog.opt
lib/mercury/ints/hlc.gc.pregen/prolog.trans_opt
lib/mercury/ints/hlc.gc.pregen/queue.opt
lib/mercury/ints/hlc.gc.pregen/queue.trans_opt
lib/mercury/ints/hlc.gc.pregen/random.opt
lib/mercury/ints/hlc.gc.pregen/random.trans_opt
lib/mercury/ints/hlc.gc.pregen/rational.opt
lib/mercury/ints/hlc.gc.pregen/rational.trans_opt
lib/mercury/ints/hlc.gc.pregen/rbtree.opt
lib/mercury/ints/hlc.gc.pregen/rbtree.trans_opt
lib/mercury/ints/hlc.gc.pregen/region_builtin.opt
lib/mercury/ints/hlc.gc.pregen/region_builtin.trans_opt
lib/mercury/ints/hlc.gc.pregen/require.opt
lib/mercury/ints/hlc.gc.pregen/require.trans_opt
lib/mercury/ints/hlc.gc.pregen/robdd.opt
lib/mercury/ints/hlc.gc.pregen/robdd.trans_opt
lib/mercury/ints/hlc.gc.pregen/rtree.opt
lib/mercury/ints/hlc.gc.pregen/rtree.trans_opt
lib/mercury/ints/hlc.gc.pregen/rtti_implementation.opt
lib/mercury/ints/hlc.gc.pregen/rtti_implementation.trans_opt
lib/mercury/ints/hlc.gc.pregen/set.opt
lib/mercury/ints/hlc.gc.pregen/set.trans_opt
lib/mercury/ints/hlc.gc.pregen/set_bbbtree.opt
lib/mercury/ints/hlc.gc.pregen/set_bbbtree.trans_opt
lib/mercury/ints/hlc.gc.pregen/set_ctree234.opt
lib/mercury/ints/hlc.gc.pregen/set_ctree234.trans_opt
lib/mercury/ints/hlc.gc.pregen/set_ordlist.opt
lib/mercury/ints/hlc.gc.pregen/set_ordlist.trans_opt
lib/mercury/ints/hlc.gc.pregen/set_tree234.opt
lib/mercury/ints/hlc.gc.pregen/set_tree234.trans_opt
lib/mercury/ints/hlc.gc.pregen/set_unordlist.opt
lib/mercury/ints/hlc.gc.pregen/set_unordlist.trans_opt
lib/mercury/ints/hlc.gc.pregen/solutions.opt
lib/mercury/ints/hlc.gc.pregen/solutions.trans_opt
lib/mercury/ints/hlc.gc.pregen/sparse_bitset.opt
lib/mercury/ints/hlc.gc.pregen/sparse_bitset.trans_opt
lib/mercury/ints/hlc.gc.pregen/stack.opt
lib/mercury/ints/hlc.gc.pregen/stack.trans_opt
lib/mercury/ints/hlc.gc.pregen/std_util.opt
lib/mercury/ints/hlc.gc.pregen/std_util.trans_opt
lib/mercury/ints/hlc.gc.pregen/stm_builtin.opt
lib/mercury/ints/hlc.gc.pregen/stm_builtin.trans_opt
lib/mercury/ints/hlc.gc.pregen/store.opt
lib/mercury/ints/hlc.gc.pregen/store.trans_opt
lib/mercury/ints/hlc.gc.pregen/stream.opt
lib/mercury/ints/hlc.gc.pregen/stream.string_writer.opt
lib/mercury/ints/hlc.gc.pregen/stream.string_writer.trans_opt
lib/mercury/ints/hlc.gc.pregen/stream.trans_opt
lib/mercury/ints/hlc.gc.pregen/string.builder.opt
lib/mercury/ints/hlc.gc.pregen/string.builder.trans_opt
lib/mercury/ints/hlc.gc.pregen/string.opt
lib/mercury/ints/hlc.gc.pregen/string.trans_opt
lib/mercury/ints/hlc.gc.pregen/table_builtin.opt
lib/mercury/ints/hlc.gc.pregen/table_builtin.trans_opt
lib/mercury/ints/hlc.gc.pregen/table_statistics.opt
lib/mercury/ints/hlc.gc.pregen/table_statistics.trans_opt
lib/mercury/ints/hlc.gc.pregen/term.opt
lib/mercury/ints/hlc.gc.pregen/term.trans_opt
lib/mercury/ints/hlc.gc.pregen/term_io.opt
lib/mercury/ints/hlc.gc.pregen/term_io.trans_opt
lib/mercury/ints/hlc.gc.pregen/term_size_prof_builtin.opt
lib/mercury/ints/hlc.gc.pregen/term_size_prof_builtin.trans_opt
lib/mercury/ints/hlc.gc.pregen/term_to_xml.opt
lib/mercury/ints/hlc.gc.pregen/term_to_xml.trans_opt
lib/mercury/ints/hlc.gc.pregen/test_bitset.opt
lib/mercury/ints/hlc.gc.pregen/test_bitset.trans_opt
lib/mercury/ints/hlc.gc.pregen/thread.channel.opt
lib/mercury/ints/hlc.gc.pregen/thread.channel.trans_opt
lib/mercury/ints/hlc.gc.pregen/thread.mvar.opt
lib/mercury/ints/hlc.gc.pregen/thread.mvar.trans_opt
lib/mercury/ints/hlc.gc.pregen/thread.opt
lib/mercury/ints/hlc.gc.pregen/thread.semaphore.opt
lib/mercury/ints/hlc.gc.pregen/thread.semaphore.trans_opt
lib/mercury/ints/hlc.gc.pregen/thread.trans_opt
lib/mercury/ints/hlc.gc.pregen/time.opt
lib/mercury/ints/hlc.gc.pregen/time.trans_opt
lib/mercury/ints/hlc.gc.pregen/tree234.opt
lib/mercury/ints/hlc.gc.pregen/tree234.trans_opt
lib/mercury/ints/hlc.gc.pregen/tree_bitset.opt
lib/mercury/ints/hlc.gc.pregen/tree_bitset.trans_opt
lib/mercury/ints/hlc.gc.pregen/type_desc.opt
lib/mercury/ints/hlc.gc.pregen/type_desc.trans_opt
lib/mercury/ints/hlc.gc.pregen/unit.opt
lib/mercury/ints/hlc.gc.pregen/unit.trans_opt
lib/mercury/ints/hlc.gc.pregen/univ.opt
lib/mercury/ints/hlc.gc.pregen/univ.trans_opt
lib/mercury/ints/hlc.gc.pregen/varset.opt
lib/mercury/ints/hlc.gc.pregen/varset.trans_opt
lib/mercury/ints/hlc.gc.pregen/version_array.opt
lib/mercury/ints/hlc.gc.pregen/version_array.trans_opt
lib/mercury/ints/hlc.gc.pregen/version_array2d.opt
lib/mercury/ints/hlc.gc.pregen/version_array2d.trans_opt
lib/mercury/ints/hlc.gc.pregen/version_bitmap.opt
lib/mercury/ints/hlc.gc.pregen/version_bitmap.trans_opt
lib/mercury/ints/hlc.gc.pregen/version_hash_table.opt
lib/mercury/ints/hlc.gc.pregen/version_hash_table.trans_opt
lib/mercury/ints/hlc.gc.pregen/version_store.opt
lib/mercury/ints/hlc.gc.pregen/version_store.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/hlc.gc.trseg/Mercury/opts
lib/mercury/ints/hlc.gc.trseg/Mercury/trans_opts
lib/mercury/ints/hlc.gc.trseg/array.opt
lib/mercury/ints/hlc.gc.trseg/array.trans_opt
lib/mercury/ints/hlc.gc.trseg/array2d.opt
lib/mercury/ints/hlc.gc.trseg/array2d.trans_opt
lib/mercury/ints/hlc.gc.trseg/assoc_list.opt
lib/mercury/ints/hlc.gc.trseg/assoc_list.trans_opt
lib/mercury/ints/hlc.gc.trseg/backjump.opt
lib/mercury/ints/hlc.gc.trseg/backjump.trans_opt
lib/mercury/ints/hlc.gc.trseg/bag.opt
lib/mercury/ints/hlc.gc.trseg/bag.trans_opt
lib/mercury/ints/hlc.gc.trseg/benchmarking.opt
lib/mercury/ints/hlc.gc.trseg/benchmarking.trans_opt
lib/mercury/ints/hlc.gc.trseg/bimap.opt
lib/mercury/ints/hlc.gc.trseg/bimap.trans_opt
lib/mercury/ints/hlc.gc.trseg/bit_buffer.opt
lib/mercury/ints/hlc.gc.trseg/bit_buffer.read.opt
lib/mercury/ints/hlc.gc.trseg/bit_buffer.read.trans_opt
lib/mercury/ints/hlc.gc.trseg/bit_buffer.trans_opt
lib/mercury/ints/hlc.gc.trseg/bit_buffer.write.opt
lib/mercury/ints/hlc.gc.trseg/bit_buffer.write.trans_opt
lib/mercury/ints/hlc.gc.trseg/bitmap.opt
lib/mercury/ints/hlc.gc.trseg/bitmap.trans_opt
lib/mercury/ints/hlc.gc.trseg/bool.opt
lib/mercury/ints/hlc.gc.trseg/bool.trans_opt
lib/mercury/ints/hlc.gc.trseg/bt_array.opt
lib/mercury/ints/hlc.gc.trseg/bt_array.trans_opt
lib/mercury/ints/hlc.gc.trseg/builtin.opt
lib/mercury/ints/hlc.gc.trseg/builtin.trans_opt
lib/mercury/ints/hlc.gc.trseg/calendar.opt
lib/mercury/ints/hlc.gc.trseg/calendar.trans_opt
lib/mercury/ints/hlc.gc.trseg/char.opt
lib/mercury/ints/hlc.gc.trseg/char.trans_opt
lib/mercury/ints/hlc.gc.trseg/construct.opt
lib/mercury/ints/hlc.gc.trseg/construct.trans_opt
lib/mercury/ints/hlc.gc.trseg/cord.opt
lib/mercury/ints/hlc.gc.trseg/cord.trans_opt
lib/mercury/ints/hlc.gc.trseg/counter.opt
lib/mercury/ints/hlc.gc.trseg/counter.trans_opt
lib/mercury/ints/hlc.gc.trseg/deconstruct.opt
lib/mercury/ints/hlc.gc.trseg/deconstruct.trans_opt
lib/mercury/ints/hlc.gc.trseg/digraph.opt
lib/mercury/ints/hlc.gc.trseg/digraph.trans_opt
lib/mercury/ints/hlc.gc.trseg/dir.opt
lib/mercury/ints/hlc.gc.trseg/dir.trans_opt
lib/mercury/ints/hlc.gc.trseg/enum.opt
lib/mercury/ints/hlc.gc.trseg/enum.trans_opt
lib/mercury/ints/hlc.gc.trseg/eqvclass.opt
lib/mercury/ints/hlc.gc.trseg/eqvclass.trans_opt
lib/mercury/ints/hlc.gc.trseg/erlang_builtin.opt
lib/mercury/ints/hlc.gc.trseg/erlang_builtin.trans_opt
lib/mercury/ints/hlc.gc.trseg/erlang_rtti_implementation.opt
lib/mercury/ints/hlc.gc.trseg/erlang_rtti_implementation.trans_opt
lib/mercury/ints/hlc.gc.trseg/exception.opt
lib/mercury/ints/hlc.gc.trseg/exception.trans_opt
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/ints/hlc.gc.trseg/fat_sparse_bitset.opt
lib/mercury/ints/hlc.gc.trseg/fat_sparse_bitset.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/hlc.gc.trseg/float.opt
lib/mercury/ints/hlc.gc.trseg/float.trans_opt
lib/mercury/ints/hlc.gc.trseg/gc.opt
lib/mercury/ints/hlc.gc.trseg/gc.trans_opt
lib/mercury/ints/hlc.gc.trseg/getopt.opt
lib/mercury/ints/hlc.gc.trseg/getopt.trans_opt
lib/mercury/ints/hlc.gc.trseg/getopt_io.opt
lib/mercury/ints/hlc.gc.trseg/getopt_io.trans_opt
lib/mercury/ints/hlc.gc.trseg/hash_table.opt
lib/mercury/ints/hlc.gc.trseg/hash_table.trans_opt
lib/mercury/ints/hlc.gc.trseg/injection.opt
lib/mercury/ints/hlc.gc.trseg/injection.trans_opt
lib/mercury/ints/hlc.gc.trseg/int.opt
lib/mercury/ints/hlc.gc.trseg/int.trans_opt
lib/mercury/ints/hlc.gc.trseg/integer.opt
lib/mercury/ints/hlc.gc.trseg/integer.trans_opt
lib/mercury/ints/hlc.gc.trseg/io.opt
lib/mercury/ints/hlc.gc.trseg/io.trans_opt
lib/mercury/ints/hlc.gc.trseg/lazy.opt
lib/mercury/ints/hlc.gc.trseg/lazy.trans_opt
lib/mercury/ints/hlc.gc.trseg/lexer.opt
lib/mercury/ints/hlc.gc.trseg/lexer.trans_opt
lib/mercury/ints/hlc.gc.trseg/library.opt
lib/mercury/ints/hlc.gc.trseg/library.trans_opt
lib/mercury/ints/hlc.gc.trseg/list.opt
lib/mercury/ints/hlc.gc.trseg/list.trans_opt
lib/mercury/ints/hlc.gc.trseg/map.opt
lib/mercury/ints/hlc.gc.trseg/map.trans_opt
lib/mercury/ints/hlc.gc.trseg/math.opt
lib/mercury/ints/hlc.gc.trseg/math.trans_opt
lib/mercury/ints/hlc.gc.trseg/maybe.opt
lib/mercury/ints/hlc.gc.trseg/maybe.trans_opt
lib/mercury/ints/hlc.gc.trseg/mer_std.opt
lib/mercury/ints/hlc.gc.trseg/mer_std.trans_opt
lib/mercury/ints/hlc.gc.trseg/multi_map.opt
lib/mercury/ints/hlc.gc.trseg/multi_map.trans_opt
lib/mercury/ints/hlc.gc.trseg/mutvar.opt
lib/mercury/ints/hlc.gc.trseg/mutvar.trans_opt
lib/mercury/ints/hlc.gc.trseg/ops.opt
lib/mercury/ints/hlc.gc.trseg/ops.trans_opt
lib/mercury/ints/hlc.gc.trseg/pair.opt
lib/mercury/ints/hlc.gc.trseg/pair.trans_opt
lib/mercury/ints/hlc.gc.trseg/par_builtin.opt
lib/mercury/ints/hlc.gc.trseg/par_builtin.trans_opt
lib/mercury/ints/hlc.gc.trseg/parser.opt
lib/mercury/ints/hlc.gc.trseg/parser.trans_opt
lib/mercury/ints/hlc.gc.trseg/parsing_utils.opt
lib/mercury/ints/hlc.gc.trseg/parsing_utils.trans_opt
lib/mercury/ints/hlc.gc.trseg/pprint.opt
lib/mercury/ints/hlc.gc.trseg/pprint.trans_opt
lib/mercury/ints/hlc.gc.trseg/pqueue.opt
lib/mercury/ints/hlc.gc.trseg/pqueue.trans_opt
lib/mercury/ints/hlc.gc.trseg/pretty_printer.opt
lib/mercury/ints/hlc.gc.trseg/pretty_printer.trans_opt
lib/mercury/ints/hlc.gc.trseg/private_builtin.opt
lib/mercury/ints/hlc.gc.trseg/private_builtin.trans_opt
lib/mercury/ints/hlc.gc.trseg/profiling_builtin.opt
lib/mercury/ints/hlc.gc.trseg/profiling_builtin.trans_opt
lib/mercury/ints/hlc.gc.trseg/prolog.opt
lib/mercury/ints/hlc.gc.trseg/prolog.trans_opt
lib/mercury/ints/hlc.gc.trseg/queue.opt
lib/mercury/ints/hlc.gc.trseg/queue.trans_opt
lib/mercury/ints/hlc.gc.trseg/random.opt
lib/mercury/ints/hlc.gc.trseg/random.trans_opt
lib/mercury/ints/hlc.gc.trseg/rational.opt
lib/mercury/ints/hlc.gc.trseg/rational.trans_opt
lib/mercury/ints/hlc.gc.trseg/rbtree.opt
lib/mercury/ints/hlc.gc.trseg/rbtree.trans_opt
lib/mercury/ints/hlc.gc.trseg/region_builtin.opt
lib/mercury/ints/hlc.gc.trseg/region_builtin.trans_opt
lib/mercury/ints/hlc.gc.trseg/require.opt
lib/mercury/ints/hlc.gc.trseg/require.trans_opt
lib/mercury/ints/hlc.gc.trseg/robdd.opt
lib/mercury/ints/hlc.gc.trseg/robdd.trans_opt
lib/mercury/ints/hlc.gc.trseg/rtree.opt
lib/mercury/ints/hlc.gc.trseg/rtree.trans_opt
lib/mercury/ints/hlc.gc.trseg/rtti_implementation.opt
lib/mercury/ints/hlc.gc.trseg/rtti_implementation.trans_opt
lib/mercury/ints/hlc.gc.trseg/set.opt
lib/mercury/ints/hlc.gc.trseg/set.trans_opt
lib/mercury/ints/hlc.gc.trseg/set_bbbtree.opt
lib/mercury/ints/hlc.gc.trseg/set_bbbtree.trans_opt
lib/mercury/ints/hlc.gc.trseg/set_ctree234.opt
lib/mercury/ints/hlc.gc.trseg/set_ctree234.trans_opt
lib/mercury/ints/hlc.gc.trseg/set_ordlist.opt
lib/mercury/ints/hlc.gc.trseg/set_ordlist.trans_opt
lib/mercury/ints/hlc.gc.trseg/set_tree234.opt
lib/mercury/ints/hlc.gc.trseg/set_tree234.trans_opt
lib/mercury/ints/hlc.gc.trseg/set_unordlist.opt
lib/mercury/ints/hlc.gc.trseg/set_unordlist.trans_opt
lib/mercury/ints/hlc.gc.trseg/solutions.opt
lib/mercury/ints/hlc.gc.trseg/solutions.trans_opt
lib/mercury/ints/hlc.gc.trseg/sparse_bitset.opt
lib/mercury/ints/hlc.gc.trseg/sparse_bitset.trans_opt
lib/mercury/ints/hlc.gc.trseg/stack.opt
lib/mercury/ints/hlc.gc.trseg/stack.trans_opt
lib/mercury/ints/hlc.gc.trseg/std_util.opt
lib/mercury/ints/hlc.gc.trseg/std_util.trans_opt
lib/mercury/ints/hlc.gc.trseg/stm_builtin.opt
lib/mercury/ints/hlc.gc.trseg/stm_builtin.trans_opt
lib/mercury/ints/hlc.gc.trseg/store.opt
lib/mercury/ints/hlc.gc.trseg/store.trans_opt
lib/mercury/ints/hlc.gc.trseg/stream.opt
lib/mercury/ints/hlc.gc.trseg/stream.string_writer.opt
lib/mercury/ints/hlc.gc.trseg/stream.string_writer.trans_opt
lib/mercury/ints/hlc.gc.trseg/stream.trans_opt
lib/mercury/ints/hlc.gc.trseg/string.builder.opt
lib/mercury/ints/hlc.gc.trseg/string.builder.trans_opt
lib/mercury/ints/hlc.gc.trseg/string.opt
lib/mercury/ints/hlc.gc.trseg/string.trans_opt
lib/mercury/ints/hlc.gc.trseg/table_builtin.opt
lib/mercury/ints/hlc.gc.trseg/table_builtin.trans_opt
lib/mercury/ints/hlc.gc.trseg/table_statistics.opt
lib/mercury/ints/hlc.gc.trseg/table_statistics.trans_opt
lib/mercury/ints/hlc.gc.trseg/term.opt
lib/mercury/ints/hlc.gc.trseg/term.trans_opt
lib/mercury/ints/hlc.gc.trseg/term_io.opt
lib/mercury/ints/hlc.gc.trseg/term_io.trans_opt
lib/mercury/ints/hlc.gc.trseg/term_size_prof_builtin.opt
lib/mercury/ints/hlc.gc.trseg/term_size_prof_builtin.trans_opt
lib/mercury/ints/hlc.gc.trseg/term_to_xml.opt
lib/mercury/ints/hlc.gc.trseg/term_to_xml.trans_opt
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/ints/hlc.gc.trseg/test_bitset.opt
lib/mercury/ints/hlc.gc.trseg/test_bitset.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/hlc.gc.trseg/thread.channel.opt
lib/mercury/ints/hlc.gc.trseg/thread.channel.trans_opt
lib/mercury/ints/hlc.gc.trseg/thread.mvar.opt
lib/mercury/ints/hlc.gc.trseg/thread.mvar.trans_opt
lib/mercury/ints/hlc.gc.trseg/thread.opt
lib/mercury/ints/hlc.gc.trseg/thread.semaphore.opt
lib/mercury/ints/hlc.gc.trseg/thread.semaphore.trans_opt
lib/mercury/ints/hlc.gc.trseg/thread.trans_opt
lib/mercury/ints/hlc.gc.trseg/time.opt
lib/mercury/ints/hlc.gc.trseg/time.trans_opt
lib/mercury/ints/hlc.gc.trseg/tree234.opt
lib/mercury/ints/hlc.gc.trseg/tree234.trans_opt
lib/mercury/ints/hlc.gc.trseg/tree_bitset.opt
lib/mercury/ints/hlc.gc.trseg/tree_bitset.trans_opt
lib/mercury/ints/hlc.gc.trseg/type_desc.opt
lib/mercury/ints/hlc.gc.trseg/type_desc.trans_opt
lib/mercury/ints/hlc.gc.trseg/unit.opt
lib/mercury/ints/hlc.gc.trseg/unit.trans_opt
lib/mercury/ints/hlc.gc.trseg/univ.opt
lib/mercury/ints/hlc.gc.trseg/univ.trans_opt
lib/mercury/ints/hlc.gc.trseg/varset.opt
lib/mercury/ints/hlc.gc.trseg/varset.trans_opt
lib/mercury/ints/hlc.gc.trseg/version_array.opt
lib/mercury/ints/hlc.gc.trseg/version_array.trans_opt
lib/mercury/ints/hlc.gc.trseg/version_array2d.opt
lib/mercury/ints/hlc.gc.trseg/version_array2d.trans_opt
lib/mercury/ints/hlc.gc.trseg/version_bitmap.opt
lib/mercury/ints/hlc.gc.trseg/version_bitmap.trans_opt
lib/mercury/ints/hlc.gc.trseg/version_hash_table.opt
lib/mercury/ints/hlc.gc.trseg/version_hash_table.trans_opt
lib/mercury/ints/hlc.gc.trseg/version_store.opt
lib/mercury/ints/hlc.gc.trseg/version_store.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/Mercury/opts
lib/mercury/ints/hlc.gc/Mercury/trans_opts
lib/mercury/ints/hlc.gc/array.opt
lib/mercury/ints/hlc.gc/array.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/hlc.gc/array2d.opt
lib/mercury/ints/hlc.gc/array2d.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/assoc_list.opt
lib/mercury/ints/hlc.gc/assoc_list.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/hlc.gc/backjump.opt
lib/mercury/ints/hlc.gc/backjump.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/bag.opt
lib/mercury/ints/hlc.gc/bag.trans_opt
lib/mercury/ints/hlc.gc/benchmarking.opt
lib/mercury/ints/hlc.gc/benchmarking.trans_opt
lib/mercury/ints/hlc.gc/bimap.opt
lib/mercury/ints/hlc.gc/bimap.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/hlc.gc/bit_buffer.opt
lib/mercury/ints/hlc.gc/bit_buffer.read.opt
lib/mercury/ints/hlc.gc/bit_buffer.read.trans_opt
lib/mercury/ints/hlc.gc/bit_buffer.trans_opt
lib/mercury/ints/hlc.gc/bit_buffer.write.opt
lib/mercury/ints/hlc.gc/bit_buffer.write.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/bitmap.opt
lib/mercury/ints/hlc.gc/bitmap.trans_opt
lib/mercury/ints/hlc.gc/bool.opt
lib/mercury/ints/hlc.gc/bool.trans_opt
lib/mercury/ints/hlc.gc/bt_array.opt
lib/mercury/ints/hlc.gc/bt_array.trans_opt
lib/mercury/ints/hlc.gc/builtin.opt
lib/mercury/ints/hlc.gc/builtin.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/hlc.gc/calendar.opt
lib/mercury/ints/hlc.gc/calendar.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/char.opt
lib/mercury/ints/hlc.gc/char.trans_opt
lib/mercury/ints/hlc.gc/construct.opt
lib/mercury/ints/hlc.gc/construct.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/hlc.gc/cord.opt
lib/mercury/ints/hlc.gc/cord.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/counter.opt
lib/mercury/ints/hlc.gc/counter.trans_opt
lib/mercury/ints/hlc.gc/deconstruct.opt
lib/mercury/ints/hlc.gc/deconstruct.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/hlc.gc/digraph.opt
lib/mercury/ints/hlc.gc/digraph.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/dir.opt
lib/mercury/ints/hlc.gc/dir.trans_opt
lib/mercury/ints/hlc.gc/enum.opt
lib/mercury/ints/hlc.gc/enum.trans_opt
lib/mercury/ints/hlc.gc/eqvclass.opt
lib/mercury/ints/hlc.gc/eqvclass.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/hlc.gc/erlang_builtin.opt
lib/mercury/ints/hlc.gc/erlang_builtin.trans_opt
lib/mercury/ints/hlc.gc/erlang_rtti_implementation.opt
lib/mercury/ints/hlc.gc/erlang_rtti_implementation.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/exception.opt
lib/mercury/ints/hlc.gc/exception.trans_opt
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/ints/hlc.gc/fat_sparse_bitset.opt
lib/mercury/ints/hlc.gc/fat_sparse_bitset.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/float.opt
lib/mercury/ints/hlc.gc/float.trans_opt
lib/mercury/ints/hlc.gc/gc.opt
lib/mercury/ints/hlc.gc/gc.trans_opt
lib/mercury/ints/hlc.gc/getopt.opt
lib/mercury/ints/hlc.gc/getopt.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/hlc.gc/getopt_io.opt
lib/mercury/ints/hlc.gc/getopt_io.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/hash_table.opt
lib/mercury/ints/hlc.gc/hash_table.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/hlc.gc/injection.opt
lib/mercury/ints/hlc.gc/injection.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/int.opt
lib/mercury/ints/hlc.gc/int.trans_opt
lib/mercury/ints/hlc.gc/integer.opt
lib/mercury/ints/hlc.gc/integer.trans_opt
lib/mercury/ints/hlc.gc/io.opt
lib/mercury/ints/hlc.gc/io.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/hlc.gc/lazy.opt
lib/mercury/ints/hlc.gc/lazy.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/lexer.opt
lib/mercury/ints/hlc.gc/lexer.trans_opt
lib/mercury/ints/hlc.gc/library.opt
lib/mercury/ints/hlc.gc/library.trans_opt
lib/mercury/ints/hlc.gc/list.opt
lib/mercury/ints/hlc.gc/list.trans_opt
lib/mercury/ints/hlc.gc/map.opt
lib/mercury/ints/hlc.gc/map.trans_opt
lib/mercury/ints/hlc.gc/math.opt
lib/mercury/ints/hlc.gc/math.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/hlc.gc/maybe.opt
lib/mercury/ints/hlc.gc/maybe.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/mer_std.opt
lib/mercury/ints/hlc.gc/mer_std.trans_opt
lib/mercury/ints/hlc.gc/multi_map.opt
lib/mercury/ints/hlc.gc/multi_map.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/hlc.gc/mutvar.opt
lib/mercury/ints/hlc.gc/mutvar.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/ops.opt
lib/mercury/ints/hlc.gc/ops.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/hlc.gc/pair.opt
lib/mercury/ints/hlc.gc/pair.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/hlc.gc/par_builtin.opt
lib/mercury/ints/hlc.gc/par_builtin.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/parser.opt
lib/mercury/ints/hlc.gc/parser.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/hlc.gc/parsing_utils.opt
lib/mercury/ints/hlc.gc/parsing_utils.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/pprint.opt
lib/mercury/ints/hlc.gc/pprint.trans_opt
lib/mercury/ints/hlc.gc/pqueue.opt
lib/mercury/ints/hlc.gc/pqueue.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/hlc.gc/pretty_printer.opt
lib/mercury/ints/hlc.gc/pretty_printer.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/private_builtin.opt
lib/mercury/ints/hlc.gc/private_builtin.trans_opt
lib/mercury/ints/hlc.gc/profiling_builtin.opt
lib/mercury/ints/hlc.gc/profiling_builtin.trans_opt
lib/mercury/ints/hlc.gc/prolog.opt
lib/mercury/ints/hlc.gc/prolog.trans_opt
lib/mercury/ints/hlc.gc/queue.opt
lib/mercury/ints/hlc.gc/queue.trans_opt
lib/mercury/ints/hlc.gc/random.opt
lib/mercury/ints/hlc.gc/random.trans_opt
lib/mercury/ints/hlc.gc/rational.opt
lib/mercury/ints/hlc.gc/rational.trans_opt
lib/mercury/ints/hlc.gc/rbtree.opt
lib/mercury/ints/hlc.gc/rbtree.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/hlc.gc/region_builtin.opt
lib/mercury/ints/hlc.gc/region_builtin.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/require.opt
lib/mercury/ints/hlc.gc/require.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/hlc.gc/robdd.opt
lib/mercury/ints/hlc.gc/robdd.trans_opt
lib/mercury/ints/hlc.gc/rtree.opt
lib/mercury/ints/hlc.gc/rtree.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/rtti_implementation.opt
lib/mercury/ints/hlc.gc/rtti_implementation.trans_opt
lib/mercury/ints/hlc.gc/set.opt
lib/mercury/ints/hlc.gc/set.trans_opt
lib/mercury/ints/hlc.gc/set_bbbtree.opt
lib/mercury/ints/hlc.gc/set_bbbtree.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/hlc.gc/set_ctree234.opt
lib/mercury/ints/hlc.gc/set_ctree234.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/set_ordlist.opt
lib/mercury/ints/hlc.gc/set_ordlist.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/hlc.gc/set_tree234.opt
lib/mercury/ints/hlc.gc/set_tree234.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/set_unordlist.opt
lib/mercury/ints/hlc.gc/set_unordlist.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/hlc.gc/solutions.opt
lib/mercury/ints/hlc.gc/solutions.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/sparse_bitset.opt
lib/mercury/ints/hlc.gc/sparse_bitset.trans_opt
lib/mercury/ints/hlc.gc/stack.opt
lib/mercury/ints/hlc.gc/stack.trans_opt
lib/mercury/ints/hlc.gc/std_util.opt
lib/mercury/ints/hlc.gc/std_util.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/hlc.gc/stm_builtin.opt
lib/mercury/ints/hlc.gc/stm_builtin.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/store.opt
lib/mercury/ints/hlc.gc/store.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/hlc.gc/stream.opt
lib/mercury/ints/hlc.gc/stream.string_writer.opt
lib/mercury/ints/hlc.gc/stream.string_writer.trans_opt
lib/mercury/ints/hlc.gc/stream.trans_opt
lib/mercury/ints/hlc.gc/string.builder.opt
lib/mercury/ints/hlc.gc/string.builder.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/string.opt
lib/mercury/ints/hlc.gc/string.trans_opt
lib/mercury/ints/hlc.gc/table_builtin.opt
lib/mercury/ints/hlc.gc/table_builtin.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/hlc.gc/table_statistics.opt
lib/mercury/ints/hlc.gc/table_statistics.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/term.opt
lib/mercury/ints/hlc.gc/term.trans_opt
lib/mercury/ints/hlc.gc/term_io.opt
lib/mercury/ints/hlc.gc/term_io.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/hlc.gc/term_size_prof_builtin.opt
lib/mercury/ints/hlc.gc/term_size_prof_builtin.trans_opt
lib/mercury/ints/hlc.gc/term_to_xml.opt
lib/mercury/ints/hlc.gc/term_to_xml.trans_opt
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/ints/hlc.gc/test_bitset.opt
lib/mercury/ints/hlc.gc/test_bitset.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/hlc.gc/thread.channel.opt
lib/mercury/ints/hlc.gc/thread.channel.trans_opt
lib/mercury/ints/hlc.gc/thread.mvar.opt
lib/mercury/ints/hlc.gc/thread.mvar.trans_opt
lib/mercury/ints/hlc.gc/thread.opt
lib/mercury/ints/hlc.gc/thread.semaphore.opt
lib/mercury/ints/hlc.gc/thread.semaphore.trans_opt
lib/mercury/ints/hlc.gc/thread.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/time.opt
lib/mercury/ints/hlc.gc/time.trans_opt
lib/mercury/ints/hlc.gc/tree234.opt
lib/mercury/ints/hlc.gc/tree234.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/hlc.gc/tree_bitset.opt
lib/mercury/ints/hlc.gc/tree_bitset.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/type_desc.opt
lib/mercury/ints/hlc.gc/type_desc.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/hlc.gc/unit.opt
lib/mercury/ints/hlc.gc/unit.trans_opt
lib/mercury/ints/hlc.gc/univ.opt
lib/mercury/ints/hlc.gc/univ.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/hlc.gc/varset.opt
lib/mercury/ints/hlc.gc/varset.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/hlc.gc/version_array.opt
lib/mercury/ints/hlc.gc/version_array.trans_opt
lib/mercury/ints/hlc.gc/version_array2d.opt
lib/mercury/ints/hlc.gc/version_array2d.trans_opt
lib/mercury/ints/hlc.gc/version_bitmap.opt
lib/mercury/ints/hlc.gc/version_bitmap.trans_opt
lib/mercury/ints/hlc.gc/version_hash_table.opt
lib/mercury/ints/hlc.gc/version_hash_table.trans_opt
lib/mercury/ints/hlc.gc/version_store.opt
lib/mercury/ints/hlc.gc/version_store.trans_opt
lib/mercury/ints/injection.int
lib/mercury/ints/injection.int2
lib/mercury/ints/injection.int3
lib/mercury/ints/injection.mh
lib/mercury/ints/injection.mih
lib/mercury/ints/injection.module_dep
lib/mercury/ints/injection.opt
lib/mercury/ints/injection.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/int.int
lib/mercury/ints/int.int2
lib/mercury/ints/int.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/int.mh
lib/mercury/ints/int.mih
lib/mercury/ints/int.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/int.opt
lib/mercury/ints/int.trans_opt
lib/mercury/ints/integer.int
lib/mercury/ints/integer.int2
lib/mercury/ints/integer.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/integer.mh
lib/mercury/ints/integer.mih
lib/mercury/ints/integer.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/integer.opt
lib/mercury/ints/integer.trans_opt
lib/mercury/ints/io.int
lib/mercury/ints/io.int2
lib/mercury/ints/io.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/io.mh
lib/mercury/ints/io.mih
lib/mercury/ints/io.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/io.opt
lib/mercury/ints/io.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/lazy.int
lib/mercury/ints/lazy.int2
lib/mercury/ints/lazy.int3
lib/mercury/ints/lazy.mh
lib/mercury/ints/lazy.mih
lib/mercury/ints/lazy.module_dep
lib/mercury/ints/lazy.opt
lib/mercury/ints/lazy.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/lexer.int
lib/mercury/ints/lexer.int2
lib/mercury/ints/lexer.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/lexer.mh
lib/mercury/ints/lexer.mih
lib/mercury/ints/lexer.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/lexer.opt
lib/mercury/ints/lexer.trans_opt
lib/mercury/ints/library.int
lib/mercury/ints/library.int2
lib/mercury/ints/library.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/library.mh
lib/mercury/ints/library.mih
lib/mercury/ints/library.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/library.opt
lib/mercury/ints/library.trans_opt
lib/mercury/ints/list.int
lib/mercury/ints/list.int2
lib/mercury/ints/list.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/list.mh
lib/mercury/ints/list.mih
lib/mercury/ints/list.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/list.opt
lib/mercury/ints/list.trans_opt
lib/mercury/ints/map.int
lib/mercury/ints/map.int2
lib/mercury/ints/map.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/map.mh
lib/mercury/ints/map.mih
lib/mercury/ints/map.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/map.opt
lib/mercury/ints/map.trans_opt
lib/mercury/ints/math.int
lib/mercury/ints/math.int2
lib/mercury/ints/math.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/math.mh
lib/mercury/ints/math.mih
lib/mercury/ints/math.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/math.opt
lib/mercury/ints/math.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/maybe.int
lib/mercury/ints/maybe.int2
lib/mercury/ints/maybe.int3
lib/mercury/ints/maybe.mh
lib/mercury/ints/maybe.mih
lib/mercury/ints/maybe.module_dep
lib/mercury/ints/maybe.opt
lib/mercury/ints/maybe.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/mdb.browse.int
lib/mercury/ints/mdb.browse.int2
lib/mercury/ints/mdb.browse.int3
lib/mercury/ints/mdb.browse.mh
lib/mercury/ints/mdb.browse.mih
lib/mercury/ints/mdb.browse.module_dep
lib/mercury/ints/mdb.browser_info.int
lib/mercury/ints/mdb.browser_info.int2
lib/mercury/ints/mdb.browser_info.int3
lib/mercury/ints/mdb.browser_info.mh
lib/mercury/ints/mdb.browser_info.mih
lib/mercury/ints/mdb.browser_info.module_dep
lib/mercury/ints/mdb.browser_term.int
lib/mercury/ints/mdb.browser_term.int2
lib/mercury/ints/mdb.browser_term.int3
lib/mercury/ints/mdb.browser_term.mh
lib/mercury/ints/mdb.browser_term.mih
lib/mercury/ints/mdb.browser_term.module_dep
lib/mercury/ints/mdb.collect_lib.int
lib/mercury/ints/mdb.collect_lib.int2
lib/mercury/ints/mdb.collect_lib.int3
lib/mercury/ints/mdb.collect_lib.mh
lib/mercury/ints/mdb.collect_lib.mih
lib/mercury/ints/mdb.collect_lib.module_dep
lib/mercury/ints/mdb.cterm.int
lib/mercury/ints/mdb.cterm.int2
lib/mercury/ints/mdb.cterm.int3
lib/mercury/ints/mdb.cterm.mh
lib/mercury/ints/mdb.cterm.mih
lib/mercury/ints/mdb.cterm.module_dep
lib/mercury/ints/mdb.debugger_interface.int
lib/mercury/ints/mdb.debugger_interface.int2
lib/mercury/ints/mdb.debugger_interface.int3
lib/mercury/ints/mdb.debugger_interface.mh
lib/mercury/ints/mdb.debugger_interface.mih
lib/mercury/ints/mdb.debugger_interface.module_dep
lib/mercury/ints/mdb.declarative_analyser.int
lib/mercury/ints/mdb.declarative_analyser.int2
lib/mercury/ints/mdb.declarative_analyser.int3
lib/mercury/ints/mdb.declarative_analyser.mh
lib/mercury/ints/mdb.declarative_analyser.mih
lib/mercury/ints/mdb.declarative_analyser.module_dep
lib/mercury/ints/mdb.declarative_debugger.int
lib/mercury/ints/mdb.declarative_debugger.int2
lib/mercury/ints/mdb.declarative_debugger.int3
lib/mercury/ints/mdb.declarative_debugger.mh
lib/mercury/ints/mdb.declarative_debugger.mih
lib/mercury/ints/mdb.declarative_debugger.module_dep
lib/mercury/ints/mdb.declarative_edt.int
lib/mercury/ints/mdb.declarative_edt.int2
lib/mercury/ints/mdb.declarative_edt.int3
lib/mercury/ints/mdb.declarative_edt.mh
lib/mercury/ints/mdb.declarative_edt.mih
lib/mercury/ints/mdb.declarative_edt.module_dep
lib/mercury/ints/mdb.declarative_execution.int
lib/mercury/ints/mdb.declarative_execution.int2
lib/mercury/ints/mdb.declarative_execution.int3
lib/mercury/ints/mdb.declarative_execution.mh
lib/mercury/ints/mdb.declarative_execution.mih
lib/mercury/ints/mdb.declarative_execution.module_dep
lib/mercury/ints/mdb.declarative_oracle.int
lib/mercury/ints/mdb.declarative_oracle.int2
lib/mercury/ints/mdb.declarative_oracle.int3
lib/mercury/ints/mdb.declarative_oracle.mh
lib/mercury/ints/mdb.declarative_oracle.mih
lib/mercury/ints/mdb.declarative_oracle.module_dep
lib/mercury/ints/mdb.declarative_tree.int
lib/mercury/ints/mdb.declarative_tree.int2
lib/mercury/ints/mdb.declarative_tree.int3
lib/mercury/ints/mdb.declarative_tree.mh
lib/mercury/ints/mdb.declarative_tree.mih
lib/mercury/ints/mdb.declarative_tree.module_dep
lib/mercury/ints/mdb.declarative_user.int
lib/mercury/ints/mdb.declarative_user.int2
lib/mercury/ints/mdb.declarative_user.int3
lib/mercury/ints/mdb.declarative_user.mh
lib/mercury/ints/mdb.declarative_user.mih
lib/mercury/ints/mdb.declarative_user.module_dep
lib/mercury/ints/mdb.diff.int
lib/mercury/ints/mdb.diff.int2
lib/mercury/ints/mdb.diff.int3
lib/mercury/ints/mdb.diff.mh
lib/mercury/ints/mdb.diff.mih
lib/mercury/ints/mdb.diff.module_dep
lib/mercury/ints/mdb.dl.int
lib/mercury/ints/mdb.dl.int2
lib/mercury/ints/mdb.dl.int3
lib/mercury/ints/mdb.dl.mh
lib/mercury/ints/mdb.dl.mih
lib/mercury/ints/mdb.dl.module_dep
lib/mercury/ints/mdb.frame.int
lib/mercury/ints/mdb.frame.int2
lib/mercury/ints/mdb.frame.int3
lib/mercury/ints/mdb.frame.mh
lib/mercury/ints/mdb.frame.mih
lib/mercury/ints/mdb.frame.module_dep
lib/mercury/ints/mdb.help.int
lib/mercury/ints/mdb.help.int2
lib/mercury/ints/mdb.help.int3
lib/mercury/ints/mdb.help.mh
lib/mercury/ints/mdb.help.mih
lib/mercury/ints/mdb.help.module_dep
lib/mercury/ints/mdb.int
lib/mercury/ints/mdb.int2
lib/mercury/ints/mdb.int3
lib/mercury/ints/mdb.interactive_query.int
lib/mercury/ints/mdb.interactive_query.int2
lib/mercury/ints/mdb.interactive_query.int3
lib/mercury/ints/mdb.interactive_query.mh
lib/mercury/ints/mdb.interactive_query.mih
lib/mercury/ints/mdb.interactive_query.module_dep
lib/mercury/ints/mdb.io_action.int
lib/mercury/ints/mdb.io_action.int2
lib/mercury/ints/mdb.io_action.int3
lib/mercury/ints/mdb.io_action.mh
lib/mercury/ints/mdb.io_action.mih
lib/mercury/ints/mdb.io_action.module_dep
lib/mercury/ints/mdb.listing.int
lib/mercury/ints/mdb.listing.int2
lib/mercury/ints/mdb.listing.int3
lib/mercury/ints/mdb.listing.mh
lib/mercury/ints/mdb.listing.mih
lib/mercury/ints/mdb.listing.module_dep
lib/mercury/ints/mdb.mh
lib/mercury/ints/mdb.mih
lib/mercury/ints/mdb.module_dep
lib/mercury/ints/mdb.name_mangle.int
lib/mercury/ints/mdb.name_mangle.int2
lib/mercury/ints/mdb.name_mangle.int3
lib/mercury/ints/mdb.name_mangle.mh
lib/mercury/ints/mdb.name_mangle.mih
lib/mercury/ints/mdb.name_mangle.module_dep
lib/mercury/ints/mdb.parse.int
lib/mercury/ints/mdb.parse.int2
lib/mercury/ints/mdb.parse.int3
lib/mercury/ints/mdb.parse.mh
lib/mercury/ints/mdb.parse.mih
lib/mercury/ints/mdb.parse.module_dep
lib/mercury/ints/mdb.sized_pretty.int
lib/mercury/ints/mdb.sized_pretty.int2
lib/mercury/ints/mdb.sized_pretty.int3
lib/mercury/ints/mdb.sized_pretty.mh
lib/mercury/ints/mdb.sized_pretty.mih
lib/mercury/ints/mdb.sized_pretty.module_dep
lib/mercury/ints/mdb.term_rep.int
lib/mercury/ints/mdb.term_rep.int2
lib/mercury/ints/mdb.term_rep.int3
lib/mercury/ints/mdb.term_rep.mh
lib/mercury/ints/mdb.term_rep.mih
lib/mercury/ints/mdb.term_rep.module_dep
lib/mercury/ints/mdb.util.int
lib/mercury/ints/mdb.util.int2
lib/mercury/ints/mdb.util.int3
lib/mercury/ints/mdb.util.mh
lib/mercury/ints/mdb.util.mih
lib/mercury/ints/mdb.util.module_dep
lib/mercury/ints/mdbcomp.feedback.automatic_parallelism.int
lib/mercury/ints/mdbcomp.feedback.automatic_parallelism.int2
lib/mercury/ints/mdbcomp.feedback.automatic_parallelism.int3
lib/mercury/ints/mdbcomp.feedback.automatic_parallelism.mh
lib/mercury/ints/mdbcomp.feedback.automatic_parallelism.mih
lib/mercury/ints/mdbcomp.feedback.automatic_parallelism.module_dep
lib/mercury/ints/mdbcomp.feedback.int
lib/mercury/ints/mdbcomp.feedback.int2
lib/mercury/ints/mdbcomp.feedback.int3
lib/mercury/ints/mdbcomp.feedback.mh
lib/mercury/ints/mdbcomp.feedback.mih
lib/mercury/ints/mdbcomp.feedback.module_dep
lib/mercury/ints/mdbcomp.goal_path.int
lib/mercury/ints/mdbcomp.goal_path.int2
lib/mercury/ints/mdbcomp.goal_path.int3
lib/mercury/ints/mdbcomp.goal_path.mh
lib/mercury/ints/mdbcomp.goal_path.mih
lib/mercury/ints/mdbcomp.goal_path.module_dep
lib/mercury/ints/mdbcomp.int
lib/mercury/ints/mdbcomp.int2
lib/mercury/ints/mdbcomp.int3
lib/mercury/ints/mdbcomp.mh
lib/mercury/ints/mdbcomp.mih
lib/mercury/ints/mdbcomp.module_dep
lib/mercury/ints/mdbcomp.prim_data.int
lib/mercury/ints/mdbcomp.prim_data.int2
lib/mercury/ints/mdbcomp.prim_data.int3
lib/mercury/ints/mdbcomp.prim_data.mh
lib/mercury/ints/mdbcomp.prim_data.mih
lib/mercury/ints/mdbcomp.prim_data.module_dep
lib/mercury/ints/mdbcomp.program_representation.int
lib/mercury/ints/mdbcomp.program_representation.int2
lib/mercury/ints/mdbcomp.program_representation.int3
lib/mercury/ints/mdbcomp.program_representation.mh
lib/mercury/ints/mdbcomp.program_representation.mih
lib/mercury/ints/mdbcomp.program_representation.module_dep
lib/mercury/ints/mdbcomp.rtti_access.int
lib/mercury/ints/mdbcomp.rtti_access.int2
lib/mercury/ints/mdbcomp.rtti_access.int3
lib/mercury/ints/mdbcomp.rtti_access.mh
lib/mercury/ints/mdbcomp.rtti_access.mih
lib/mercury/ints/mdbcomp.rtti_access.module_dep
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/ints/mdbcomp.shared_utilities.int
lib/mercury/ints/mdbcomp.shared_utilities.int2
lib/mercury/ints/mdbcomp.shared_utilities.int3
lib/mercury/ints/mdbcomp.shared_utilities.mh
lib/mercury/ints/mdbcomp.shared_utilities.mih
lib/mercury/ints/mdbcomp.shared_utilities.module_dep
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/mdbcomp.slice_and_dice.int
lib/mercury/ints/mdbcomp.slice_and_dice.int2
lib/mercury/ints/mdbcomp.slice_and_dice.int3
lib/mercury/ints/mdbcomp.slice_and_dice.mh
lib/mercury/ints/mdbcomp.slice_and_dice.mih
lib/mercury/ints/mdbcomp.slice_and_dice.module_dep
lib/mercury/ints/mdbcomp.trace_counts.int
lib/mercury/ints/mdbcomp.trace_counts.int2
lib/mercury/ints/mdbcomp.trace_counts.int3
lib/mercury/ints/mdbcomp.trace_counts.mh
lib/mercury/ints/mdbcomp.trace_counts.mih
lib/mercury/ints/mdbcomp.trace_counts.module_dep
lib/mercury/ints/mer_browser.int
lib/mercury/ints/mer_browser.int2
lib/mercury/ints/mer_browser.int3
lib/mercury/ints/mer_browser.mh
lib/mercury/ints/mer_browser.mih
lib/mercury/ints/mer_browser.module_dep
lib/mercury/ints/mer_mdbcomp.int
lib/mercury/ints/mer_mdbcomp.int2
lib/mercury/ints/mer_mdbcomp.int3
lib/mercury/ints/mer_mdbcomp.mh
lib/mercury/ints/mer_mdbcomp.mih
lib/mercury/ints/mer_mdbcomp.module_dep
lib/mercury/ints/mer_ssdb.int
lib/mercury/ints/mer_ssdb.int2
lib/mercury/ints/mer_ssdb.int3
lib/mercury/ints/mer_ssdb.mh
lib/mercury/ints/mer_ssdb.mih
lib/mercury/ints/mer_ssdb.module_dep
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/mer_std.int
lib/mercury/ints/mer_std.int2
lib/mercury/ints/mer_std.int3
lib/mercury/ints/mer_std.mh
lib/mercury/ints/mer_std.mih
lib/mercury/ints/mer_std.module_dep
lib/mercury/ints/mer_std.opt
lib/mercury/ints/mer_std.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/multi_map.int
lib/mercury/ints/multi_map.int2
lib/mercury/ints/multi_map.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/multi_map.mh
lib/mercury/ints/multi_map.mih
lib/mercury/ints/multi_map.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/multi_map.opt
lib/mercury/ints/multi_map.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/mutvar.int
lib/mercury/ints/mutvar.int2
lib/mercury/ints/mutvar.int3
lib/mercury/ints/mutvar.mh
lib/mercury/ints/mutvar.mih
lib/mercury/ints/mutvar.module_dep
lib/mercury/ints/mutvar.opt
lib/mercury/ints/mutvar.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/ops.int
lib/mercury/ints/ops.int2
lib/mercury/ints/ops.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/ops.mh
lib/mercury/ints/ops.mih
lib/mercury/ints/ops.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/ops.opt
lib/mercury/ints/ops.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/pair.int
lib/mercury/ints/pair.int2
lib/mercury/ints/pair.int3
lib/mercury/ints/pair.mh
lib/mercury/ints/pair.mih
lib/mercury/ints/pair.module_dep
lib/mercury/ints/pair.opt
lib/mercury/ints/pair.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/par_builtin.int
lib/mercury/ints/par_builtin.int2
lib/mercury/ints/par_builtin.int3
lib/mercury/ints/par_builtin.mh
lib/mercury/ints/par_builtin.mih
lib/mercury/ints/par_builtin.module_dep
lib/mercury/ints/par_builtin.opt
lib/mercury/ints/par_builtin.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/parser.int
lib/mercury/ints/parser.int2
lib/mercury/ints/parser.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/parser.mh
lib/mercury/ints/parser.mih
lib/mercury/ints/parser.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/parser.opt
lib/mercury/ints/parser.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/parsing_utils.int
lib/mercury/ints/parsing_utils.int2
lib/mercury/ints/parsing_utils.int3
lib/mercury/ints/parsing_utils.mh
lib/mercury/ints/parsing_utils.mih
lib/mercury/ints/parsing_utils.module_dep
lib/mercury/ints/parsing_utils.opt
lib/mercury/ints/parsing_utils.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/pprint.int
lib/mercury/ints/pprint.int2
lib/mercury/ints/pprint.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/pprint.mh
lib/mercury/ints/pprint.mih
lib/mercury/ints/pprint.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/pprint.opt
lib/mercury/ints/pprint.trans_opt
lib/mercury/ints/pqueue.int
lib/mercury/ints/pqueue.int2
lib/mercury/ints/pqueue.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/pqueue.mh
lib/mercury/ints/pqueue.mih
lib/mercury/ints/pqueue.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/pqueue.opt
lib/mercury/ints/pqueue.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/pretty_printer.int
lib/mercury/ints/pretty_printer.int2
lib/mercury/ints/pretty_printer.int3
lib/mercury/ints/pretty_printer.mh
lib/mercury/ints/pretty_printer.mih
lib/mercury/ints/pretty_printer.module_dep
lib/mercury/ints/pretty_printer.opt
lib/mercury/ints/pretty_printer.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/private_builtin.int
lib/mercury/ints/private_builtin.int2
lib/mercury/ints/private_builtin.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/private_builtin.mh
lib/mercury/ints/private_builtin.mih
lib/mercury/ints/private_builtin.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/private_builtin.opt
lib/mercury/ints/private_builtin.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/profiling_builtin.int
lib/mercury/ints/profiling_builtin.int2
lib/mercury/ints/profiling_builtin.int3
lib/mercury/ints/profiling_builtin.mh
lib/mercury/ints/profiling_builtin.mih
lib/mercury/ints/profiling_builtin.module_dep
lib/mercury/ints/profiling_builtin.opt
lib/mercury/ints/profiling_builtin.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/prolog.int
lib/mercury/ints/prolog.int2
lib/mercury/ints/prolog.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/prolog.mh
lib/mercury/ints/prolog.mih
lib/mercury/ints/prolog.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/prolog.opt
lib/mercury/ints/prolog.trans_opt
lib/mercury/ints/queue.int
lib/mercury/ints/queue.int2
lib/mercury/ints/queue.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/queue.mh
lib/mercury/ints/queue.mih
lib/mercury/ints/queue.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/queue.opt
lib/mercury/ints/queue.trans_opt
lib/mercury/ints/random.int
lib/mercury/ints/random.int2
lib/mercury/ints/random.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/random.mh
lib/mercury/ints/random.mih
lib/mercury/ints/random.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/random.opt
lib/mercury/ints/random.trans_opt
lib/mercury/ints/rational.int
lib/mercury/ints/rational.int2
lib/mercury/ints/rational.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/rational.mh
lib/mercury/ints/rational.mih
lib/mercury/ints/rational.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/rational.opt
lib/mercury/ints/rational.trans_opt
lib/mercury/ints/rbtree.int
lib/mercury/ints/rbtree.int2
lib/mercury/ints/rbtree.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/rbtree.mh
lib/mercury/ints/rbtree.mih
lib/mercury/ints/rbtree.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/rbtree.opt
lib/mercury/ints/rbtree.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/region_builtin.int
lib/mercury/ints/region_builtin.int2
lib/mercury/ints/region_builtin.int3
lib/mercury/ints/region_builtin.mh
lib/mercury/ints/region_builtin.mih
lib/mercury/ints/region_builtin.module_dep
lib/mercury/ints/region_builtin.opt
lib/mercury/ints/region_builtin.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/require.int
lib/mercury/ints/require.int2
lib/mercury/ints/require.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/require.mh
lib/mercury/ints/require.mih
lib/mercury/ints/require.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/require.opt
lib/mercury/ints/require.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/robdd.int
lib/mercury/ints/robdd.int2
lib/mercury/ints/robdd.int3
lib/mercury/ints/robdd.mh
lib/mercury/ints/robdd.mih
lib/mercury/ints/robdd.module_dep
lib/mercury/ints/robdd.opt
lib/mercury/ints/robdd.trans_opt
lib/mercury/ints/rtree.int
lib/mercury/ints/rtree.int2
lib/mercury/ints/rtree.int3
lib/mercury/ints/rtree.mh
lib/mercury/ints/rtree.mih
lib/mercury/ints/rtree.module_dep
lib/mercury/ints/rtree.opt
lib/mercury/ints/rtree.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/rtti_implementation.int
lib/mercury/ints/rtti_implementation.int2
lib/mercury/ints/rtti_implementation.int3
lib/mercury/ints/rtti_implementation.mh
lib/mercury/ints/rtti_implementation.mih
lib/mercury/ints/rtti_implementation.module_dep
lib/mercury/ints/rtti_implementation.opt
lib/mercury/ints/rtti_implementation.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/set.int
lib/mercury/ints/set.int2
lib/mercury/ints/set.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/set.mh
lib/mercury/ints/set.mih
lib/mercury/ints/set.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/set.opt
lib/mercury/ints/set.trans_opt
lib/mercury/ints/set_bbbtree.int
lib/mercury/ints/set_bbbtree.int2
lib/mercury/ints/set_bbbtree.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/set_bbbtree.mh
lib/mercury/ints/set_bbbtree.mih
lib/mercury/ints/set_bbbtree.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/set_bbbtree.opt
lib/mercury/ints/set_bbbtree.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/set_ctree234.int
lib/mercury/ints/set_ctree234.int2
lib/mercury/ints/set_ctree234.int3
lib/mercury/ints/set_ctree234.mh
lib/mercury/ints/set_ctree234.mih
lib/mercury/ints/set_ctree234.module_dep
lib/mercury/ints/set_ctree234.opt
lib/mercury/ints/set_ctree234.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/set_ordlist.int
lib/mercury/ints/set_ordlist.int2
lib/mercury/ints/set_ordlist.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/set_ordlist.mh
lib/mercury/ints/set_ordlist.mih
lib/mercury/ints/set_ordlist.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/set_ordlist.opt
lib/mercury/ints/set_ordlist.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/set_tree234.int
lib/mercury/ints/set_tree234.int2
lib/mercury/ints/set_tree234.int3
lib/mercury/ints/set_tree234.mh
lib/mercury/ints/set_tree234.mih
lib/mercury/ints/set_tree234.module_dep
lib/mercury/ints/set_tree234.opt
lib/mercury/ints/set_tree234.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/set_unordlist.int
lib/mercury/ints/set_unordlist.int2
lib/mercury/ints/set_unordlist.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/set_unordlist.mh
lib/mercury/ints/set_unordlist.mih
lib/mercury/ints/set_unordlist.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/set_unordlist.opt
lib/mercury/ints/set_unordlist.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/solutions.int
lib/mercury/ints/solutions.int2
lib/mercury/ints/solutions.int3
lib/mercury/ints/solutions.mh
lib/mercury/ints/solutions.mih
lib/mercury/ints/solutions.module_dep
lib/mercury/ints/solutions.opt
lib/mercury/ints/solutions.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/sparse_bitset.int
lib/mercury/ints/sparse_bitset.int2
lib/mercury/ints/sparse_bitset.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/sparse_bitset.mh
lib/mercury/ints/sparse_bitset.mih
lib/mercury/ints/sparse_bitset.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/sparse_bitset.opt
lib/mercury/ints/sparse_bitset.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/ssdb.int
lib/mercury/ints/ssdb.int2
lib/mercury/ints/ssdb.int3
lib/mercury/ints/ssdb.mh
lib/mercury/ints/ssdb.mih
lib/mercury/ints/ssdb.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/stack.int
lib/mercury/ints/stack.int2
lib/mercury/ints/stack.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/stack.mh
lib/mercury/ints/stack.mih
lib/mercury/ints/stack.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/stack.opt
lib/mercury/ints/stack.trans_opt
lib/mercury/ints/std_util.int
lib/mercury/ints/std_util.int2
lib/mercury/ints/std_util.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/std_util.mh
lib/mercury/ints/std_util.mih
lib/mercury/ints/std_util.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/std_util.opt
lib/mercury/ints/std_util.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/stm_builtin.int
lib/mercury/ints/stm_builtin.int2
lib/mercury/ints/stm_builtin.int3
lib/mercury/ints/stm_builtin.mh
lib/mercury/ints/stm_builtin.mih
lib/mercury/ints/stm_builtin.module_dep
lib/mercury/ints/stm_builtin.opt
lib/mercury/ints/stm_builtin.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/store.int
lib/mercury/ints/store.int2
lib/mercury/ints/store.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/store.mh
lib/mercury/ints/store.mih
lib/mercury/ints/store.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/store.opt
lib/mercury/ints/store.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/stream.int
lib/mercury/ints/stream.int0
lib/mercury/ints/stream.int2
lib/mercury/ints/stream.int3
lib/mercury/ints/stream.mh
lib/mercury/ints/stream.mih
lib/mercury/ints/stream.module_dep
lib/mercury/ints/stream.opt
lib/mercury/ints/stream.string_writer.int
lib/mercury/ints/stream.string_writer.int2
lib/mercury/ints/stream.string_writer.int3
lib/mercury/ints/stream.string_writer.mh
lib/mercury/ints/stream.string_writer.mih
lib/mercury/ints/stream.string_writer.module_dep
lib/mercury/ints/stream.string_writer.opt
lib/mercury/ints/stream.string_writer.trans_opt
lib/mercury/ints/stream.trans_opt
lib/mercury/ints/string.builder.int
lib/mercury/ints/string.builder.int2
lib/mercury/ints/string.builder.int3
lib/mercury/ints/string.builder.mh
lib/mercury/ints/string.builder.mih
lib/mercury/ints/string.builder.module_dep
lib/mercury/ints/string.builder.opt
lib/mercury/ints/string.builder.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/string.int
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/string.int0
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/string.int2
lib/mercury/ints/string.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/string.mh
lib/mercury/ints/string.mih
lib/mercury/ints/string.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/string.opt
lib/mercury/ints/string.trans_opt
lib/mercury/ints/table_builtin.int
lib/mercury/ints/table_builtin.int2
lib/mercury/ints/table_builtin.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/table_builtin.mh
lib/mercury/ints/table_builtin.mih
lib/mercury/ints/table_builtin.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/table_builtin.opt
lib/mercury/ints/table_builtin.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/table_statistics.int
lib/mercury/ints/table_statistics.int2
lib/mercury/ints/table_statistics.int3
lib/mercury/ints/table_statistics.mh
lib/mercury/ints/table_statistics.mih
lib/mercury/ints/table_statistics.module_dep
lib/mercury/ints/table_statistics.opt
lib/mercury/ints/table_statistics.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/term.int
lib/mercury/ints/term.int2
lib/mercury/ints/term.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/term.mh
lib/mercury/ints/term.mih
lib/mercury/ints/term.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/term.opt
lib/mercury/ints/term.trans_opt
lib/mercury/ints/term_io.int
lib/mercury/ints/term_io.int2
lib/mercury/ints/term_io.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/term_io.mh
lib/mercury/ints/term_io.mih
lib/mercury/ints/term_io.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/term_io.opt
lib/mercury/ints/term_io.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/term_size_prof_builtin.int
lib/mercury/ints/term_size_prof_builtin.int2
lib/mercury/ints/term_size_prof_builtin.int3
lib/mercury/ints/term_size_prof_builtin.mh
lib/mercury/ints/term_size_prof_builtin.mih
lib/mercury/ints/term_size_prof_builtin.module_dep
lib/mercury/ints/term_size_prof_builtin.opt
lib/mercury/ints/term_size_prof_builtin.trans_opt
lib/mercury/ints/term_to_xml.int
lib/mercury/ints/term_to_xml.int2
lib/mercury/ints/term_to_xml.int3
lib/mercury/ints/term_to_xml.mh
lib/mercury/ints/term_to_xml.mih
lib/mercury/ints/term_to_xml.module_dep
lib/mercury/ints/term_to_xml.opt
lib/mercury/ints/term_to_xml.trans_opt
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/ints/test_bitset.int
lib/mercury/ints/test_bitset.int2
lib/mercury/ints/test_bitset.int3
lib/mercury/ints/test_bitset.mh
lib/mercury/ints/test_bitset.mih
lib/mercury/ints/test_bitset.module_dep
lib/mercury/ints/test_bitset.opt
lib/mercury/ints/test_bitset.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/thread.channel.int
lib/mercury/ints/thread.channel.int2
lib/mercury/ints/thread.channel.int3
lib/mercury/ints/thread.channel.mh
lib/mercury/ints/thread.channel.mih
lib/mercury/ints/thread.channel.module_dep
lib/mercury/ints/thread.channel.opt
lib/mercury/ints/thread.channel.trans_opt
lib/mercury/ints/thread.int
lib/mercury/ints/thread.int0
lib/mercury/ints/thread.int2
lib/mercury/ints/thread.int3
lib/mercury/ints/thread.mh
lib/mercury/ints/thread.mih
lib/mercury/ints/thread.module_dep
lib/mercury/ints/thread.mvar.int
lib/mercury/ints/thread.mvar.int2
lib/mercury/ints/thread.mvar.int3
lib/mercury/ints/thread.mvar.mh
lib/mercury/ints/thread.mvar.mih
lib/mercury/ints/thread.mvar.module_dep
lib/mercury/ints/thread.mvar.opt
lib/mercury/ints/thread.mvar.trans_opt
lib/mercury/ints/thread.opt
lib/mercury/ints/thread.semaphore.int
lib/mercury/ints/thread.semaphore.int2
lib/mercury/ints/thread.semaphore.int3
lib/mercury/ints/thread.semaphore.mh
lib/mercury/ints/thread.semaphore.mih
lib/mercury/ints/thread.semaphore.module_dep
lib/mercury/ints/thread.semaphore.opt
lib/mercury/ints/thread.semaphore.trans_opt
lib/mercury/ints/thread.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/time.int
lib/mercury/ints/time.int2
lib/mercury/ints/time.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/time.mh
lib/mercury/ints/time.mih
lib/mercury/ints/time.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/time.opt
lib/mercury/ints/time.trans_opt
lib/mercury/ints/tree234.int
lib/mercury/ints/tree234.int2
lib/mercury/ints/tree234.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/tree234.mh
lib/mercury/ints/tree234.mih
lib/mercury/ints/tree234.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/tree234.opt
lib/mercury/ints/tree234.trans_opt
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/ints/tree_bitset.int
lib/mercury/ints/tree_bitset.int2
lib/mercury/ints/tree_bitset.int3
lib/mercury/ints/tree_bitset.mh
lib/mercury/ints/tree_bitset.mih
lib/mercury/ints/tree_bitset.module_dep
lib/mercury/ints/tree_bitset.opt
lib/mercury/ints/tree_bitset.trans_opt
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/type_desc.int
lib/mercury/ints/type_desc.int2
lib/mercury/ints/type_desc.int3
lib/mercury/ints/type_desc.mh
lib/mercury/ints/type_desc.mih
lib/mercury/ints/type_desc.module_dep
lib/mercury/ints/type_desc.opt
lib/mercury/ints/type_desc.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/unit.int
lib/mercury/ints/unit.int2
lib/mercury/ints/unit.int3
lib/mercury/ints/unit.mh
lib/mercury/ints/unit.mih
lib/mercury/ints/unit.module_dep
lib/mercury/ints/unit.opt
lib/mercury/ints/unit.trans_opt
lib/mercury/ints/univ.int
lib/mercury/ints/univ.int2
lib/mercury/ints/univ.int3
lib/mercury/ints/univ.mh
lib/mercury/ints/univ.mih
lib/mercury/ints/univ.module_dep
lib/mercury/ints/univ.opt
lib/mercury/ints/univ.trans_opt
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/varset.int
lib/mercury/ints/varset.int2
lib/mercury/ints/varset.int3
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/ints/varset.mh
lib/mercury/ints/varset.mih
lib/mercury/ints/varset.module_dep
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/ints/varset.opt
lib/mercury/ints/varset.trans_opt
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/ints/version_array.int
lib/mercury/ints/version_array.int2
lib/mercury/ints/version_array.int3
lib/mercury/ints/version_array.mh
lib/mercury/ints/version_array.mih
lib/mercury/ints/version_array.module_dep
lib/mercury/ints/version_array.opt
lib/mercury/ints/version_array.trans_opt
lib/mercury/ints/version_array2d.int
lib/mercury/ints/version_array2d.int2
lib/mercury/ints/version_array2d.int3
lib/mercury/ints/version_array2d.mh
lib/mercury/ints/version_array2d.mih
lib/mercury/ints/version_array2d.module_dep
lib/mercury/ints/version_array2d.opt
lib/mercury/ints/version_array2d.trans_opt
lib/mercury/ints/version_bitmap.int
lib/mercury/ints/version_bitmap.int2
lib/mercury/ints/version_bitmap.int3
lib/mercury/ints/version_bitmap.mh
lib/mercury/ints/version_bitmap.mih
lib/mercury/ints/version_bitmap.module_dep
lib/mercury/ints/version_bitmap.opt
lib/mercury/ints/version_bitmap.trans_opt
lib/mercury/ints/version_hash_table.int
lib/mercury/ints/version_hash_table.int2
lib/mercury/ints/version_hash_table.int3
lib/mercury/ints/version_hash_table.mh
lib/mercury/ints/version_hash_table.mih
lib/mercury/ints/version_hash_table.module_dep
lib/mercury/ints/version_hash_table.opt
lib/mercury/ints/version_hash_table.trans_opt
lib/mercury/ints/version_store.int
lib/mercury/ints/version_store.int2
lib/mercury/ints/version_store.int3
lib/mercury/ints/version_store.mh
lib/mercury/ints/version_store.mih
lib/mercury/ints/version_store.module_dep
lib/mercury/ints/version_store.opt
lib/mercury/ints/version_store.trans_opt
Update to Mercury 14.01.1 NEWS for Mercury 14.01.1 ------------------------ This is a bug-fix release. * The function string.string/1 and related functions now handle version arrays properly. * Fix resource leaks in dir fold predicates. * The mfilterjavac program is now generated with the correct file extension on Windows. * A problem that caused compilation of the Boehm GC to fail on 64-bit openSUSE 13.1 systems has been fixed. (Github issue #14) * The documentation now builds correctly on Cygwin systems. * The script configure_mingw_cross now supports 64-bit Windows targets. * We have added workarounds for problems with (arguably broken) system headers on MinGW and MinGW64 systems. * The MinGW port now builds in the absence of POSIX threads library. * Low-level C parallel grades now work on Windows instead of crashing at startup. (Bug #338) * We now use thread-safe alternatives to strerror(). (Bug #340) * We have added the configure option --enable-gc-mmap. * We configure Boehm GC to use mmap in threaded grades on Linux to avoid conflicts with glibc malloc leading to memory corruption. * A problem that caused string.format/[23] to sometimes return incorrect results when formatting floats with the 'g' conversion specifier has been fixed. This bug only affected the non-C backends. (Bug #342) * string.format now handles special float values (i.e. nan, inf, and -inf) correctly with the non-C backends. * A bug that caused io.write_float/[34] to append ".0" to float special values has been fixed. This bug affected the C and C# backends. * In the C# and Java grades, the predicate string.from_char_list now implements the documented behaviour for input lists containing null characters (i.e. it throws an exception). Likewise, for string.from_reverse_char_list in the C# grade. * We have fixed a problem that caused `mmc --make' to attempt to install libraries in non-existent grades. Changes to the Mercury compiler: * The compiler now supports stripping of executables in a separate post-link step. The new options, --strip-executable-command, --strip-executable-shared-flags and --strip-executable-static-flags are used to control this. (This is now the default on Mac OS X systems.) NEWS for Mercury 14.01 ---------------------- Changes to the Mercury language: * Repeated type variables may now occur in the heads of type class instances. For example, instance declarations like the following are now allowed: :- instance foo(list(T), map(T, T)). Changes to the Mercury standard library: * We have added the function cord.condense/1. * The following functions in the standard library's cord module now use constant stack space: foldl/3, foldl_pred/4. * We have added the following predicates to the array and version_array modules: is_empty/1, all_true/2 and all_false/2. * We have added the following predicates and functions to the map module: det_min_key/1, det_max_key/1, foldl2_values/6 and foldl3_values/8. * We have added the following predicates to the list module: foldr2/6, foldr3/8, det_take/3 and map_foldr/5. * We have added the following predicates to the bag module: foldl/4 and foldl2/6. * We have added the following predicates to the assoc_list module: foldl2_values/6 and foldl3_values/8. * We have added the following predicates and functions to the pqueue module: is_empty/1, peek/3, peek_key/2, peek_value/2, det_peek/3, merge/3, det_peek_key/1 and det_peek_value/1. * We have added the predicate bimap.equal/2. * We have added the following predicates to the int module: fold_up3/9 and fold_down3/9. Changes to the Mercury compiler: * On Mac OS X systems the compiler is now configured use the version of the host system as the default value for the deployment target. A new configuration option, `--with-macosx-deployment-target', allows an alternative value to be selected at configuration time. Portability improvements: * We have made the implementation compatible with GCC 4.8 and Visual Studio 2013. * We have made the implementation compatible with OS X 10.9. Changes to the extras distribution: * We've added a library that provides support for accessing the function trail from Mercury code.
2015-01-04 20:37:02 +01:00
lib/mercury/lib/asm_fast.gc.debug.stseg/libmer_browser.a
lib/mercury/lib/asm_fast.gc.debug.stseg/libmer_browser.so
lib/mercury/lib/asm_fast.gc.debug.stseg/libmer_eventspec.a
lib/mercury/lib/asm_fast.gc.debug.stseg/libmer_eventspec.so
lib/mercury/lib/asm_fast.gc.debug.stseg/libmer_mdbcomp.a
lib/mercury/lib/asm_fast.gc.debug.stseg/libmer_mdbcomp.so
lib/mercury/lib/asm_fast.gc.debug.stseg/libmer_rt.a
lib/mercury/lib/asm_fast.gc.debug.stseg/libmer_rt.so
lib/mercury/lib/asm_fast.gc.debug.stseg/libmer_ssdb.a
lib/mercury/lib/asm_fast.gc.debug.stseg/libmer_ssdb.so
lib/mercury/lib/asm_fast.gc.debug.stseg/libmer_std.a
lib/mercury/lib/asm_fast.gc.debug.stseg/libmer_std.so
lib/mercury/lib/asm_fast.gc.debug.stseg/libmer_trace.a
lib/mercury/lib/asm_fast.gc.debug.stseg/libmer_trace.so
lib/mercury/lib/asm_fast.gc.decldebug.stseg/libmer_browser.a
lib/mercury/lib/asm_fast.gc.decldebug.stseg/libmer_browser.so
lib/mercury/lib/asm_fast.gc.decldebug.stseg/libmer_eventspec.a
lib/mercury/lib/asm_fast.gc.decldebug.stseg/libmer_eventspec.so
lib/mercury/lib/asm_fast.gc.decldebug.stseg/libmer_mdbcomp.a
lib/mercury/lib/asm_fast.gc.decldebug.stseg/libmer_mdbcomp.so
lib/mercury/lib/asm_fast.gc.decldebug.stseg/libmer_rt.a
lib/mercury/lib/asm_fast.gc.decldebug.stseg/libmer_rt.so
lib/mercury/lib/asm_fast.gc.decldebug.stseg/libmer_ssdb.a
lib/mercury/lib/asm_fast.gc.decldebug.stseg/libmer_ssdb.so
lib/mercury/lib/asm_fast.gc.decldebug.stseg/libmer_std.a
lib/mercury/lib/asm_fast.gc.decldebug.stseg/libmer_std.so
lib/mercury/lib/asm_fast.gc.decldebug.stseg/libmer_trace.a
lib/mercury/lib/asm_fast.gc.decldebug.stseg/libmer_trace.so
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/asm_fast.gc.memprof/libmer_browser.a
lib/mercury/lib/asm_fast.gc.memprof/libmer_browser.so
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/asm_fast.gc.memprof/libmer_eventspec.a
lib/mercury/lib/asm_fast.gc.memprof/libmer_eventspec.so
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/asm_fast.gc.memprof/libmer_mdbcomp.a
lib/mercury/lib/asm_fast.gc.memprof/libmer_mdbcomp.so
lib/mercury/lib/asm_fast.gc.memprof/libmer_rt.a
lib/mercury/lib/asm_fast.gc.memprof/libmer_rt.so
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/asm_fast.gc.memprof/libmer_ssdb.a
lib/mercury/lib/asm_fast.gc.memprof/libmer_ssdb.so
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/asm_fast.gc.memprof/libmer_std.a
lib/mercury/lib/asm_fast.gc.memprof/libmer_std.so
lib/mercury/lib/asm_fast.gc.memprof/libmer_trace.a
lib/mercury/lib/asm_fast.gc.memprof/libmer_trace.so
lib/mercury/lib/asm_fast.gc.prof/libmer_browser.a
lib/mercury/lib/asm_fast.gc.prof/libmer_browser.so
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/asm_fast.gc.prof/libmer_eventspec.a
lib/mercury/lib/asm_fast.gc.prof/libmer_eventspec.so
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/asm_fast.gc.prof/libmer_mdbcomp.a
lib/mercury/lib/asm_fast.gc.prof/libmer_mdbcomp.so
lib/mercury/lib/asm_fast.gc.prof/libmer_rt.a
lib/mercury/lib/asm_fast.gc.prof/libmer_rt.so
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/asm_fast.gc.prof/libmer_ssdb.a
lib/mercury/lib/asm_fast.gc.prof/libmer_ssdb.so
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/asm_fast.gc.prof/libmer_std.a
lib/mercury/lib/asm_fast.gc.prof/libmer_std.so
lib/mercury/lib/asm_fast.gc.prof/libmer_trace.a
lib/mercury/lib/asm_fast.gc.prof/libmer_trace.so
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/asm_fast.gc.profdeep/libmer_browser.a
lib/mercury/lib/asm_fast.gc.profdeep/libmer_browser.so
lib/mercury/lib/asm_fast.gc.profdeep/libmer_eventspec.a
lib/mercury/lib/asm_fast.gc.profdeep/libmer_eventspec.so
lib/mercury/lib/asm_fast.gc.profdeep/libmer_mdbcomp.a
lib/mercury/lib/asm_fast.gc.profdeep/libmer_mdbcomp.so
lib/mercury/lib/asm_fast.gc.profdeep/libmer_rt.a
lib/mercury/lib/asm_fast.gc.profdeep/libmer_rt.so
lib/mercury/lib/asm_fast.gc.profdeep/libmer_ssdb.a
lib/mercury/lib/asm_fast.gc.profdeep/libmer_ssdb.so
lib/mercury/lib/asm_fast.gc.profdeep/libmer_std.a
lib/mercury/lib/asm_fast.gc.profdeep/libmer_std.so
lib/mercury/lib/asm_fast.gc.profdeep/libmer_trace.a
lib/mercury/lib/asm_fast.gc.profdeep/libmer_trace.so
Update to Mercury 14.01.1 NEWS for Mercury 14.01.1 ------------------------ This is a bug-fix release. * The function string.string/1 and related functions now handle version arrays properly. * Fix resource leaks in dir fold predicates. * The mfilterjavac program is now generated with the correct file extension on Windows. * A problem that caused compilation of the Boehm GC to fail on 64-bit openSUSE 13.1 systems has been fixed. (Github issue #14) * The documentation now builds correctly on Cygwin systems. * The script configure_mingw_cross now supports 64-bit Windows targets. * We have added workarounds for problems with (arguably broken) system headers on MinGW and MinGW64 systems. * The MinGW port now builds in the absence of POSIX threads library. * Low-level C parallel grades now work on Windows instead of crashing at startup. (Bug #338) * We now use thread-safe alternatives to strerror(). (Bug #340) * We have added the configure option --enable-gc-mmap. * We configure Boehm GC to use mmap in threaded grades on Linux to avoid conflicts with glibc malloc leading to memory corruption. * A problem that caused string.format/[23] to sometimes return incorrect results when formatting floats with the 'g' conversion specifier has been fixed. This bug only affected the non-C backends. (Bug #342) * string.format now handles special float values (i.e. nan, inf, and -inf) correctly with the non-C backends. * A bug that caused io.write_float/[34] to append ".0" to float special values has been fixed. This bug affected the C and C# backends. * In the C# and Java grades, the predicate string.from_char_list now implements the documented behaviour for input lists containing null characters (i.e. it throws an exception). Likewise, for string.from_reverse_char_list in the C# grade. * We have fixed a problem that caused `mmc --make' to attempt to install libraries in non-existent grades. Changes to the Mercury compiler: * The compiler now supports stripping of executables in a separate post-link step. The new options, --strip-executable-command, --strip-executable-shared-flags and --strip-executable-static-flags are used to control this. (This is now the default on Mac OS X systems.) NEWS for Mercury 14.01 ---------------------- Changes to the Mercury language: * Repeated type variables may now occur in the heads of type class instances. For example, instance declarations like the following are now allowed: :- instance foo(list(T), map(T, T)). Changes to the Mercury standard library: * We have added the function cord.condense/1. * The following functions in the standard library's cord module now use constant stack space: foldl/3, foldl_pred/4. * We have added the following predicates to the array and version_array modules: is_empty/1, all_true/2 and all_false/2. * We have added the following predicates and functions to the map module: det_min_key/1, det_max_key/1, foldl2_values/6 and foldl3_values/8. * We have added the following predicates to the list module: foldr2/6, foldr3/8, det_take/3 and map_foldr/5. * We have added the following predicates to the bag module: foldl/4 and foldl2/6. * We have added the following predicates to the assoc_list module: foldl2_values/6 and foldl3_values/8. * We have added the following predicates and functions to the pqueue module: is_empty/1, peek/3, peek_key/2, peek_value/2, det_peek/3, merge/3, det_peek_key/1 and det_peek_value/1. * We have added the predicate bimap.equal/2. * We have added the following predicates to the int module: fold_up3/9 and fold_down3/9. Changes to the Mercury compiler: * On Mac OS X systems the compiler is now configured use the version of the host system as the default value for the deployment target. A new configuration option, `--with-macosx-deployment-target', allows an alternative value to be selected at configuration time. Portability improvements: * We have made the implementation compatible with GCC 4.8 and Visual Studio 2013. * We have made the implementation compatible with OS X 10.9. Changes to the extras distribution: * We've added a library that provides support for accessing the function trail from Mercury code.
2015-01-04 20:37:02 +01:00
lib/mercury/lib/asm_fast.gc.trseg.debug.stseg/libmer_browser.a
lib/mercury/lib/asm_fast.gc.trseg.debug.stseg/libmer_browser.so
lib/mercury/lib/asm_fast.gc.trseg.debug.stseg/libmer_eventspec.a
lib/mercury/lib/asm_fast.gc.trseg.debug.stseg/libmer_eventspec.so
lib/mercury/lib/asm_fast.gc.trseg.debug.stseg/libmer_mdbcomp.a
lib/mercury/lib/asm_fast.gc.trseg.debug.stseg/libmer_mdbcomp.so
lib/mercury/lib/asm_fast.gc.trseg.debug.stseg/libmer_rt.a
lib/mercury/lib/asm_fast.gc.trseg.debug.stseg/libmer_rt.so
lib/mercury/lib/asm_fast.gc.trseg.debug.stseg/libmer_ssdb.a
lib/mercury/lib/asm_fast.gc.trseg.debug.stseg/libmer_ssdb.so
lib/mercury/lib/asm_fast.gc.trseg.debug.stseg/libmer_std.a
lib/mercury/lib/asm_fast.gc.trseg.debug.stseg/libmer_std.so
lib/mercury/lib/asm_fast.gc.trseg.debug.stseg/libmer_trace.a
lib/mercury/lib/asm_fast.gc.trseg.debug.stseg/libmer_trace.so
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/asm_fast.gc.trseg/libmer_browser.a
lib/mercury/lib/asm_fast.gc.trseg/libmer_browser.so
lib/mercury/lib/asm_fast.gc.trseg/libmer_eventspec.a
lib/mercury/lib/asm_fast.gc.trseg/libmer_eventspec.so
lib/mercury/lib/asm_fast.gc.trseg/libmer_mdbcomp.a
lib/mercury/lib/asm_fast.gc.trseg/libmer_mdbcomp.so
lib/mercury/lib/asm_fast.gc.trseg/libmer_rt.a
lib/mercury/lib/asm_fast.gc.trseg/libmer_rt.so
lib/mercury/lib/asm_fast.gc.trseg/libmer_ssdb.a
lib/mercury/lib/asm_fast.gc.trseg/libmer_ssdb.so
lib/mercury/lib/asm_fast.gc.trseg/libmer_std.a
lib/mercury/lib/asm_fast.gc.trseg/libmer_std.so
lib/mercury/lib/asm_fast.gc.trseg/libmer_trace.a
lib/mercury/lib/asm_fast.gc.trseg/libmer_trace.so
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/asm_fast.gc/libmer_browser.a
lib/mercury/lib/asm_fast.gc/libmer_browser.so
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/asm_fast.gc/libmer_eventspec.a
lib/mercury/lib/asm_fast.gc/libmer_eventspec.so
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/asm_fast.gc/libmer_mdbcomp.a
lib/mercury/lib/asm_fast.gc/libmer_mdbcomp.so
lib/mercury/lib/asm_fast.gc/libmer_rt.a
lib/mercury/lib/asm_fast.gc/libmer_rt.so
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/asm_fast.gc/libmer_ssdb.a
lib/mercury/lib/asm_fast.gc/libmer_ssdb.so
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/asm_fast.gc/libmer_std.a
lib/mercury/lib/asm_fast.gc/libmer_std.so
lib/mercury/lib/asm_fast.gc/libmer_trace.a
lib/mercury/lib/asm_fast.gc/libmer_trace.so
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/lib/hlc.gc.pregen/inc/Mercury/mihs
lib/mercury/lib/hlc.gc.pregen/inc/array.mih
lib/mercury/lib/hlc.gc.pregen/inc/array2d.mih
lib/mercury/lib/hlc.gc.pregen/inc/assoc_list.mih
lib/mercury/lib/hlc.gc.pregen/inc/backjump.mih
lib/mercury/lib/hlc.gc.pregen/inc/bag.mih
lib/mercury/lib/hlc.gc.pregen/inc/benchmarking.mih
lib/mercury/lib/hlc.gc.pregen/inc/bimap.mih
lib/mercury/lib/hlc.gc.pregen/inc/bit_buffer.mih
lib/mercury/lib/hlc.gc.pregen/inc/bit_buffer.read.mih
lib/mercury/lib/hlc.gc.pregen/inc/bit_buffer.write.mih
lib/mercury/lib/hlc.gc.pregen/inc/bitmap.mih
lib/mercury/lib/hlc.gc.pregen/inc/bool.mih
lib/mercury/lib/hlc.gc.pregen/inc/bt_array.mih
lib/mercury/lib/hlc.gc.pregen/inc/builtin.mih
lib/mercury/lib/hlc.gc.pregen/inc/calendar.mih
lib/mercury/lib/hlc.gc.pregen/inc/char.mih
lib/mercury/lib/hlc.gc.pregen/inc/construct.mih
lib/mercury/lib/hlc.gc.pregen/inc/cord.mih
lib/mercury/lib/hlc.gc.pregen/inc/counter.mih
lib/mercury/lib/hlc.gc.pregen/inc/deconstruct.mih
lib/mercury/lib/hlc.gc.pregen/inc/digraph.mih
lib/mercury/lib/hlc.gc.pregen/inc/dir.mih
lib/mercury/lib/hlc.gc.pregen/inc/enum.mih
lib/mercury/lib/hlc.gc.pregen/inc/eqvclass.mih
lib/mercury/lib/hlc.gc.pregen/inc/erlang_builtin.mih
lib/mercury/lib/hlc.gc.pregen/inc/erlang_rtti_implementation.mih
lib/mercury/lib/hlc.gc.pregen/inc/exception.mih
lib/mercury/lib/hlc.gc.pregen/inc/fat_sparse_bitset.mih
lib/mercury/lib/hlc.gc.pregen/inc/float.mih
lib/mercury/lib/hlc.gc.pregen/inc/gc.mih
lib/mercury/lib/hlc.gc.pregen/inc/getopt.mih
lib/mercury/lib/hlc.gc.pregen/inc/getopt_io.mih
lib/mercury/lib/hlc.gc.pregen/inc/hash_table.mih
lib/mercury/lib/hlc.gc.pregen/inc/injection.mih
lib/mercury/lib/hlc.gc.pregen/inc/int.mih
lib/mercury/lib/hlc.gc.pregen/inc/integer.mih
lib/mercury/lib/hlc.gc.pregen/inc/io.mih
lib/mercury/lib/hlc.gc.pregen/inc/lazy.mih
lib/mercury/lib/hlc.gc.pregen/inc/lexer.mih
lib/mercury/lib/hlc.gc.pregen/inc/library.mih
lib/mercury/lib/hlc.gc.pregen/inc/list.mih
lib/mercury/lib/hlc.gc.pregen/inc/map.mih
lib/mercury/lib/hlc.gc.pregen/inc/math.mih
lib/mercury/lib/hlc.gc.pregen/inc/maybe.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.browse.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.browser_info.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.browser_term.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.collect_lib.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.cterm.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.debugger_interface.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.declarative_analyser.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.declarative_debugger.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.declarative_edt.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.declarative_execution.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.declarative_oracle.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.declarative_tree.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.declarative_user.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.diff.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.dl.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.frame.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.help.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.interactive_query.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.io_action.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.listing.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.name_mangle.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.parse.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.sized_pretty.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.term_rep.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdb.util.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdbcomp.feedback.automatic_parallelism.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdbcomp.feedback.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdbcomp.goal_path.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdbcomp.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdbcomp.prim_data.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdbcomp.program_representation.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdbcomp.rtti_access.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdbcomp.shared_utilities.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdbcomp.slice_and_dice.mih
lib/mercury/lib/hlc.gc.pregen/inc/mdbcomp.trace_counts.mih
lib/mercury/lib/hlc.gc.pregen/inc/mer_browser.mih
lib/mercury/lib/hlc.gc.pregen/inc/mer_mdbcomp.mih
lib/mercury/lib/hlc.gc.pregen/inc/mer_ssdb.mih
lib/mercury/lib/hlc.gc.pregen/inc/mer_std.mih
lib/mercury/lib/hlc.gc.pregen/inc/multi_map.mih
lib/mercury/lib/hlc.gc.pregen/inc/mutvar.mih
lib/mercury/lib/hlc.gc.pregen/inc/ops.mih
lib/mercury/lib/hlc.gc.pregen/inc/pair.mih
lib/mercury/lib/hlc.gc.pregen/inc/par_builtin.mih
lib/mercury/lib/hlc.gc.pregen/inc/parser.mih
lib/mercury/lib/hlc.gc.pregen/inc/parsing_utils.mih
lib/mercury/lib/hlc.gc.pregen/inc/pprint.mih
lib/mercury/lib/hlc.gc.pregen/inc/pqueue.mih
lib/mercury/lib/hlc.gc.pregen/inc/pretty_printer.mih
lib/mercury/lib/hlc.gc.pregen/inc/private_builtin.mih
lib/mercury/lib/hlc.gc.pregen/inc/profiling_builtin.mih
lib/mercury/lib/hlc.gc.pregen/inc/prolog.mih
lib/mercury/lib/hlc.gc.pregen/inc/queue.mih
lib/mercury/lib/hlc.gc.pregen/inc/random.mih
lib/mercury/lib/hlc.gc.pregen/inc/rational.mih
lib/mercury/lib/hlc.gc.pregen/inc/rbtree.mih
lib/mercury/lib/hlc.gc.pregen/inc/region_builtin.mih
lib/mercury/lib/hlc.gc.pregen/inc/require.mih
lib/mercury/lib/hlc.gc.pregen/inc/robdd.mih
lib/mercury/lib/hlc.gc.pregen/inc/rtree.mih
lib/mercury/lib/hlc.gc.pregen/inc/rtti_implementation.mih
lib/mercury/lib/hlc.gc.pregen/inc/set.mih
lib/mercury/lib/hlc.gc.pregen/inc/set_bbbtree.mih
lib/mercury/lib/hlc.gc.pregen/inc/set_ctree234.mih
lib/mercury/lib/hlc.gc.pregen/inc/set_ordlist.mih
lib/mercury/lib/hlc.gc.pregen/inc/set_tree234.mih
lib/mercury/lib/hlc.gc.pregen/inc/set_unordlist.mih
lib/mercury/lib/hlc.gc.pregen/inc/solutions.mih
lib/mercury/lib/hlc.gc.pregen/inc/sparse_bitset.mih
lib/mercury/lib/hlc.gc.pregen/inc/ssdb.mih
lib/mercury/lib/hlc.gc.pregen/inc/stack.mih
lib/mercury/lib/hlc.gc.pregen/inc/std_util.mih
lib/mercury/lib/hlc.gc.pregen/inc/stm_builtin.mih
lib/mercury/lib/hlc.gc.pregen/inc/store.mih
lib/mercury/lib/hlc.gc.pregen/inc/stream.mih
lib/mercury/lib/hlc.gc.pregen/inc/stream.string_writer.mih
lib/mercury/lib/hlc.gc.pregen/inc/string.builder.mih
lib/mercury/lib/hlc.gc.pregen/inc/string.mih
lib/mercury/lib/hlc.gc.pregen/inc/table_builtin.mih
lib/mercury/lib/hlc.gc.pregen/inc/table_statistics.mih
lib/mercury/lib/hlc.gc.pregen/inc/term.mih
lib/mercury/lib/hlc.gc.pregen/inc/term_io.mih
lib/mercury/lib/hlc.gc.pregen/inc/term_size_prof_builtin.mih
lib/mercury/lib/hlc.gc.pregen/inc/term_to_xml.mih
lib/mercury/lib/hlc.gc.pregen/inc/test_bitset.mih
lib/mercury/lib/hlc.gc.pregen/inc/thread.channel.mih
lib/mercury/lib/hlc.gc.pregen/inc/thread.mih
lib/mercury/lib/hlc.gc.pregen/inc/thread.mvar.mih
lib/mercury/lib/hlc.gc.pregen/inc/thread.semaphore.mih
lib/mercury/lib/hlc.gc.pregen/inc/time.mih
lib/mercury/lib/hlc.gc.pregen/inc/tree234.mih
lib/mercury/lib/hlc.gc.pregen/inc/tree_bitset.mih
lib/mercury/lib/hlc.gc.pregen/inc/type_desc.mih
lib/mercury/lib/hlc.gc.pregen/inc/unit.mih
lib/mercury/lib/hlc.gc.pregen/inc/univ.mih
lib/mercury/lib/hlc.gc.pregen/inc/varset.mih
lib/mercury/lib/hlc.gc.pregen/inc/version_array.mih
lib/mercury/lib/hlc.gc.pregen/inc/version_array2d.mih
lib/mercury/lib/hlc.gc.pregen/inc/version_bitmap.mih
lib/mercury/lib/hlc.gc.pregen/inc/version_hash_table.mih
lib/mercury/lib/hlc.gc.pregen/inc/version_store.mih
lib/mercury/lib/hlc.gc.pregen/libmer_browser.a
lib/mercury/lib/hlc.gc.pregen/libmer_browser.so
lib/mercury/lib/hlc.gc.pregen/libmer_eventspec.a
lib/mercury/lib/hlc.gc.pregen/libmer_eventspec.so
lib/mercury/lib/hlc.gc.pregen/libmer_mdbcomp.a
lib/mercury/lib/hlc.gc.pregen/libmer_mdbcomp.so
lib/mercury/lib/hlc.gc.pregen/libmer_rt.a
lib/mercury/lib/hlc.gc.pregen/libmer_rt.so
lib/mercury/lib/hlc.gc.pregen/libmer_ssdb.a
lib/mercury/lib/hlc.gc.pregen/libmer_ssdb.so
lib/mercury/lib/hlc.gc.pregen/libmer_std.a
lib/mercury/lib/hlc.gc.pregen/libmer_std.so
lib/mercury/lib/hlc.gc.pregen/libmer_trace.a
lib/mercury/lib/hlc.gc.pregen/libmer_trace.so
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc.trseg/inc/Mercury/mihs
lib/mercury/lib/hlc.gc.trseg/inc/array.mih
lib/mercury/lib/hlc.gc.trseg/inc/array2d.mih
lib/mercury/lib/hlc.gc.trseg/inc/assoc_list.mih
lib/mercury/lib/hlc.gc.trseg/inc/backjump.mih
lib/mercury/lib/hlc.gc.trseg/inc/bag.mih
lib/mercury/lib/hlc.gc.trseg/inc/benchmarking.mih
lib/mercury/lib/hlc.gc.trseg/inc/bimap.mih
lib/mercury/lib/hlc.gc.trseg/inc/bit_buffer.mih
lib/mercury/lib/hlc.gc.trseg/inc/bit_buffer.read.mih
lib/mercury/lib/hlc.gc.trseg/inc/bit_buffer.write.mih
lib/mercury/lib/hlc.gc.trseg/inc/bitmap.mih
lib/mercury/lib/hlc.gc.trseg/inc/bool.mih
lib/mercury/lib/hlc.gc.trseg/inc/bt_array.mih
lib/mercury/lib/hlc.gc.trseg/inc/builtin.mih
lib/mercury/lib/hlc.gc.trseg/inc/calendar.mih
lib/mercury/lib/hlc.gc.trseg/inc/char.mih
lib/mercury/lib/hlc.gc.trseg/inc/construct.mih
lib/mercury/lib/hlc.gc.trseg/inc/cord.mih
lib/mercury/lib/hlc.gc.trseg/inc/counter.mih
lib/mercury/lib/hlc.gc.trseg/inc/deconstruct.mih
lib/mercury/lib/hlc.gc.trseg/inc/digraph.mih
lib/mercury/lib/hlc.gc.trseg/inc/dir.mih
lib/mercury/lib/hlc.gc.trseg/inc/enum.mih
lib/mercury/lib/hlc.gc.trseg/inc/eqvclass.mih
lib/mercury/lib/hlc.gc.trseg/inc/erlang_builtin.mih
lib/mercury/lib/hlc.gc.trseg/inc/erlang_rtti_implementation.mih
lib/mercury/lib/hlc.gc.trseg/inc/exception.mih
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/lib/hlc.gc.trseg/inc/fat_sparse_bitset.mih
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc.trseg/inc/float.mih
lib/mercury/lib/hlc.gc.trseg/inc/gc.mih
lib/mercury/lib/hlc.gc.trseg/inc/getopt.mih
lib/mercury/lib/hlc.gc.trseg/inc/getopt_io.mih
lib/mercury/lib/hlc.gc.trseg/inc/hash_table.mih
lib/mercury/lib/hlc.gc.trseg/inc/injection.mih
lib/mercury/lib/hlc.gc.trseg/inc/int.mih
lib/mercury/lib/hlc.gc.trseg/inc/integer.mih
lib/mercury/lib/hlc.gc.trseg/inc/io.mih
lib/mercury/lib/hlc.gc.trseg/inc/lazy.mih
lib/mercury/lib/hlc.gc.trseg/inc/lexer.mih
lib/mercury/lib/hlc.gc.trseg/inc/library.mih
lib/mercury/lib/hlc.gc.trseg/inc/list.mih
lib/mercury/lib/hlc.gc.trseg/inc/map.mih
lib/mercury/lib/hlc.gc.trseg/inc/math.mih
lib/mercury/lib/hlc.gc.trseg/inc/maybe.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.browse.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.browser_info.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.browser_term.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.collect_lib.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.cterm.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.debugger_interface.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.declarative_analyser.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.declarative_debugger.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.declarative_edt.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.declarative_execution.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.declarative_oracle.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.declarative_tree.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.declarative_user.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.diff.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.dl.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.frame.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.help.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.interactive_query.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.io_action.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.listing.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.name_mangle.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.parse.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.sized_pretty.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.term_rep.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdb.util.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdbcomp.feedback.automatic_parallelism.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdbcomp.feedback.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdbcomp.goal_path.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdbcomp.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdbcomp.prim_data.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdbcomp.program_representation.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdbcomp.rtti_access.mih
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/lib/hlc.gc.trseg/inc/mdbcomp.shared_utilities.mih
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc.trseg/inc/mdbcomp.slice_and_dice.mih
lib/mercury/lib/hlc.gc.trseg/inc/mdbcomp.trace_counts.mih
lib/mercury/lib/hlc.gc.trseg/inc/mer_browser.mih
lib/mercury/lib/hlc.gc.trseg/inc/mer_mdbcomp.mih
lib/mercury/lib/hlc.gc.trseg/inc/mer_ssdb.mih
lib/mercury/lib/hlc.gc.trseg/inc/mer_std.mih
lib/mercury/lib/hlc.gc.trseg/inc/multi_map.mih
lib/mercury/lib/hlc.gc.trseg/inc/mutvar.mih
lib/mercury/lib/hlc.gc.trseg/inc/ops.mih
lib/mercury/lib/hlc.gc.trseg/inc/pair.mih
lib/mercury/lib/hlc.gc.trseg/inc/par_builtin.mih
lib/mercury/lib/hlc.gc.trseg/inc/parser.mih
lib/mercury/lib/hlc.gc.trseg/inc/parsing_utils.mih
lib/mercury/lib/hlc.gc.trseg/inc/pprint.mih
lib/mercury/lib/hlc.gc.trseg/inc/pqueue.mih
lib/mercury/lib/hlc.gc.trseg/inc/pretty_printer.mih
lib/mercury/lib/hlc.gc.trseg/inc/private_builtin.mih
lib/mercury/lib/hlc.gc.trseg/inc/profiling_builtin.mih
lib/mercury/lib/hlc.gc.trseg/inc/prolog.mih
lib/mercury/lib/hlc.gc.trseg/inc/queue.mih
lib/mercury/lib/hlc.gc.trseg/inc/random.mih
lib/mercury/lib/hlc.gc.trseg/inc/rational.mih
lib/mercury/lib/hlc.gc.trseg/inc/rbtree.mih
lib/mercury/lib/hlc.gc.trseg/inc/region_builtin.mih
lib/mercury/lib/hlc.gc.trseg/inc/require.mih
lib/mercury/lib/hlc.gc.trseg/inc/robdd.mih
lib/mercury/lib/hlc.gc.trseg/inc/rtree.mih
lib/mercury/lib/hlc.gc.trseg/inc/rtti_implementation.mih
lib/mercury/lib/hlc.gc.trseg/inc/set.mih
lib/mercury/lib/hlc.gc.trseg/inc/set_bbbtree.mih
lib/mercury/lib/hlc.gc.trseg/inc/set_ctree234.mih
lib/mercury/lib/hlc.gc.trseg/inc/set_ordlist.mih
lib/mercury/lib/hlc.gc.trseg/inc/set_tree234.mih
lib/mercury/lib/hlc.gc.trseg/inc/set_unordlist.mih
lib/mercury/lib/hlc.gc.trseg/inc/solutions.mih
lib/mercury/lib/hlc.gc.trseg/inc/sparse_bitset.mih
lib/mercury/lib/hlc.gc.trseg/inc/ssdb.mih
lib/mercury/lib/hlc.gc.trseg/inc/stack.mih
lib/mercury/lib/hlc.gc.trseg/inc/std_util.mih
lib/mercury/lib/hlc.gc.trseg/inc/stm_builtin.mih
lib/mercury/lib/hlc.gc.trseg/inc/store.mih
lib/mercury/lib/hlc.gc.trseg/inc/stream.mih
lib/mercury/lib/hlc.gc.trseg/inc/stream.string_writer.mih
lib/mercury/lib/hlc.gc.trseg/inc/string.builder.mih
lib/mercury/lib/hlc.gc.trseg/inc/string.mih
lib/mercury/lib/hlc.gc.trseg/inc/table_builtin.mih
lib/mercury/lib/hlc.gc.trseg/inc/table_statistics.mih
lib/mercury/lib/hlc.gc.trseg/inc/term.mih
lib/mercury/lib/hlc.gc.trseg/inc/term_io.mih
lib/mercury/lib/hlc.gc.trseg/inc/term_size_prof_builtin.mih
lib/mercury/lib/hlc.gc.trseg/inc/term_to_xml.mih
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/lib/hlc.gc.trseg/inc/test_bitset.mih
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc.trseg/inc/thread.channel.mih
lib/mercury/lib/hlc.gc.trseg/inc/thread.mih
lib/mercury/lib/hlc.gc.trseg/inc/thread.mvar.mih
lib/mercury/lib/hlc.gc.trseg/inc/thread.semaphore.mih
lib/mercury/lib/hlc.gc.trseg/inc/time.mih
lib/mercury/lib/hlc.gc.trseg/inc/tree234.mih
lib/mercury/lib/hlc.gc.trseg/inc/tree_bitset.mih
lib/mercury/lib/hlc.gc.trseg/inc/type_desc.mih
lib/mercury/lib/hlc.gc.trseg/inc/unit.mih
lib/mercury/lib/hlc.gc.trseg/inc/univ.mih
lib/mercury/lib/hlc.gc.trseg/inc/varset.mih
lib/mercury/lib/hlc.gc.trseg/inc/version_array.mih
lib/mercury/lib/hlc.gc.trseg/inc/version_array2d.mih
lib/mercury/lib/hlc.gc.trseg/inc/version_bitmap.mih
lib/mercury/lib/hlc.gc.trseg/inc/version_hash_table.mih
lib/mercury/lib/hlc.gc.trseg/inc/version_store.mih
lib/mercury/lib/hlc.gc.trseg/libmer_browser.a
lib/mercury/lib/hlc.gc.trseg/libmer_browser.so
lib/mercury/lib/hlc.gc.trseg/libmer_eventspec.a
lib/mercury/lib/hlc.gc.trseg/libmer_eventspec.so
lib/mercury/lib/hlc.gc.trseg/libmer_mdbcomp.a
lib/mercury/lib/hlc.gc.trseg/libmer_mdbcomp.so
lib/mercury/lib/hlc.gc.trseg/libmer_rt.a
lib/mercury/lib/hlc.gc.trseg/libmer_rt.so
lib/mercury/lib/hlc.gc.trseg/libmer_ssdb.a
lib/mercury/lib/hlc.gc.trseg/libmer_ssdb.so
lib/mercury/lib/hlc.gc.trseg/libmer_std.a
lib/mercury/lib/hlc.gc.trseg/libmer_std.so
lib/mercury/lib/hlc.gc.trseg/libmer_trace.a
lib/mercury/lib/hlc.gc.trseg/libmer_trace.so
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/hlc.gc/inc/Mercury/mihs
lib/mercury/lib/hlc.gc/inc/array.mih
lib/mercury/lib/hlc.gc/inc/array2d.mih
lib/mercury/lib/hlc.gc/inc/assoc_list.mih
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc/inc/backjump.mih
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/hlc.gc/inc/bag.mih
lib/mercury/lib/hlc.gc/inc/benchmarking.mih
lib/mercury/lib/hlc.gc/inc/bimap.mih
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc/inc/bit_buffer.mih
lib/mercury/lib/hlc.gc/inc/bit_buffer.read.mih
lib/mercury/lib/hlc.gc/inc/bit_buffer.write.mih
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/hlc.gc/inc/bitmap.mih
lib/mercury/lib/hlc.gc/inc/bool.mih
lib/mercury/lib/hlc.gc/inc/bt_array.mih
lib/mercury/lib/hlc.gc/inc/builtin.mih
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc/inc/calendar.mih
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/hlc.gc/inc/char.mih
lib/mercury/lib/hlc.gc/inc/construct.mih
lib/mercury/lib/hlc.gc/inc/cord.mih
lib/mercury/lib/hlc.gc/inc/counter.mih
lib/mercury/lib/hlc.gc/inc/deconstruct.mih
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc/inc/digraph.mih
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/hlc.gc/inc/dir.mih
lib/mercury/lib/hlc.gc/inc/enum.mih
lib/mercury/lib/hlc.gc/inc/eqvclass.mih
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc/inc/erlang_builtin.mih
lib/mercury/lib/hlc.gc/inc/erlang_rtti_implementation.mih
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/hlc.gc/inc/exception.mih
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/lib/hlc.gc/inc/fat_sparse_bitset.mih
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/hlc.gc/inc/float.mih
lib/mercury/lib/hlc.gc/inc/gc.mih
lib/mercury/lib/hlc.gc/inc/getopt.mih
lib/mercury/lib/hlc.gc/inc/getopt_io.mih
lib/mercury/lib/hlc.gc/inc/hash_table.mih
lib/mercury/lib/hlc.gc/inc/injection.mih
lib/mercury/lib/hlc.gc/inc/int.mih
lib/mercury/lib/hlc.gc/inc/integer.mih
lib/mercury/lib/hlc.gc/inc/io.mih
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc/inc/lazy.mih
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/hlc.gc/inc/lexer.mih
lib/mercury/lib/hlc.gc/inc/library.mih
lib/mercury/lib/hlc.gc/inc/list.mih
lib/mercury/lib/hlc.gc/inc/map.mih
lib/mercury/lib/hlc.gc/inc/math.mih
lib/mercury/lib/hlc.gc/inc/maybe.mih
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc/inc/mdb.browse.mih
lib/mercury/lib/hlc.gc/inc/mdb.browser_info.mih
lib/mercury/lib/hlc.gc/inc/mdb.browser_term.mih
lib/mercury/lib/hlc.gc/inc/mdb.collect_lib.mih
lib/mercury/lib/hlc.gc/inc/mdb.cterm.mih
lib/mercury/lib/hlc.gc/inc/mdb.debugger_interface.mih
lib/mercury/lib/hlc.gc/inc/mdb.declarative_analyser.mih
lib/mercury/lib/hlc.gc/inc/mdb.declarative_debugger.mih
lib/mercury/lib/hlc.gc/inc/mdb.declarative_edt.mih
lib/mercury/lib/hlc.gc/inc/mdb.declarative_execution.mih
lib/mercury/lib/hlc.gc/inc/mdb.declarative_oracle.mih
lib/mercury/lib/hlc.gc/inc/mdb.declarative_tree.mih
lib/mercury/lib/hlc.gc/inc/mdb.declarative_user.mih
lib/mercury/lib/hlc.gc/inc/mdb.diff.mih
lib/mercury/lib/hlc.gc/inc/mdb.dl.mih
lib/mercury/lib/hlc.gc/inc/mdb.frame.mih
lib/mercury/lib/hlc.gc/inc/mdb.help.mih
lib/mercury/lib/hlc.gc/inc/mdb.interactive_query.mih
lib/mercury/lib/hlc.gc/inc/mdb.io_action.mih
lib/mercury/lib/hlc.gc/inc/mdb.listing.mih
lib/mercury/lib/hlc.gc/inc/mdb.mih
lib/mercury/lib/hlc.gc/inc/mdb.name_mangle.mih
lib/mercury/lib/hlc.gc/inc/mdb.parse.mih
lib/mercury/lib/hlc.gc/inc/mdb.sized_pretty.mih
lib/mercury/lib/hlc.gc/inc/mdb.term_rep.mih
lib/mercury/lib/hlc.gc/inc/mdb.util.mih
lib/mercury/lib/hlc.gc/inc/mdbcomp.feedback.automatic_parallelism.mih
lib/mercury/lib/hlc.gc/inc/mdbcomp.feedback.mih
lib/mercury/lib/hlc.gc/inc/mdbcomp.goal_path.mih
lib/mercury/lib/hlc.gc/inc/mdbcomp.mih
lib/mercury/lib/hlc.gc/inc/mdbcomp.prim_data.mih
lib/mercury/lib/hlc.gc/inc/mdbcomp.program_representation.mih
lib/mercury/lib/hlc.gc/inc/mdbcomp.rtti_access.mih
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/lib/hlc.gc/inc/mdbcomp.shared_utilities.mih
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc/inc/mdbcomp.slice_and_dice.mih
lib/mercury/lib/hlc.gc/inc/mdbcomp.trace_counts.mih
lib/mercury/lib/hlc.gc/inc/mer_browser.mih
lib/mercury/lib/hlc.gc/inc/mer_mdbcomp.mih
lib/mercury/lib/hlc.gc/inc/mer_ssdb.mih
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/hlc.gc/inc/mer_std.mih
lib/mercury/lib/hlc.gc/inc/multi_map.mih
lib/mercury/lib/hlc.gc/inc/mutvar.mih
lib/mercury/lib/hlc.gc/inc/ops.mih
lib/mercury/lib/hlc.gc/inc/pair.mih
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc/inc/par_builtin.mih
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/hlc.gc/inc/parser.mih
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc/inc/parsing_utils.mih
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/hlc.gc/inc/pprint.mih
lib/mercury/lib/hlc.gc/inc/pqueue.mih
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc/inc/pretty_printer.mih
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/hlc.gc/inc/private_builtin.mih
lib/mercury/lib/hlc.gc/inc/profiling_builtin.mih
lib/mercury/lib/hlc.gc/inc/prolog.mih
lib/mercury/lib/hlc.gc/inc/queue.mih
lib/mercury/lib/hlc.gc/inc/random.mih
lib/mercury/lib/hlc.gc/inc/rational.mih
lib/mercury/lib/hlc.gc/inc/rbtree.mih
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc/inc/region_builtin.mih
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/hlc.gc/inc/require.mih
lib/mercury/lib/hlc.gc/inc/robdd.mih
lib/mercury/lib/hlc.gc/inc/rtree.mih
lib/mercury/lib/hlc.gc/inc/rtti_implementation.mih
lib/mercury/lib/hlc.gc/inc/set.mih
lib/mercury/lib/hlc.gc/inc/set_bbbtree.mih
lib/mercury/lib/hlc.gc/inc/set_ctree234.mih
lib/mercury/lib/hlc.gc/inc/set_ordlist.mih
lib/mercury/lib/hlc.gc/inc/set_tree234.mih
lib/mercury/lib/hlc.gc/inc/set_unordlist.mih
lib/mercury/lib/hlc.gc/inc/solutions.mih
lib/mercury/lib/hlc.gc/inc/sparse_bitset.mih
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc/inc/ssdb.mih
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/hlc.gc/inc/stack.mih
lib/mercury/lib/hlc.gc/inc/std_util.mih
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc/inc/stm_builtin.mih
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/hlc.gc/inc/store.mih
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc/inc/stream.mih
lib/mercury/lib/hlc.gc/inc/stream.string_writer.mih
lib/mercury/lib/hlc.gc/inc/string.builder.mih
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/hlc.gc/inc/string.mih
lib/mercury/lib/hlc.gc/inc/table_builtin.mih
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc/inc/table_statistics.mih
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/hlc.gc/inc/term.mih
lib/mercury/lib/hlc.gc/inc/term_io.mih
lib/mercury/lib/hlc.gc/inc/term_size_prof_builtin.mih
lib/mercury/lib/hlc.gc/inc/term_to_xml.mih
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/lib/hlc.gc/inc/test_bitset.mih
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc/inc/thread.channel.mih
lib/mercury/lib/hlc.gc/inc/thread.mih
lib/mercury/lib/hlc.gc/inc/thread.mvar.mih
lib/mercury/lib/hlc.gc/inc/thread.semaphore.mih
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/hlc.gc/inc/time.mih
lib/mercury/lib/hlc.gc/inc/tree234.mih
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc/inc/tree_bitset.mih
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/hlc.gc/inc/type_desc.mih
lib/mercury/lib/hlc.gc/inc/unit.mih
lib/mercury/lib/hlc.gc/inc/univ.mih
lib/mercury/lib/hlc.gc/inc/varset.mih
lib/mercury/lib/hlc.gc/inc/version_array.mih
lib/mercury/lib/hlc.gc/inc/version_array2d.mih
lib/mercury/lib/hlc.gc/inc/version_bitmap.mih
lib/mercury/lib/hlc.gc/inc/version_hash_table.mih
lib/mercury/lib/hlc.gc/inc/version_store.mih
lib/mercury/lib/hlc.gc/libmer_browser.a
lib/mercury/lib/hlc.gc/libmer_browser.so
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc/libmer_eventspec.a
lib/mercury/lib/hlc.gc/libmer_eventspec.so
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/hlc.gc/libmer_mdbcomp.a
lib/mercury/lib/hlc.gc/libmer_mdbcomp.so
lib/mercury/lib/hlc.gc/libmer_rt.a
lib/mercury/lib/hlc.gc/libmer_rt.so
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/lib/hlc.gc/libmer_ssdb.a
lib/mercury/lib/hlc.gc/libmer_ssdb.so
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/lib/hlc.gc/libmer_std.a
lib/mercury/lib/hlc.gc/libmer_std.so
lib/mercury/lib/hlc.gc/libmer_trace.a
lib/mercury/lib/hlc.gc/libmer_trace.so
lib/mercury/lib/libgc.a
lib/mercury/lib/libgc.so
lib/mercury/lib/libgc_prof.a
lib/mercury/lib/libgc_prof.so
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
lib/mercury/mdb/mdb_doc
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/mdb/mdb_grep
lib/mercury/mdb/mdb_open
lib/mercury/mdb/mdb_track
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/mdb/mdbrc
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/mdb/xul_tree.xsl
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
lib/mercury/mmake/Mmake.rules
lib/mercury/mmake/Mmake.vars
Update to Mercury 14.01.1 NEWS for Mercury 14.01.1 ------------------------ This is a bug-fix release. * The function string.string/1 and related functions now handle version arrays properly. * Fix resource leaks in dir fold predicates. * The mfilterjavac program is now generated with the correct file extension on Windows. * A problem that caused compilation of the Boehm GC to fail on 64-bit openSUSE 13.1 systems has been fixed. (Github issue #14) * The documentation now builds correctly on Cygwin systems. * The script configure_mingw_cross now supports 64-bit Windows targets. * We have added workarounds for problems with (arguably broken) system headers on MinGW and MinGW64 systems. * The MinGW port now builds in the absence of POSIX threads library. * Low-level C parallel grades now work on Windows instead of crashing at startup. (Bug #338) * We now use thread-safe alternatives to strerror(). (Bug #340) * We have added the configure option --enable-gc-mmap. * We configure Boehm GC to use mmap in threaded grades on Linux to avoid conflicts with glibc malloc leading to memory corruption. * A problem that caused string.format/[23] to sometimes return incorrect results when formatting floats with the 'g' conversion specifier has been fixed. This bug only affected the non-C backends. (Bug #342) * string.format now handles special float values (i.e. nan, inf, and -inf) correctly with the non-C backends. * A bug that caused io.write_float/[34] to append ".0" to float special values has been fixed. This bug affected the C and C# backends. * In the C# and Java grades, the predicate string.from_char_list now implements the documented behaviour for input lists containing null characters (i.e. it throws an exception). Likewise, for string.from_reverse_char_list in the C# grade. * We have fixed a problem that caused `mmc --make' to attempt to install libraries in non-existent grades. Changes to the Mercury compiler: * The compiler now supports stripping of executables in a separate post-link step. The new options, --strip-executable-command, --strip-executable-shared-flags and --strip-executable-static-flags are used to control this. (This is now the default on Mac OS X systems.) NEWS for Mercury 14.01 ---------------------- Changes to the Mercury language: * Repeated type variables may now occur in the heads of type class instances. For example, instance declarations like the following are now allowed: :- instance foo(list(T), map(T, T)). Changes to the Mercury standard library: * We have added the function cord.condense/1. * The following functions in the standard library's cord module now use constant stack space: foldl/3, foldl_pred/4. * We have added the following predicates to the array and version_array modules: is_empty/1, all_true/2 and all_false/2. * We have added the following predicates and functions to the map module: det_min_key/1, det_max_key/1, foldl2_values/6 and foldl3_values/8. * We have added the following predicates to the list module: foldr2/6, foldr3/8, det_take/3 and map_foldr/5. * We have added the following predicates to the bag module: foldl/4 and foldl2/6. * We have added the following predicates to the assoc_list module: foldl2_values/6 and foldl3_values/8. * We have added the following predicates and functions to the pqueue module: is_empty/1, peek/3, peek_key/2, peek_value/2, det_peek/3, merge/3, det_peek_key/1 and det_peek_value/1. * We have added the predicate bimap.equal/2. * We have added the following predicates to the int module: fold_up3/9 and fold_down3/9. Changes to the Mercury compiler: * On Mac OS X systems the compiler is now configured use the version of the host system as the default value for the deployment target. A new configuration option, `--with-macosx-deployment-target', allows an alternative value to be selected at configuration time. Portability improvements: * We have made the implementation compatible with GCC 4.8 and Visual Studio 2013. * We have made the implementation compatible with OS X 10.9. Changes to the extras distribution: * We've added a library that provides support for accessing the function trail from Mercury code.
2015-01-04 20:37:02 +01:00
lib/mercury/modules/asm_fast.gc.debug.stseg/mer_browser.init
lib/mercury/modules/asm_fast.gc.debug.stseg/mer_mdbcomp.init
lib/mercury/modules/asm_fast.gc.debug.stseg/mer_rt.init
lib/mercury/modules/asm_fast.gc.debug.stseg/mer_ssdb.init
lib/mercury/modules/asm_fast.gc.debug.stseg/mer_std.init
lib/mercury/modules/asm_fast.gc.decldebug.stseg/mer_browser.init
lib/mercury/modules/asm_fast.gc.decldebug.stseg/mer_mdbcomp.init
lib/mercury/modules/asm_fast.gc.decldebug.stseg/mer_rt.init
lib/mercury/modules/asm_fast.gc.decldebug.stseg/mer_ssdb.init
lib/mercury/modules/asm_fast.gc.decldebug.stseg/mer_std.init
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/modules/asm_fast.gc.memprof/mer_browser.init
lib/mercury/modules/asm_fast.gc.memprof/mer_mdbcomp.init
lib/mercury/modules/asm_fast.gc.memprof/mer_rt.init
lib/mercury/modules/asm_fast.gc.memprof/mer_ssdb.init
lib/mercury/modules/asm_fast.gc.memprof/mer_std.init
lib/mercury/modules/asm_fast.gc.prof/mer_browser.init
lib/mercury/modules/asm_fast.gc.prof/mer_mdbcomp.init
lib/mercury/modules/asm_fast.gc.prof/mer_rt.init
lib/mercury/modules/asm_fast.gc.prof/mer_ssdb.init
lib/mercury/modules/asm_fast.gc.prof/mer_std.init
lib/mercury/modules/asm_fast.gc.profdeep/mer_browser.init
lib/mercury/modules/asm_fast.gc.profdeep/mer_mdbcomp.init
lib/mercury/modules/asm_fast.gc.profdeep/mer_rt.init
lib/mercury/modules/asm_fast.gc.profdeep/mer_ssdb.init
lib/mercury/modules/asm_fast.gc.profdeep/mer_std.init
Update to Mercury 14.01.1 NEWS for Mercury 14.01.1 ------------------------ This is a bug-fix release. * The function string.string/1 and related functions now handle version arrays properly. * Fix resource leaks in dir fold predicates. * The mfilterjavac program is now generated with the correct file extension on Windows. * A problem that caused compilation of the Boehm GC to fail on 64-bit openSUSE 13.1 systems has been fixed. (Github issue #14) * The documentation now builds correctly on Cygwin systems. * The script configure_mingw_cross now supports 64-bit Windows targets. * We have added workarounds for problems with (arguably broken) system headers on MinGW and MinGW64 systems. * The MinGW port now builds in the absence of POSIX threads library. * Low-level C parallel grades now work on Windows instead of crashing at startup. (Bug #338) * We now use thread-safe alternatives to strerror(). (Bug #340) * We have added the configure option --enable-gc-mmap. * We configure Boehm GC to use mmap in threaded grades on Linux to avoid conflicts with glibc malloc leading to memory corruption. * A problem that caused string.format/[23] to sometimes return incorrect results when formatting floats with the 'g' conversion specifier has been fixed. This bug only affected the non-C backends. (Bug #342) * string.format now handles special float values (i.e. nan, inf, and -inf) correctly with the non-C backends. * A bug that caused io.write_float/[34] to append ".0" to float special values has been fixed. This bug affected the C and C# backends. * In the C# and Java grades, the predicate string.from_char_list now implements the documented behaviour for input lists containing null characters (i.e. it throws an exception). Likewise, for string.from_reverse_char_list in the C# grade. * We have fixed a problem that caused `mmc --make' to attempt to install libraries in non-existent grades. Changes to the Mercury compiler: * The compiler now supports stripping of executables in a separate post-link step. The new options, --strip-executable-command, --strip-executable-shared-flags and --strip-executable-static-flags are used to control this. (This is now the default on Mac OS X systems.) NEWS for Mercury 14.01 ---------------------- Changes to the Mercury language: * Repeated type variables may now occur in the heads of type class instances. For example, instance declarations like the following are now allowed: :- instance foo(list(T), map(T, T)). Changes to the Mercury standard library: * We have added the function cord.condense/1. * The following functions in the standard library's cord module now use constant stack space: foldl/3, foldl_pred/4. * We have added the following predicates to the array and version_array modules: is_empty/1, all_true/2 and all_false/2. * We have added the following predicates and functions to the map module: det_min_key/1, det_max_key/1, foldl2_values/6 and foldl3_values/8. * We have added the following predicates to the list module: foldr2/6, foldr3/8, det_take/3 and map_foldr/5. * We have added the following predicates to the bag module: foldl/4 and foldl2/6. * We have added the following predicates to the assoc_list module: foldl2_values/6 and foldl3_values/8. * We have added the following predicates and functions to the pqueue module: is_empty/1, peek/3, peek_key/2, peek_value/2, det_peek/3, merge/3, det_peek_key/1 and det_peek_value/1. * We have added the predicate bimap.equal/2. * We have added the following predicates to the int module: fold_up3/9 and fold_down3/9. Changes to the Mercury compiler: * On Mac OS X systems the compiler is now configured use the version of the host system as the default value for the deployment target. A new configuration option, `--with-macosx-deployment-target', allows an alternative value to be selected at configuration time. Portability improvements: * We have made the implementation compatible with GCC 4.8 and Visual Studio 2013. * We have made the implementation compatible with OS X 10.9. Changes to the extras distribution: * We've added a library that provides support for accessing the function trail from Mercury code.
2015-01-04 20:37:02 +01:00
lib/mercury/modules/asm_fast.gc.trseg.debug.stseg/mer_browser.init
lib/mercury/modules/asm_fast.gc.trseg.debug.stseg/mer_mdbcomp.init
lib/mercury/modules/asm_fast.gc.trseg.debug.stseg/mer_rt.init
lib/mercury/modules/asm_fast.gc.trseg.debug.stseg/mer_ssdb.init
lib/mercury/modules/asm_fast.gc.trseg.debug.stseg/mer_std.init
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/modules/asm_fast.gc.trseg/mer_browser.init
lib/mercury/modules/asm_fast.gc.trseg/mer_mdbcomp.init
lib/mercury/modules/asm_fast.gc.trseg/mer_rt.init
lib/mercury/modules/asm_fast.gc.trseg/mer_ssdb.init
lib/mercury/modules/asm_fast.gc.trseg/mer_std.init
lib/mercury/modules/asm_fast.gc/mer_browser.init
lib/mercury/modules/asm_fast.gc/mer_mdbcomp.init
lib/mercury/modules/asm_fast.gc/mer_rt.init
lib/mercury/modules/asm_fast.gc/mer_ssdb.init
lib/mercury/modules/asm_fast.gc/mer_std.init
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/modules/hlc.gc.pregen/mer_browser.init
lib/mercury/modules/hlc.gc.pregen/mer_mdbcomp.init
lib/mercury/modules/hlc.gc.pregen/mer_rt.init
lib/mercury/modules/hlc.gc.pregen/mer_ssdb.init
lib/mercury/modules/hlc.gc.pregen/mer_std.init
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/modules/hlc.gc.trseg/mer_browser.init
lib/mercury/modules/hlc.gc.trseg/mer_mdbcomp.init
lib/mercury/modules/hlc.gc.trseg/mer_rt.init
lib/mercury/modules/hlc.gc.trseg/mer_ssdb.init
lib/mercury/modules/hlc.gc.trseg/mer_std.init
lib/mercury/modules/hlc.gc/mer_browser.init
lib/mercury/modules/hlc.gc/mer_mdbcomp.init
lib/mercury/modules/hlc.gc/mer_rt.init
lib/mercury/modules/hlc.gc/mer_ssdb.init
lib/mercury/modules/hlc.gc/mer_std.init
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/reconf/VERSION
lib/mercury/reconf/aclocal.m4
lib/mercury/reconf/config.guess
lib/mercury/reconf/config.sub
lib/mercury/reconf/configure
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
lib/mercury/reconf/configure.ac
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/reconf/install-sh
lib/mercury/reconf/runtime/mercury_conf.h.in
lib/mercury/reconf/scripts/Mercury.config.bootstrap.in
lib/mercury/reconf/scripts/Mercury.config.in
lib/mercury/reconf/scripts/Mmake.vars.in
lib/mercury/reconf/scripts/c2init
lib/mercury/reconf/scripts/c2init.in
lib/mercury/reconf/scripts/canonical_grade
lib/mercury/reconf/scripts/canonical_grade.in
lib/mercury/reconf/scripts/canonical_grade.sh-subr
lib/mercury/reconf/scripts/final_grade_options.sh-subr
lib/mercury/reconf/scripts/init_grade_options.sh-subr
lib/mercury/reconf/scripts/mdb
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/reconf/scripts/mdb.bat
lib/mercury/reconf/scripts/mdb.bat.in
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/reconf/scripts/mdb.in
lib/mercury/reconf/scripts/mdbrc.in
lib/mercury/reconf/scripts/mdprof
lib/mercury/reconf/scripts/mdprof.in
lib/mercury/reconf/scripts/mercury.bat
lib/mercury/reconf/scripts/mercury.bat.in
lib/mercury/reconf/scripts/mercury_config
lib/mercury/reconf/scripts/mercury_config.in
lib/mercury/reconf/scripts/mercury_update_interface
lib/mercury/reconf/scripts/mercury_update_interface.in
lib/mercury/reconf/scripts/mgnuc
lib/mercury/reconf/scripts/mgnuc.in
lib/mercury/reconf/scripts/mgnuc_file_opts.sh-subr
lib/mercury/reconf/scripts/mkfifo_using_mknod
lib/mercury/reconf/scripts/mkfifo_using_mknod.in
lib/mercury/reconf/scripts/ml
lib/mercury/reconf/scripts/ml.in
lib/mercury/reconf/scripts/mmake
lib/mercury/reconf/scripts/mmake.in
lib/mercury/reconf/scripts/mmc
lib/mercury/reconf/scripts/mmc.in
lib/mercury/reconf/scripts/mprof
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/reconf/scripts/mprof.bat
lib/mercury/reconf/scripts/mprof.bat.in
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/reconf/scripts/mprof.in
lib/mercury/reconf/scripts/mprof_merge_runs
lib/mercury/reconf/scripts/mtags
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/reconf/scripts/mtags.in
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/reconf/scripts/mtc
lib/mercury/reconf/scripts/parse_grade_options.sh-subr
lib/mercury/reconf/scripts/parse_ml_options.sh-subr
lib/mercury/reconf/scripts/parse_ml_options.sh-subr.in
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
lib/mercury/reconf/scripts/prepare_install_dir
lib/mercury/reconf/scripts/prepare_install_dir.in
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
lib/mercury/reconf/scripts/vpath_find
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
man/man1/c2init.1
man/man1/mdb.1
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
man/man1/mercury_config.1
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
man/man1/mgnuc.1
man/man1/ml.1
man/man1/mmake.1
man/man1/mmc.1
man/man1/mprof.1
man/man1/mprof_merge_runs.1
man/man1/mtags.1
share/doc/mercury/faq.dvi
lang/mercury: move HTML documentation to share/doc/mercury/html
2018-02-18 06:30:55 +01:00
share/doc/mercury/html/mercury.html
share/doc/mercury/html/mercury_faq.html
share/doc/mercury/html/mercury_library.html
share/doc/mercury/html/mercury_ref.html
share/doc/mercury/html/mercury_trans_guide.html
share/doc/mercury/html/mercury_user_guide.html
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
share/doc/mercury/library.dvi
share/doc/mercury/reference_manual.dvi
share/doc/mercury/transition_guide.dvi
share/doc/mercury/user_guide.dvi
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
share/emacs/site-lisp/mercury/gud.el
Update to Mercury 14.01.1 NEWS for Mercury 14.01.1 ------------------------ This is a bug-fix release. * The function string.string/1 and related functions now handle version arrays properly. * Fix resource leaks in dir fold predicates. * The mfilterjavac program is now generated with the correct file extension on Windows. * A problem that caused compilation of the Boehm GC to fail on 64-bit openSUSE 13.1 systems has been fixed. (Github issue #14) * The documentation now builds correctly on Cygwin systems. * The script configure_mingw_cross now supports 64-bit Windows targets. * We have added workarounds for problems with (arguably broken) system headers on MinGW and MinGW64 systems. * The MinGW port now builds in the absence of POSIX threads library. * Low-level C parallel grades now work on Windows instead of crashing at startup. (Bug #338) * We now use thread-safe alternatives to strerror(). (Bug #340) * We have added the configure option --enable-gc-mmap. * We configure Boehm GC to use mmap in threaded grades on Linux to avoid conflicts with glibc malloc leading to memory corruption. * A problem that caused string.format/[23] to sometimes return incorrect results when formatting floats with the 'g' conversion specifier has been fixed. This bug only affected the non-C backends. (Bug #342) * string.format now handles special float values (i.e. nan, inf, and -inf) correctly with the non-C backends. * A bug that caused io.write_float/[34] to append ".0" to float special values has been fixed. This bug affected the C and C# backends. * In the C# and Java grades, the predicate string.from_char_list now implements the documented behaviour for input lists containing null characters (i.e. it throws an exception). Likewise, for string.from_reverse_char_list in the C# grade. * We have fixed a problem that caused `mmc --make' to attempt to install libraries in non-existent grades. Changes to the Mercury compiler: * The compiler now supports stripping of executables in a separate post-link step. The new options, --strip-executable-command, --strip-executable-shared-flags and --strip-executable-static-flags are used to control this. (This is now the default on Mac OS X systems.) NEWS for Mercury 14.01 ---------------------- Changes to the Mercury language: * Repeated type variables may now occur in the heads of type class instances. For example, instance declarations like the following are now allowed: :- instance foo(list(T), map(T, T)). Changes to the Mercury standard library: * We have added the function cord.condense/1. * The following functions in the standard library's cord module now use constant stack space: foldl/3, foldl_pred/4. * We have added the following predicates to the array and version_array modules: is_empty/1, all_true/2 and all_false/2. * We have added the following predicates and functions to the map module: det_min_key/1, det_max_key/1, foldl2_values/6 and foldl3_values/8. * We have added the following predicates to the list module: foldr2/6, foldr3/8, det_take/3 and map_foldr/5. * We have added the following predicates to the bag module: foldl/4 and foldl2/6. * We have added the following predicates to the assoc_list module: foldl2_values/6 and foldl3_values/8. * We have added the following predicates and functions to the pqueue module: is_empty/1, peek/3, peek_key/2, peek_value/2, det_peek/3, merge/3, det_peek_key/1 and det_peek_value/1. * We have added the predicate bimap.equal/2. * We have added the following predicates to the int module: fold_up3/9 and fold_down3/9. Changes to the Mercury compiler: * On Mac OS X systems the compiler is now configured use the version of the host system as the default value for the deployment target. A new configuration option, `--with-macosx-deployment-target', allows an alternative value to be selected at configuration time. Portability improvements: * We have made the implementation compatible with GCC 4.8 and Visual Studio 2013. * We have made the implementation compatible with OS X 10.9. Changes to the extras distribution: * We've added a library that provides support for accessing the function trail from Mercury code.
2015-01-04 20:37:02 +01:00
share/examples/mercury/.gitignore
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
share/examples/mercury/.nocopyright
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
share/examples/mercury/COPYING
share/examples/mercury/COPYING.LIB
share/examples/mercury/INSTALL
share/examples/mercury/INSTALL_CVS
share/examples/mercury/Mmake.common
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
share/examples/mercury/Mmakefile
share/examples/mercury/README
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
share/examples/mercury/appengine/Makefile
share/examples/mercury/appengine/README
share/examples/mercury/appengine/servlet.m
share/examples/mercury/appengine/war/WEB-INF/appengine-web.xml
share/examples/mercury/appengine/war/WEB-INF/web.xml
Update to Mercury 14.01.1 NEWS for Mercury 14.01.1 ------------------------ This is a bug-fix release. * The function string.string/1 and related functions now handle version arrays properly. * Fix resource leaks in dir fold predicates. * The mfilterjavac program is now generated with the correct file extension on Windows. * A problem that caused compilation of the Boehm GC to fail on 64-bit openSUSE 13.1 systems has been fixed. (Github issue #14) * The documentation now builds correctly on Cygwin systems. * The script configure_mingw_cross now supports 64-bit Windows targets. * We have added workarounds for problems with (arguably broken) system headers on MinGW and MinGW64 systems. * The MinGW port now builds in the absence of POSIX threads library. * Low-level C parallel grades now work on Windows instead of crashing at startup. (Bug #338) * We now use thread-safe alternatives to strerror(). (Bug #340) * We have added the configure option --enable-gc-mmap. * We configure Boehm GC to use mmap in threaded grades on Linux to avoid conflicts with glibc malloc leading to memory corruption. * A problem that caused string.format/[23] to sometimes return incorrect results when formatting floats with the 'g' conversion specifier has been fixed. This bug only affected the non-C backends. (Bug #342) * string.format now handles special float values (i.e. nan, inf, and -inf) correctly with the non-C backends. * A bug that caused io.write_float/[34] to append ".0" to float special values has been fixed. This bug affected the C and C# backends. * In the C# and Java grades, the predicate string.from_char_list now implements the documented behaviour for input lists containing null characters (i.e. it throws an exception). Likewise, for string.from_reverse_char_list in the C# grade. * We have fixed a problem that caused `mmc --make' to attempt to install libraries in non-existent grades. Changes to the Mercury compiler: * The compiler now supports stripping of executables in a separate post-link step. The new options, --strip-executable-command, --strip-executable-shared-flags and --strip-executable-static-flags are used to control this. (This is now the default on Mac OS X systems.) NEWS for Mercury 14.01 ---------------------- Changes to the Mercury language: * Repeated type variables may now occur in the heads of type class instances. For example, instance declarations like the following are now allowed: :- instance foo(list(T), map(T, T)). Changes to the Mercury standard library: * We have added the function cord.condense/1. * The following functions in the standard library's cord module now use constant stack space: foldl/3, foldl_pred/4. * We have added the following predicates to the array and version_array modules: is_empty/1, all_true/2 and all_false/2. * We have added the following predicates and functions to the map module: det_min_key/1, det_max_key/1, foldl2_values/6 and foldl3_values/8. * We have added the following predicates to the list module: foldr2/6, foldr3/8, det_take/3 and map_foldr/5. * We have added the following predicates to the bag module: foldl/4 and foldl2/6. * We have added the following predicates to the assoc_list module: foldl2_values/6 and foldl3_values/8. * We have added the following predicates and functions to the pqueue module: is_empty/1, peek/3, peek_key/2, peek_value/2, det_peek/3, merge/3, det_peek_key/1 and det_peek_value/1. * We have added the predicate bimap.equal/2. * We have added the following predicates to the int module: fold_up3/9 and fold_down3/9. Changes to the Mercury compiler: * On Mac OS X systems the compiler is now configured use the version of the host system as the default value for the deployment target. A new configuration option, `--with-macosx-deployment-target', allows an alternative value to be selected at configuration time. Portability improvements: * We have made the implementation compatible with GCC 4.8 and Visual Studio 2013. * We have made the implementation compatible with OS X 10.9. Changes to the extras distribution: * We've added a library that provides support for accessing the function trail from Mercury code.
2015-01-04 20:37:02 +01:00
share/examples/mercury/c_interface/.gitignore
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
share/examples/mercury/c_interface/README
share/examples/mercury/c_interface/c_calls_mercury/Mmakefile
share/examples/mercury/c_interface/c_calls_mercury/c_main.c
share/examples/mercury/c_interface/c_calls_mercury/c_main.h
share/examples/mercury/c_interface/c_calls_mercury/c_main_int.m
share/examples/mercury/c_interface/c_calls_mercury/mercury_lib.m
share/examples/mercury/c_interface/c_calls_mercury/mercury_main.m
share/examples/mercury/c_interface/cplusplus_calls_mercury/Mmakefile
share/examples/mercury/c_interface/cplusplus_calls_mercury/cpp_main.cc
share/examples/mercury/c_interface/cplusplus_calls_mercury/cpp_main.h
share/examples/mercury/c_interface/cplusplus_calls_mercury/cpp_main_int.m
share/examples/mercury/c_interface/cplusplus_calls_mercury/mercury_lib.m
share/examples/mercury/c_interface/cplusplus_calls_mercury/mercury_main.m
share/examples/mercury/c_interface/mercury_calls_c/Mmakefile
share/examples/mercury/c_interface/mercury_calls_c/c_main.c
share/examples/mercury/c_interface/mercury_calls_c/c_main.h
share/examples/mercury/c_interface/mercury_calls_c/c_main_int.m
share/examples/mercury/c_interface/mercury_calls_c/mercury_main.m
share/examples/mercury/c_interface/mercury_calls_cplusplus/Mmakefile
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
share/examples/mercury/c_interface/mercury_calls_cplusplus/cpp_main.cc
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
share/examples/mercury/c_interface/mercury_calls_cplusplus/cpp_main.h
share/examples/mercury/c_interface/mercury_calls_cplusplus/cpp_main_int.m
share/examples/mercury/c_interface/mercury_calls_cplusplus/mercury_main.m
share/examples/mercury/c_interface/mercury_calls_fortran/Mmakefile
share/examples/mercury/c_interface/mercury_calls_fortran/fortran_main.f
share/examples/mercury/c_interface/mercury_calls_fortran/fortran_main_int.m
share/examples/mercury/c_interface/mercury_calls_fortran/mercury_main.m
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
share/examples/mercury/c_interface/short_example.m
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
share/examples/mercury/c_interface/simpler_c_calls_mercury/Mmakefile
share/examples/mercury/c_interface/simpler_c_calls_mercury/README
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
share/examples/mercury/c_interface/simpler_c_calls_mercury/c_main.m
share/examples/mercury/c_interface/simpler_c_calls_mercury/main.c
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
share/examples/mercury/c_interface/simpler_c_calls_mercury/mercury_lib.m
share/examples/mercury/c_interface/simpler_cplusplus_calls_mercury/Mmakefile
share/examples/mercury/c_interface/simpler_cplusplus_calls_mercury/README
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
share/examples/mercury/c_interface/simpler_cplusplus_calls_mercury/cpp_main.m
share/examples/mercury/c_interface/simpler_cplusplus_calls_mercury/main.cc
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
share/examples/mercury/c_interface/simpler_cplusplus_calls_mercury/mercury_lib.m
Update to Mercury 14.01.1 NEWS for Mercury 14.01.1 ------------------------ This is a bug-fix release. * The function string.string/1 and related functions now handle version arrays properly. * Fix resource leaks in dir fold predicates. * The mfilterjavac program is now generated with the correct file extension on Windows. * A problem that caused compilation of the Boehm GC to fail on 64-bit openSUSE 13.1 systems has been fixed. (Github issue #14) * The documentation now builds correctly on Cygwin systems. * The script configure_mingw_cross now supports 64-bit Windows targets. * We have added workarounds for problems with (arguably broken) system headers on MinGW and MinGW64 systems. * The MinGW port now builds in the absence of POSIX threads library. * Low-level C parallel grades now work on Windows instead of crashing at startup. (Bug #338) * We now use thread-safe alternatives to strerror(). (Bug #340) * We have added the configure option --enable-gc-mmap. * We configure Boehm GC to use mmap in threaded grades on Linux to avoid conflicts with glibc malloc leading to memory corruption. * A problem that caused string.format/[23] to sometimes return incorrect results when formatting floats with the 'g' conversion specifier has been fixed. This bug only affected the non-C backends. (Bug #342) * string.format now handles special float values (i.e. nan, inf, and -inf) correctly with the non-C backends. * A bug that caused io.write_float/[34] to append ".0" to float special values has been fixed. This bug affected the C and C# backends. * In the C# and Java grades, the predicate string.from_char_list now implements the documented behaviour for input lists containing null characters (i.e. it throws an exception). Likewise, for string.from_reverse_char_list in the C# grade. * We have fixed a problem that caused `mmc --make' to attempt to install libraries in non-existent grades. Changes to the Mercury compiler: * The compiler now supports stripping of executables in a separate post-link step. The new options, --strip-executable-command, --strip-executable-shared-flags and --strip-executable-static-flags are used to control this. (This is now the default on Mac OS X systems.) NEWS for Mercury 14.01 ---------------------- Changes to the Mercury language: * Repeated type variables may now occur in the heads of type class instances. For example, instance declarations like the following are now allowed: :- instance foo(list(T), map(T, T)). Changes to the Mercury standard library: * We have added the function cord.condense/1. * The following functions in the standard library's cord module now use constant stack space: foldl/3, foldl_pred/4. * We have added the following predicates to the array and version_array modules: is_empty/1, all_true/2 and all_false/2. * We have added the following predicates and functions to the map module: det_min_key/1, det_max_key/1, foldl2_values/6 and foldl3_values/8. * We have added the following predicates to the list module: foldr2/6, foldr3/8, det_take/3 and map_foldr/5. * We have added the following predicates to the bag module: foldl/4 and foldl2/6. * We have added the following predicates to the assoc_list module: foldl2_values/6 and foldl3_values/8. * We have added the following predicates and functions to the pqueue module: is_empty/1, peek/3, peek_key/2, peek_value/2, det_peek/3, merge/3, det_peek_key/1 and det_peek_value/1. * We have added the predicate bimap.equal/2. * We have added the following predicates to the int module: fold_up3/9 and fold_down3/9. Changes to the Mercury compiler: * On Mac OS X systems the compiler is now configured use the version of the host system as the default value for the deployment target. A new configuration option, `--with-macosx-deployment-target', allows an alternative value to be selected at configuration time. Portability improvements: * We have made the implementation compatible with GCC 4.8 and Visual Studio 2013. * We have made the implementation compatible with OS X 10.9. Changes to the extras distribution: * We've added a library that provides support for accessing the function trail from Mercury code.
2015-01-04 20:37:02 +01:00
share/examples/mercury/c_interface/standalone_c/.gitignore
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
share/examples/mercury/c_interface/standalone_c/.nocopyright
share/examples/mercury/c_interface/standalone_c/Makefile
share/examples/mercury/c_interface/standalone_c/c_main.c
share/examples/mercury/c_interface/standalone_c/c_main.exp
share/examples/mercury/c_interface/standalone_c/mercury_lib.m
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
share/examples/mercury/calculator.m
share/examples/mercury/calculator2.m
share/examples/mercury/cat.m
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
share/examples/mercury/concurrency/dining_philosophers/.nocopyright
share/examples/mercury/concurrency/dining_philosophers/README
share/examples/mercury/concurrency/dining_philosophers/philo.m
share/examples/mercury/concurrency/dining_philosophers/philo2.m
share/examples/mercury/concurrency/dining_philosophers/philo3.m
share/examples/mercury/concurrency/midimon/README
share/examples/mercury/concurrency/midimon/concurrent_stream.m
share/examples/mercury/concurrency/midimon/midi.m
share/examples/mercury/concurrency/midimon/midi_data
share/examples/mercury/concurrency/midimon/midimon.m
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
share/examples/mercury/diff/Mmakefile
share/examples/mercury/diff/README
share/examples/mercury/diff/TODO
share/examples/mercury/diff/diff.m
share/examples/mercury/diff/diff_out.m
share/examples/mercury/diff/difftype.m
share/examples/mercury/diff/file.m
share/examples/mercury/diff/filter.m
share/examples/mercury/diff/globals.m
share/examples/mercury/diff/match.m
share/examples/mercury/diff/myers.m
share/examples/mercury/diff/options.m
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
share/examples/mercury/e.m
share/examples/mercury/eliza.m
share/examples/mercury/expand_terms.m
share/examples/mercury/hello.m
share/examples/mercury/interpreter.m
Update to Mercury 14.01.1 NEWS for Mercury 14.01.1 ------------------------ This is a bug-fix release. * The function string.string/1 and related functions now handle version arrays properly. * Fix resource leaks in dir fold predicates. * The mfilterjavac program is now generated with the correct file extension on Windows. * A problem that caused compilation of the Boehm GC to fail on 64-bit openSUSE 13.1 systems has been fixed. (Github issue #14) * The documentation now builds correctly on Cygwin systems. * The script configure_mingw_cross now supports 64-bit Windows targets. * We have added workarounds for problems with (arguably broken) system headers on MinGW and MinGW64 systems. * The MinGW port now builds in the absence of POSIX threads library. * Low-level C parallel grades now work on Windows instead of crashing at startup. (Bug #338) * We now use thread-safe alternatives to strerror(). (Bug #340) * We have added the configure option --enable-gc-mmap. * We configure Boehm GC to use mmap in threaded grades on Linux to avoid conflicts with glibc malloc leading to memory corruption. * A problem that caused string.format/[23] to sometimes return incorrect results when formatting floats with the 'g' conversion specifier has been fixed. This bug only affected the non-C backends. (Bug #342) * string.format now handles special float values (i.e. nan, inf, and -inf) correctly with the non-C backends. * A bug that caused io.write_float/[34] to append ".0" to float special values has been fixed. This bug affected the C and C# backends. * In the C# and Java grades, the predicate string.from_char_list now implements the documented behaviour for input lists containing null characters (i.e. it throws an exception). Likewise, for string.from_reverse_char_list in the C# grade. * We have fixed a problem that caused `mmc --make' to attempt to install libraries in non-existent grades. Changes to the Mercury compiler: * The compiler now supports stripping of executables in a separate post-link step. The new options, --strip-executable-command, --strip-executable-shared-flags and --strip-executable-static-flags are used to control this. (This is now the default on Mac OS X systems.) NEWS for Mercury 14.01 ---------------------- Changes to the Mercury language: * Repeated type variables may now occur in the heads of type class instances. For example, instance declarations like the following are now allowed: :- instance foo(list(T), map(T, T)). Changes to the Mercury standard library: * We have added the function cord.condense/1. * The following functions in the standard library's cord module now use constant stack space: foldl/3, foldl_pred/4. * We have added the following predicates to the array and version_array modules: is_empty/1, all_true/2 and all_false/2. * We have added the following predicates and functions to the map module: det_min_key/1, det_max_key/1, foldl2_values/6 and foldl3_values/8. * We have added the following predicates to the list module: foldr2/6, foldr3/8, det_take/3 and map_foldr/5. * We have added the following predicates to the bag module: foldl/4 and foldl2/6. * We have added the following predicates to the assoc_list module: foldl2_values/6 and foldl3_values/8. * We have added the following predicates and functions to the pqueue module: is_empty/1, peek/3, peek_key/2, peek_value/2, det_peek/3, merge/3, det_peek_key/1 and det_peek_value/1. * We have added the predicate bimap.equal/2. * We have added the following predicates to the int module: fold_up3/9 and fold_down3/9. Changes to the Mercury compiler: * On Mac OS X systems the compiler is now configured use the version of the host system as the default value for the deployment target. A new configuration option, `--with-macosx-deployment-target', allows an alternative value to be selected at configuration time. Portability improvements: * We have made the implementation compatible with GCC 4.8 and Visual Studio 2013. * We have made the implementation compatible with OS X 10.9. Changes to the extras distribution: * We've added a library that provides support for accessing the function trail from Mercury code.
2015-01-04 20:37:02 +01:00
share/examples/mercury/java_interface/.gitignore
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
share/examples/mercury/java_interface/.nocopyright
share/examples/mercury/java_interface/README
share/examples/mercury/java_interface/java_calls_mercury/JavaMain.java
share/examples/mercury/java_interface/java_calls_mercury/Makefile
share/examples/mercury/java_interface/java_calls_mercury/java_main_int.m
share/examples/mercury/java_interface/java_calls_mercury/mercury_lib.m
share/examples/mercury/java_interface/java_calls_mercury/mercury_main.m
share/examples/mercury/java_interface/mercury_calls_java/JavaMain.java
share/examples/mercury/java_interface/mercury_calls_java/Makefile
share/examples/mercury/java_interface/mercury_calls_java/java_main_int.m
share/examples/mercury/java_interface/mercury_calls_java/mercury_main.m
Update to Mercury 14.01.1 NEWS for Mercury 14.01.1 ------------------------ This is a bug-fix release. * The function string.string/1 and related functions now handle version arrays properly. * Fix resource leaks in dir fold predicates. * The mfilterjavac program is now generated with the correct file extension on Windows. * A problem that caused compilation of the Boehm GC to fail on 64-bit openSUSE 13.1 systems has been fixed. (Github issue #14) * The documentation now builds correctly on Cygwin systems. * The script configure_mingw_cross now supports 64-bit Windows targets. * We have added workarounds for problems with (arguably broken) system headers on MinGW and MinGW64 systems. * The MinGW port now builds in the absence of POSIX threads library. * Low-level C parallel grades now work on Windows instead of crashing at startup. (Bug #338) * We now use thread-safe alternatives to strerror(). (Bug #340) * We have added the configure option --enable-gc-mmap. * We configure Boehm GC to use mmap in threaded grades on Linux to avoid conflicts with glibc malloc leading to memory corruption. * A problem that caused string.format/[23] to sometimes return incorrect results when formatting floats with the 'g' conversion specifier has been fixed. This bug only affected the non-C backends. (Bug #342) * string.format now handles special float values (i.e. nan, inf, and -inf) correctly with the non-C backends. * A bug that caused io.write_float/[34] to append ".0" to float special values has been fixed. This bug affected the C and C# backends. * In the C# and Java grades, the predicate string.from_char_list now implements the documented behaviour for input lists containing null characters (i.e. it throws an exception). Likewise, for string.from_reverse_char_list in the C# grade. * We have fixed a problem that caused `mmc --make' to attempt to install libraries in non-existent grades. Changes to the Mercury compiler: * The compiler now supports stripping of executables in a separate post-link step. The new options, --strip-executable-command, --strip-executable-shared-flags and --strip-executable-static-flags are used to control this. (This is now the default on Mac OS X systems.) NEWS for Mercury 14.01 ---------------------- Changes to the Mercury language: * Repeated type variables may now occur in the heads of type class instances. For example, instance declarations like the following are now allowed: :- instance foo(list(T), map(T, T)). Changes to the Mercury standard library: * We have added the function cord.condense/1. * The following functions in the standard library's cord module now use constant stack space: foldl/3, foldl_pred/4. * We have added the following predicates to the array and version_array modules: is_empty/1, all_true/2 and all_false/2. * We have added the following predicates and functions to the map module: det_min_key/1, det_max_key/1, foldl2_values/6 and foldl3_values/8. * We have added the following predicates to the list module: foldr2/6, foldr3/8, det_take/3 and map_foldr/5. * We have added the following predicates to the bag module: foldl/4 and foldl2/6. * We have added the following predicates to the assoc_list module: foldl2_values/6 and foldl3_values/8. * We have added the following predicates and functions to the pqueue module: is_empty/1, peek/3, peek_key/2, peek_value/2, det_peek/3, merge/3, det_peek_key/1 and det_peek_value/1. * We have added the predicate bimap.equal/2. * We have added the following predicates to the int module: fold_up3/9 and fold_down3/9. Changes to the Mercury compiler: * On Mac OS X systems the compiler is now configured use the version of the host system as the default value for the deployment target. A new configuration option, `--with-macosx-deployment-target', allows an alternative value to be selected at configuration time. Portability improvements: * We have made the implementation compatible with GCC 4.8 and Visual Studio 2013. * We have made the implementation compatible with OS X 10.9. Changes to the extras distribution: * We've added a library that provides support for accessing the function trail from Mercury code.
2015-01-04 20:37:02 +01:00
share/examples/mercury/lazy_list/.gitignore
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
share/examples/mercury/lazy_list/.nocopyright
share/examples/mercury/lazy_list/README
share/examples/mercury/lazy_list/lazy_list.m
share/examples/mercury/lazy_list/lazy_list_test.m
Update to Mercury 14.01.1 NEWS for Mercury 14.01.1 ------------------------ This is a bug-fix release. * The function string.string/1 and related functions now handle version arrays properly. * Fix resource leaks in dir fold predicates. * The mfilterjavac program is now generated with the correct file extension on Windows. * A problem that caused compilation of the Boehm GC to fail on 64-bit openSUSE 13.1 systems has been fixed. (Github issue #14) * The documentation now builds correctly on Cygwin systems. * The script configure_mingw_cross now supports 64-bit Windows targets. * We have added workarounds for problems with (arguably broken) system headers on MinGW and MinGW64 systems. * The MinGW port now builds in the absence of POSIX threads library. * Low-level C parallel grades now work on Windows instead of crashing at startup. (Bug #338) * We now use thread-safe alternatives to strerror(). (Bug #340) * We have added the configure option --enable-gc-mmap. * We configure Boehm GC to use mmap in threaded grades on Linux to avoid conflicts with glibc malloc leading to memory corruption. * A problem that caused string.format/[23] to sometimes return incorrect results when formatting floats with the 'g' conversion specifier has been fixed. This bug only affected the non-C backends. (Bug #342) * string.format now handles special float values (i.e. nan, inf, and -inf) correctly with the non-C backends. * A bug that caused io.write_float/[34] to append ".0" to float special values has been fixed. This bug affected the C and C# backends. * In the C# and Java grades, the predicate string.from_char_list now implements the documented behaviour for input lists containing null characters (i.e. it throws an exception). Likewise, for string.from_reverse_char_list in the C# grade. * We have fixed a problem that caused `mmc --make' to attempt to install libraries in non-existent grades. Changes to the Mercury compiler: * The compiler now supports stripping of executables in a separate post-link step. The new options, --strip-executable-command, --strip-executable-shared-flags and --strip-executable-static-flags are used to control this. (This is now the default on Mac OS X systems.) NEWS for Mercury 14.01 ---------------------- Changes to the Mercury language: * Repeated type variables may now occur in the heads of type class instances. For example, instance declarations like the following are now allowed: :- instance foo(list(T), map(T, T)). Changes to the Mercury standard library: * We have added the function cord.condense/1. * The following functions in the standard library's cord module now use constant stack space: foldl/3, foldl_pred/4. * We have added the following predicates to the array and version_array modules: is_empty/1, all_true/2 and all_false/2. * We have added the following predicates and functions to the map module: det_min_key/1, det_max_key/1, foldl2_values/6 and foldl3_values/8. * We have added the following predicates to the list module: foldr2/6, foldr3/8, det_take/3 and map_foldr/5. * We have added the following predicates to the bag module: foldl/4 and foldl2/6. * We have added the following predicates to the assoc_list module: foldl2_values/6 and foldl3_values/8. * We have added the following predicates and functions to the pqueue module: is_empty/1, peek/3, peek_key/2, peek_value/2, det_peek/3, merge/3, det_peek_key/1 and det_peek_value/1. * We have added the predicate bimap.equal/2. * We have added the following predicates to the int module: fold_up3/9 and fold_down3/9. Changes to the Mercury compiler: * On Mac OS X systems the compiler is now configured use the version of the host system as the default value for the deployment target. A new configuration option, `--with-macosx-deployment-target', allows an alternative value to be selected at configuration time. Portability improvements: * We have made the implementation compatible with GCC 4.8 and Visual Studio 2013. * We have made the implementation compatible with OS X 10.9. Changes to the extras distribution: * We've added a library that provides support for accessing the function trail from Mercury code.
2015-01-04 20:37:02 +01:00
share/examples/mercury/muz/.gitignore
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
share/examples/mercury/muz/.nocopyright
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
share/examples/mercury/muz/Mmakefile
share/examples/mercury/muz/README
share/examples/mercury/muz/dict.m
share/examples/mercury/muz/example.tex
share/examples/mercury/muz/example1.tex
share/examples/mercury/muz/higher_order.m
share/examples/mercury/muz/muz.m
share/examples/mercury/muz/muz_zed_syntax.txt
share/examples/mercury/muz/toolkit.tex
share/examples/mercury/muz/typecheck.m
share/examples/mercury/muz/word.m
share/examples/mercury/muz/zabstract.m
share/examples/mercury/muz/zed-csp.sty
share/examples/mercury/muz/zlogic.m
share/examples/mercury/muz/zparser.m
share/examples/mercury/muz/ztoken.m
share/examples/mercury/muz/ztoken_io.m
share/examples/mercury/muz/ztype.m
share/examples/mercury/muz/ztype_op.m
Update to Mercury 14.01.1 NEWS for Mercury 14.01.1 ------------------------ This is a bug-fix release. * The function string.string/1 and related functions now handle version arrays properly. * Fix resource leaks in dir fold predicates. * The mfilterjavac program is now generated with the correct file extension on Windows. * A problem that caused compilation of the Boehm GC to fail on 64-bit openSUSE 13.1 systems has been fixed. (Github issue #14) * The documentation now builds correctly on Cygwin systems. * The script configure_mingw_cross now supports 64-bit Windows targets. * We have added workarounds for problems with (arguably broken) system headers on MinGW and MinGW64 systems. * The MinGW port now builds in the absence of POSIX threads library. * Low-level C parallel grades now work on Windows instead of crashing at startup. (Bug #338) * We now use thread-safe alternatives to strerror(). (Bug #340) * We have added the configure option --enable-gc-mmap. * We configure Boehm GC to use mmap in threaded grades on Linux to avoid conflicts with glibc malloc leading to memory corruption. * A problem that caused string.format/[23] to sometimes return incorrect results when formatting floats with the 'g' conversion specifier has been fixed. This bug only affected the non-C backends. (Bug #342) * string.format now handles special float values (i.e. nan, inf, and -inf) correctly with the non-C backends. * A bug that caused io.write_float/[34] to append ".0" to float special values has been fixed. This bug affected the C and C# backends. * In the C# and Java grades, the predicate string.from_char_list now implements the documented behaviour for input lists containing null characters (i.e. it throws an exception). Likewise, for string.from_reverse_char_list in the C# grade. * We have fixed a problem that caused `mmc --make' to attempt to install libraries in non-existent grades. Changes to the Mercury compiler: * The compiler now supports stripping of executables in a separate post-link step. The new options, --strip-executable-command, --strip-executable-shared-flags and --strip-executable-static-flags are used to control this. (This is now the default on Mac OS X systems.) NEWS for Mercury 14.01 ---------------------- Changes to the Mercury language: * Repeated type variables may now occur in the heads of type class instances. For example, instance declarations like the following are now allowed: :- instance foo(list(T), map(T, T)). Changes to the Mercury standard library: * We have added the function cord.condense/1. * The following functions in the standard library's cord module now use constant stack space: foldl/3, foldl_pred/4. * We have added the following predicates to the array and version_array modules: is_empty/1, all_true/2 and all_false/2. * We have added the following predicates and functions to the map module: det_min_key/1, det_max_key/1, foldl2_values/6 and foldl3_values/8. * We have added the following predicates to the list module: foldr2/6, foldr3/8, det_take/3 and map_foldr/5. * We have added the following predicates to the bag module: foldl/4 and foldl2/6. * We have added the following predicates to the assoc_list module: foldl2_values/6 and foldl3_values/8. * We have added the following predicates and functions to the pqueue module: is_empty/1, peek/3, peek_key/2, peek_value/2, det_peek/3, merge/3, det_peek_key/1 and det_peek_value/1. * We have added the predicate bimap.equal/2. * We have added the following predicates to the int module: fold_up3/9 and fold_down3/9. Changes to the Mercury compiler: * On Mac OS X systems the compiler is now configured use the version of the host system as the default value for the deployment target. A new configuration option, `--with-macosx-deployment-target', allows an alternative value to be selected at configuration time. Portability improvements: * We have made the implementation compatible with GCC 4.8 and Visual Studio 2013. * We have made the implementation compatible with OS X 10.9. Changes to the extras distribution: * We've added a library that provides support for accessing the function trail from Mercury code.
2015-01-04 20:37:02 +01:00
share/examples/mercury/rot13/.gitignore
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
share/examples/mercury/rot13/Mmakefile
share/examples/mercury/rot13/README
share/examples/mercury/rot13/rot13_concise.m
share/examples/mercury/rot13/rot13_gustavo.m
share/examples/mercury/rot13/rot13_juergen.m
share/examples/mercury/rot13/rot13_ralph.m
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
share/examples/mercury/rot13/rot13_verbose.m
Update to Mercury 14.01.1 NEWS for Mercury 14.01.1 ------------------------ This is a bug-fix release. * The function string.string/1 and related functions now handle version arrays properly. * Fix resource leaks in dir fold predicates. * The mfilterjavac program is now generated with the correct file extension on Windows. * A problem that caused compilation of the Boehm GC to fail on 64-bit openSUSE 13.1 systems has been fixed. (Github issue #14) * The documentation now builds correctly on Cygwin systems. * The script configure_mingw_cross now supports 64-bit Windows targets. * We have added workarounds for problems with (arguably broken) system headers on MinGW and MinGW64 systems. * The MinGW port now builds in the absence of POSIX threads library. * Low-level C parallel grades now work on Windows instead of crashing at startup. (Bug #338) * We now use thread-safe alternatives to strerror(). (Bug #340) * We have added the configure option --enable-gc-mmap. * We configure Boehm GC to use mmap in threaded grades on Linux to avoid conflicts with glibc malloc leading to memory corruption. * A problem that caused string.format/[23] to sometimes return incorrect results when formatting floats with the 'g' conversion specifier has been fixed. This bug only affected the non-C backends. (Bug #342) * string.format now handles special float values (i.e. nan, inf, and -inf) correctly with the non-C backends. * A bug that caused io.write_float/[34] to append ".0" to float special values has been fixed. This bug affected the C and C# backends. * In the C# and Java grades, the predicate string.from_char_list now implements the documented behaviour for input lists containing null characters (i.e. it throws an exception). Likewise, for string.from_reverse_char_list in the C# grade. * We have fixed a problem that caused `mmc --make' to attempt to install libraries in non-existent grades. Changes to the Mercury compiler: * The compiler now supports stripping of executables in a separate post-link step. The new options, --strip-executable-command, --strip-executable-shared-flags and --strip-executable-static-flags are used to control this. (This is now the default on Mac OS X systems.) NEWS for Mercury 14.01 ---------------------- Changes to the Mercury language: * Repeated type variables may now occur in the heads of type class instances. For example, instance declarations like the following are now allowed: :- instance foo(list(T), map(T, T)). Changes to the Mercury standard library: * We have added the function cord.condense/1. * The following functions in the standard library's cord module now use constant stack space: foldl/3, foldl_pred/4. * We have added the following predicates to the array and version_array modules: is_empty/1, all_true/2 and all_false/2. * We have added the following predicates and functions to the map module: det_min_key/1, det_max_key/1, foldl2_values/6 and foldl3_values/8. * We have added the following predicates to the list module: foldr2/6, foldr3/8, det_take/3 and map_foldr/5. * We have added the following predicates to the bag module: foldl/4 and foldl2/6. * We have added the following predicates to the assoc_list module: foldl2_values/6 and foldl3_values/8. * We have added the following predicates and functions to the pqueue module: is_empty/1, peek/3, peek_key/2, peek_value/2, det_peek/3, merge/3, det_peek_key/1 and det_peek_value/1. * We have added the predicate bimap.equal/2. * We have added the following predicates to the int module: fold_up3/9 and fold_down3/9. Changes to the Mercury compiler: * On Mac OS X systems the compiler is now configured use the version of the host system as the default value for the deployment target. A new configuration option, `--with-macosx-deployment-target', allows an alternative value to be selected at configuration time. Portability improvements: * We have made the implementation compatible with GCC 4.8 and Visual Studio 2013. * We have made the implementation compatible with OS X 10.9. Changes to the extras distribution: * We've added a library that provides support for accessing the function trail from Mercury code.
2015-01-04 20:37:02 +01:00
share/examples/mercury/solutions/.gitignore
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
share/examples/mercury/solutions/all_solutions.m
Update to Mercury 0.13.1 The list of changes is too long, it includes 5 years of development. See NEWS and HISTORY files for details.
2010-07-20 14:29:20 +02:00
share/examples/mercury/solutions/n_solutions.m
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
share/examples/mercury/solutions/one_solution.m
share/examples/mercury/solutions/some_solutions.m
Update to Mercury 14.01.1 NEWS for Mercury 14.01.1 ------------------------ This is a bug-fix release. * The function string.string/1 and related functions now handle version arrays properly. * Fix resource leaks in dir fold predicates. * The mfilterjavac program is now generated with the correct file extension on Windows. * A problem that caused compilation of the Boehm GC to fail on 64-bit openSUSE 13.1 systems has been fixed. (Github issue #14) * The documentation now builds correctly on Cygwin systems. * The script configure_mingw_cross now supports 64-bit Windows targets. * We have added workarounds for problems with (arguably broken) system headers on MinGW and MinGW64 systems. * The MinGW port now builds in the absence of POSIX threads library. * Low-level C parallel grades now work on Windows instead of crashing at startup. (Bug #338) * We now use thread-safe alternatives to strerror(). (Bug #340) * We have added the configure option --enable-gc-mmap. * We configure Boehm GC to use mmap in threaded grades on Linux to avoid conflicts with glibc malloc leading to memory corruption. * A problem that caused string.format/[23] to sometimes return incorrect results when formatting floats with the 'g' conversion specifier has been fixed. This bug only affected the non-C backends. (Bug #342) * string.format now handles special float values (i.e. nan, inf, and -inf) correctly with the non-C backends. * A bug that caused io.write_float/[34] to append ".0" to float special values has been fixed. This bug affected the C and C# backends. * In the C# and Java grades, the predicate string.from_char_list now implements the documented behaviour for input lists containing null characters (i.e. it throws an exception). Likewise, for string.from_reverse_char_list in the C# grade. * We have fixed a problem that caused `mmc --make' to attempt to install libraries in non-existent grades. Changes to the Mercury compiler: * The compiler now supports stripping of executables in a separate post-link step. The new options, --strip-executable-command, --strip-executable-shared-flags and --strip-executable-static-flags are used to control this. (This is now the default on Mac OS X systems.) NEWS for Mercury 14.01 ---------------------- Changes to the Mercury language: * Repeated type variables may now occur in the heads of type class instances. For example, instance declarations like the following are now allowed: :- instance foo(list(T), map(T, T)). Changes to the Mercury standard library: * We have added the function cord.condense/1. * The following functions in the standard library's cord module now use constant stack space: foldl/3, foldl_pred/4. * We have added the following predicates to the array and version_array modules: is_empty/1, all_true/2 and all_false/2. * We have added the following predicates and functions to the map module: det_min_key/1, det_max_key/1, foldl2_values/6 and foldl3_values/8. * We have added the following predicates to the list module: foldr2/6, foldr3/8, det_take/3 and map_foldr/5. * We have added the following predicates to the bag module: foldl/4 and foldl2/6. * We have added the following predicates to the assoc_list module: foldl2_values/6 and foldl3_values/8. * We have added the following predicates and functions to the pqueue module: is_empty/1, peek/3, peek_key/2, peek_value/2, det_peek/3, merge/3, det_peek_key/1 and det_peek_value/1. * We have added the predicate bimap.equal/2. * We have added the following predicates to the int module: fold_up3/9 and fold_down3/9. Changes to the Mercury compiler: * On Mac OS X systems the compiler is now configured use the version of the host system as the default value for the deployment target. A new configuration option, `--with-macosx-deployment-target', allows an alternative value to be selected at configuration time. Portability improvements: * We have made the implementation compatible with GCC 4.8 and Visual Studio 2013. * We have made the implementation compatible with OS X 10.9. Changes to the extras distribution: * We've added a library that provides support for accessing the function trail from Mercury code.
2015-01-04 20:37:02 +01:00
share/examples/mercury/solver_types/.gitignore
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
share/examples/mercury/solver_types/.nocopyright
share/examples/mercury/solver_types/Makefile
Update to Mercury 13.05.1 Beta NEWS for Mercury 13.05.1 ------------------------ Changes to the Mercury standard library: * We have added the function bimap.count/1. NEWS for Mercury 13.05 ---------------------- Changes to the Mercury standard library: * We have swapped the argument order of the predicates set.singleton_set/2, set_bbbtree.singleton_set/2, set_ordlist.singleton_set/2 and set_unordlist.singleton_set/2 so that it conforms with the order in the other set modules. * All the modules that operate on sets now have two new predicates. One is insert_new: if the item is not already in the set, it inserts the item, otherwise it fails. The other is all_true: it succeeds if and only if all elements in the set pass a test. * The map and varset modules each have a new predicate that deletes a sorted list of items from a map or varset, and can do so faster than usual by exploiting the order. * The map, bimap and tree234 modules each have a new predicate that does a search, and if the search is unsuccessful, does an insertion during the *same* traversal. * The argument order of the following predicates has been changed so as to make them more conducive to the use of state variable notation: pqueue.insert/4, pqueue.remove/4, stack.push/3, stack.push_list/3, stack.pop/3 and stack.det_pop/3. * We have added versions of the operations in the math module that omit the domain checks. * We have added new predicates to the parsing_utils module: input_string/3, get_skip_whitespace_pred/2 and next_char_no_progress/4. * The lexer module returns base 10 integer literals in the string representation, if the integer is too large for an `int'. * We have add the following new predicates to the list module: list.all_true_corresponding/3, list.all_false_corresponding/3 and list.same_length3/3. * We have added the type maybe.maybe_error/2 which is polymorphic in the error type. * We have added predicates to the calendar module for folding over the days in a given range of dates: foldl_days/5, foldl2_days/7 and foldl3_days/9. * We have added two functions to both the hash_table and version_hash_table modules: copy/1 and from_assoc_list/4. Changes to the Mercury compiler: * Generation of 64-bit code on Windows using the MinGW64 port of GCC is now supported, i.e. the x86_64-w64-mingw32 architecture is now supported. * We have improved compilation times for very large programs. In particular, compilation times for predicates containing the following have been improved: - large ground terms - large disjunctions - large numbers of higher order constructs and/or code that uses large hierarchies of type classes * We have implemented a type representation optimisation, where a functor with exactly one argument can be represented by a tagged pointer to the argument value, which itself does not require the tag bits. * In C grades, consecutive enumeration arguments in discriminated union types can now be packed into a single word. * Double-precision `float' constructor arguments are now stored in unboxed form in high-level C grades. * Double-precision `float' constructor arguments are now stored in unboxed form on 32-bit architectures in the low-level C grades. This was previously so for 64-bit architectures. * Double-precision float arguments can now be passed via dedicated Mercury abstract machine registers to avoid boxing, in low-level C grades on 32-bit architectures. Float variables can occupy two words on the Mercury stack to avoid boxing. * The option `--warn-non-tail-recursion' no longer requires `--high-level-code'. * A new option, `--sign-assembly', provides supports for signing assemblies generated by the C# backend with a strong name. * A new option, `--cstack-reserve-size', allows the size of the C stack for executables to be changed on Microsoft Windows systems. Changes to the Mercury debugger: * We have added new capabilities to the "level", "retry" and "finish" mdb commands. If these commands are given the argument "clentry", they will operate on the ancestor of the current call that represents entry to the clique of mutually recursive procedures that the current call belongs to. If they are given the argument "clparent", they will operate on the parent of that call. * The mdb command "stack" can now find and mark cliques of mutually recursive calls on the stack, and can (and by default, will) impose a limit on the number of lines it prints for each clique. Changes to the extras distribution: * We have added a binding to the GLFW library. NEWS for Mercury 11.07.2, 3 August 2012 --------------------------------------- This is a bug-fix release: it fixes the following: * The name of the C# compiler in newer versions of Mono is now recognised. * The configure script now distinguishes between the MS C# compiler and the Chicken Scheme compiler. * Thread local storage now works on Mac OS X when using clang as the C compiler. * Various build issues on Solaris 10 have been resolved. * The --erlang option now sets all the relevant grade components correctly. * The binary input and output streams are now set to binary translation mode when using the MSVC CRT. * The standard library's lexer module now correctly tokenizes binary, octal and hexadecimal integer literals. * Some bugs in the UTF-8 routines used by the C grades have been fixed. Also, the performance of these routines has been improved. * The exit status is now correctly set when --warn-non-tail-recursion is being used. Changes to the Mercury standard library: * We have added additional modes to map.foldr/4, map.foldr/6 and the list.foldl<N>_corresponding3 predicates. * The predicates parsing_utils.float_literal/3 and parsing_utils.float_literal_as_string/4 now accept an optional plus sign in the exponent. * The obsolete predicates string.remove_suffix_det/2 and string.index_det/2 have been removed. * The predicate time.times/4 is now implemented for the csharp grade. * The version_hash_table module is now supported in the csharp and java grades. * The unsafe versions of the predicates in the array2d module are now more efficient. Changes to the Mercury compiler: * The compiler now outputs #line directives in C# code it generates. NEWS for Mercury 11.07.1, 2 March 2012 -------------------------------------- This is a bug-fix release. It fixes a problem that was preventing the standard library from building in the csharp grade on Cygwin and also adds support for using GCC in C99 (or GNU99) mode with Mercury. In addition, there are a number of minor changes to the standard library. Changes to the Mercury standard library: * We have added the predicate map.keys_and_values/3. * We have added the predicates set.is_singleton/2, set_bbbtree.is_singleton/2, set_ctree234.is_singleton/2 and set_unordlist.is_singleton/2. * We have added the function list.foldl_corresponding/4.
2013-06-11 21:34:14 +02:00
share/examples/mercury/solver_types/Mercury.options
Update to Mercury 11.07 There're lots of changes since version 0.13.1 including changes to the language, the standard library, addition of new grades and new backends, bug fixes. Read lengthy details in NEWS file in distributed source.
2012-01-30 06:40:02 +01:00
share/examples/mercury/solver_types/README
share/examples/mercury/solver_types/eqneq.m
share/examples/mercury/solver_types/sudoku.m
share/examples/mercury/solver_types/sudoku_puzzle.easy
share/examples/mercury/solver_types/sudoku_puzzle.hard
share/examples/mercury/solver_types/test_eqneq.m
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
share/examples/mercury/sort.m
share/examples/mercury/tests/Mmake.common
share/examples/mercury/tests/Mmake.common.samples
share/examples/mercury/tests/Mmakefile
share/examples/mercury/tests/c_interface/Mmake.thisdir
share/examples/mercury/tests/c_interface/Mmakefile
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
share/examples/mercury/tests/c_interface/c_calls_mercury/Mmake.thisdir
share/examples/mercury/tests/c_interface/c_calls_mercury/Mmakefile
share/examples/mercury/tests/c_interface/c_calls_mercury/mercury_main.exp
share/examples/mercury/tests/c_interface/c_calls_mercury/runtests
share/examples/mercury/tests/c_interface/cplusplus_calls_mercury/Mmake.thisdir
share/examples/mercury/tests/c_interface/cplusplus_calls_mercury/Mmakefile
share/examples/mercury/tests/c_interface/cplusplus_calls_mercury/mercury_main.exp
share/examples/mercury/tests/c_interface/cplusplus_calls_mercury/runtests
share/examples/mercury/tests/c_interface/mercury_calls_c/Mmake.thisdir
share/examples/mercury/tests/c_interface/mercury_calls_c/Mmakefile
share/examples/mercury/tests/c_interface/mercury_calls_c/mercury_main.exp
share/examples/mercury/tests/c_interface/mercury_calls_c/runtests
share/examples/mercury/tests/c_interface/mercury_calls_cplusplus/Mmake.thisdir
share/examples/mercury/tests/c_interface/mercury_calls_cplusplus/Mmakefile
share/examples/mercury/tests/c_interface/mercury_calls_cplusplus/mercury_main.exp
share/examples/mercury/tests/c_interface/mercury_calls_cplusplus/runtests
share/examples/mercury/tests/c_interface/mercury_calls_fortran/Mmake.thisdir
share/examples/mercury/tests/c_interface/mercury_calls_fortran/Mmakefile
share/examples/mercury/tests/c_interface/mercury_calls_fortran/mercury_main.exp
share/examples/mercury/tests/c_interface/mercury_calls_fortran/runtests
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
share/examples/mercury/tests/c_interface/runtests
share/examples/mercury/tests/c_interface/short_example.exp
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
share/examples/mercury/tests/c_interface/simpler_c_calls_mercury/Mmake.thisdir
share/examples/mercury/tests/c_interface/simpler_c_calls_mercury/Mmakefile
share/examples/mercury/tests/c_interface/simpler_c_calls_mercury/c_main.exp
share/examples/mercury/tests/c_interface/simpler_c_calls_mercury/runtests
share/examples/mercury/tests/c_interface/simpler_cplusplus_calls_mercury/Mmake.thisdir
share/examples/mercury/tests/c_interface/simpler_cplusplus_calls_mercury/Mmakefile
share/examples/mercury/tests/c_interface/simpler_cplusplus_calls_mercury/cpp_main.exp
share/examples/mercury/tests/c_interface/simpler_cplusplus_calls_mercury/runtests
share/examples/mercury/tests/diff/Mmake.thisdir
share/examples/mercury/tests/diff/Mmakefile
share/examples/mercury/tests/diff/diff.arg
share/examples/mercury/tests/diff/diff.exp
share/examples/mercury/tests/diff/diff.test.1
share/examples/mercury/tests/diff/diff.test.2
share/examples/mercury/tests/diff/runtests
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
share/examples/mercury/tests/handle_options
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
share/examples/mercury/tests/muz/Mmake.thisdir
share/examples/mercury/tests/muz/Mmakefile
share/examples/mercury/tests/muz/muz.arg
share/examples/mercury/tests/muz/muz.exp
share/examples/mercury/tests/muz/runtests
share/examples/mercury/tests/rot13/Mmake.thisdir
share/examples/mercury/tests/rot13/Mmakefile
share/examples/mercury/tests/rot13/rot13_concise.exp
share/examples/mercury/tests/rot13/rot13_concise.inp
share/examples/mercury/tests/rot13/rot13_gustavo.exp
share/examples/mercury/tests/rot13/rot13_gustavo.inp
share/examples/mercury/tests/rot13/rot13_juergen.exp
share/examples/mercury/tests/rot13/rot13_juergen.inp
share/examples/mercury/tests/rot13/rot13_verbose.exp
share/examples/mercury/tests/rot13/rot13_verbose.inp
share/examples/mercury/tests/rot13/runtests
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
share/examples/mercury/tests/runtests
share/examples/mercury/tests/shutdown
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
share/examples/mercury/tests/solutions/Mmake.thisdir
share/examples/mercury/tests/solutions/Mmakefile
share/examples/mercury/tests/solutions/all_solutions.exp
share/examples/mercury/tests/solutions/one_solution.exp
share/examples/mercury/tests/solutions/runtests
share/examples/mercury/tests/solutions/some_solutions.exp
share/examples/mercury/tests/solutions/some_solutions.inp
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
share/examples/mercury/tests/startup
share/examples/mercury/tests/subdir_runtests
Initial import of mercury-0.10.1. Mercury is a modern logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems. Mercury addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs. This package includes the compiler, profiler, debugger, documentation, etc. It does NOT include the "extras" distribution; that is available from <http://www.cs.mu.oz.au/mercury/download/release.html>.
2001-05-15 23:09:44 +02:00
share/examples/mercury/tests/toplevel/Mmake.thisdir
share/examples/mercury/tests/toplevel/Mmakefile
share/examples/mercury/tests/toplevel/calculator.exp
share/examples/mercury/tests/toplevel/calculator.inp
share/examples/mercury/tests/toplevel/cat.exp
share/examples/mercury/tests/toplevel/cat.inp
share/examples/mercury/tests/toplevel/e.exp
share/examples/mercury/tests/toplevel/eliza.exp
share/examples/mercury/tests/toplevel/eliza.inp
share/examples/mercury/tests/toplevel/expand_terms.exp
share/examples/mercury/tests/toplevel/expand_terms.inp
share/examples/mercury/tests/toplevel/hello.exp
share/examples/mercury/tests/toplevel/interpreter.arg
share/examples/mercury/tests/toplevel/interpreter.exp
share/examples/mercury/tests/toplevel/interpreter.inp
share/examples/mercury/tests/toplevel/interpreter_test.pl
share/examples/mercury/tests/toplevel/runtests
share/examples/mercury/tests/toplevel/sort.exp
share/examples/mercury/tests/toplevel/sort.inp
share/examples/mercury/tests/toplevel/ultra_sub.arg
share/examples/mercury/tests/toplevel/ultra_sub.exp
share/examples/mercury/tests/toplevel/ultra_sub.inp
Update mercury to version 0.11.0. Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution.
2003-05-02 19:48:28 +02:00
share/examples/mercury/ultra_sub.m
Update to Mercury 14.01.1 NEWS for Mercury 14.01.1 ------------------------ This is a bug-fix release. * The function string.string/1 and related functions now handle version arrays properly. * Fix resource leaks in dir fold predicates. * The mfilterjavac program is now generated with the correct file extension on Windows. * A problem that caused compilation of the Boehm GC to fail on 64-bit openSUSE 13.1 systems has been fixed. (Github issue #14) * The documentation now builds correctly on Cygwin systems. * The script configure_mingw_cross now supports 64-bit Windows targets. * We have added workarounds for problems with (arguably broken) system headers on MinGW and MinGW64 systems. * The MinGW port now builds in the absence of POSIX threads library. * Low-level C parallel grades now work on Windows instead of crashing at startup. (Bug #338) * We now use thread-safe alternatives to strerror(). (Bug #340) * We have added the configure option --enable-gc-mmap. * We configure Boehm GC to use mmap in threaded grades on Linux to avoid conflicts with glibc malloc leading to memory corruption. * A problem that caused string.format/[23] to sometimes return incorrect results when formatting floats with the 'g' conversion specifier has been fixed. This bug only affected the non-C backends. (Bug #342) * string.format now handles special float values (i.e. nan, inf, and -inf) correctly with the non-C backends. * A bug that caused io.write_float/[34] to append ".0" to float special values has been fixed. This bug affected the C and C# backends. * In the C# and Java grades, the predicate string.from_char_list now implements the documented behaviour for input lists containing null characters (i.e. it throws an exception). Likewise, for string.from_reverse_char_list in the C# grade. * We have fixed a problem that caused `mmc --make' to attempt to install libraries in non-existent grades. Changes to the Mercury compiler: * The compiler now supports stripping of executables in a separate post-link step. The new options, --strip-executable-command, --strip-executable-shared-flags and --strip-executable-static-flags are used to control this. (This is now the default on Mac OS X systems.) NEWS for Mercury 14.01 ---------------------- Changes to the Mercury language: * Repeated type variables may now occur in the heads of type class instances. For example, instance declarations like the following are now allowed: :- instance foo(list(T), map(T, T)). Changes to the Mercury standard library: * We have added the function cord.condense/1. * The following functions in the standard library's cord module now use constant stack space: foldl/3, foldl_pred/4. * We have added the following predicates to the array and version_array modules: is_empty/1, all_true/2 and all_false/2. * We have added the following predicates and functions to the map module: det_min_key/1, det_max_key/1, foldl2_values/6 and foldl3_values/8. * We have added the following predicates to the list module: foldr2/6, foldr3/8, det_take/3 and map_foldr/5. * We have added the following predicates to the bag module: foldl/4 and foldl2/6. * We have added the following predicates to the assoc_list module: foldl2_values/6 and foldl3_values/8. * We have added the following predicates and functions to the pqueue module: is_empty/1, peek/3, peek_key/2, peek_value/2, det_peek/3, merge/3, det_peek_key/1 and det_peek_value/1. * We have added the predicate bimap.equal/2. * We have added the following predicates to the int module: fold_up3/9 and fold_down3/9. Changes to the Mercury compiler: * On Mac OS X systems the compiler is now configured use the version of the host system as the default value for the deployment target. A new configuration option, `--with-macosx-deployment-target', allows an alternative value to be selected at configuration time. Portability improvements: * We have made the implementation compatible with GCC 4.8 and Visual Studio 2013. * We have made the implementation compatible with OS X 10.9. Changes to the extras distribution: * We've added a library that provides support for accessing the function trail from Mercury code.
2015-01-04 20:37:02 +01:00
@pkgdir lib/mercury/lib/asm_fast.gc/inc/Mercury
@pkgdir lib/mercury/lib/asm_fast.gc.trseg/inc/Mercury
@pkgdir lib/mercury/lib/asm_fast.gc.trseg.debug.stseg/inc/Mercury
@pkgdir lib/mercury/lib/asm_fast.gc.profdeep/inc/Mercury
@pkgdir lib/mercury/lib/asm_fast.gc.prof/inc/Mercury
@pkgdir lib/mercury/lib/asm_fast.gc.memprof/inc/Mercury
@pkgdir lib/mercury/lib/asm_fast.gc.decldebug.stseg/inc/Mercury
@pkgdir lib/mercury/lib/asm_fast.gc.debug.stseg/inc/Mercury
Reference in a new issue Copy permalink