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

2151 lines
90 KiB
Text
Raw Normal View History

Convert to USE_NEW_TEXINFO. Add info directory entries by way of patch files to most of the info files.
2003-07-05 23:16:36 +02:00
@comment $NetBSD: PLIST,v 1.5 2003/07/05 21:16:36 seb 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
bin/mdb
bin/mdemangle
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
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_cleanup_install
bin/mercury_update_interface
bin/mgnuc
bin/mkfifo_using_mknod
bin/mkinit
bin/ml
bin/mmake
bin/mmc
bin/mprof
bin/mprof_merge_runs
bin/mtags
bin/vpath_find
info/mercury.info
info/mercury_faq.info
info/mercury_library.info
info/mercury_library.info-1
info/mercury_library.info-10
info/mercury_library.info-11
info/mercury_library.info-12
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
info/mercury_library.info-13
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
info/mercury_library.info-2
info/mercury_library.info-3
info/mercury_library.info-4
info/mercury_library.info-5
info/mercury_library.info-6
info/mercury_library.info-7
info/mercury_library.info-8
info/mercury_library.info-9
info/mercury_ref.info
info/mercury_ref.info-1
info/mercury_ref.info-2
info/mercury_ref.info-3
info/mercury_ref.info-4
info/mercury_ref.info-5
info/mercury_ref.info-6
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
info/mercury_ref.info-7
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
info/mercury_trans_guide.info
info/mercury_user_guide.info
info/mercury_user_guide.info-1
info/mercury_user_guide.info-2
info/mercury_user_guide.info-3
info/mercury_user_guide.info-4
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
info/mercury_user_guide.info-5
info/mercury_user_guide.info-6
The host specific installation subdirectories are actually taken by configure from its --host argument, which is exactly ${MACHINE_GNU_PLATFORM}. Use that for the PLIST instead of ${MACHINE_ARCH}--${LOWER_OPSYS}, which may lack the "elf" suffix on certain platforms.
2002-03-18 08:58:35 +01:00
lib/mercury/bin/${MACHINE_GNU_PLATFORM}/mercury_compile
lib/mercury/bin/${MACHINE_GNU_PLATFORM}/mercury_profile
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
lib/mercury/inc/assoc_list.mh
lib/mercury/inc/bag.mh
lib/mercury/inc/benchmarking.mh
lib/mercury/inc/bimap.mh
lib/mercury/inc/bintree.mh
lib/mercury/inc/bintree_set.mh
lib/mercury/inc/bitmap.mh
lib/mercury/inc/bool.mh
lib/mercury/inc/bt_array.mh
lib/mercury/inc/builtin.mh
lib/mercury/inc/char.mh
lib/mercury/inc/construct.mh
lib/mercury/inc/counter.mh
lib/mercury/inc/deconstruct.mh
lib/mercury/inc/dir.mh
lib/mercury/inc/enum.mh
lib/mercury/inc/eqvclass.mh
lib/mercury/inc/exception.mh
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
lib/mercury/inc/gc_inl.h
lib/mercury/inc/gc_local_alloc.h
lib/mercury/inc/gc_mark.h
lib/mercury/inc/gc_pthread_redirects.h
lib/mercury/inc/getopt.mh
lib/mercury/inc/graph.mh
lib/mercury/inc/group.mh
lib/mercury/inc/hash_table.mh
lib/mercury/inc/int.mh
lib/mercury/inc/integer.mh
lib/mercury/inc/io.mh
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 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
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 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
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
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
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
lib/mercury/inc/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/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 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
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
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 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
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
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
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
lib/mercury/inc/mercury_regorder.h
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
lib/mercury/inc/mercury_string.h
lib/mercury/inc/mercury_tabling.h
lib/mercury/inc/mercury_tabling_macros.h
lib/mercury/inc/mercury_tags.h
lib/mercury/inc/mercury_thread.h
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 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
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
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
lib/mercury/inc/mercury_types.h
lib/mercury/inc/mercury_unify_compare_body.h
lib/mercury/inc/mercury_wrapper.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
lib/mercury/inc/ops.mh
lib/mercury/inc/parser.mh
lib/mercury/inc/pprint.mh
lib/mercury/inc/pqueue.mh
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
lib/mercury/inc/relation.mh
lib/mercury/inc/require.mh
lib/mercury/inc/rtti_implementation.mh
lib/mercury/inc/set.mh
lib/mercury/inc/set_bbbtree.mh
lib/mercury/inc/set_ordlist.mh
lib/mercury/inc/set_unordlist.mh
lib/mercury/inc/sparse_bitset.mh
lib/mercury/inc/stack.mh
lib/mercury/inc/std_util.mh
lib/mercury/inc/store.mh
lib/mercury/inc/string.mh
lib/mercury/inc/table_builtin.mh
lib/mercury/inc/term.mh
lib/mercury/inc/term_io.mh
lib/mercury/inc/time.mh
lib/mercury/inc/tree234.mh
lib/mercury/inc/type_desc.mh
lib/mercury/inc/varset.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/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 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
lib/mercury/ints/asm_fast.gc.memprof/assoc_list.opt
lib/mercury/ints/asm_fast.gc.memprof/assoc_list.trans_opt
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
lib/mercury/ints/asm_fast.gc.memprof/bintree.opt
lib/mercury/ints/asm_fast.gc.memprof/bintree.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/bintree_set.opt
lib/mercury/ints/asm_fast.gc.memprof/bintree_set.trans_opt
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
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
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
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
lib/mercury/ints/asm_fast.gc.memprof/exception.opt
lib/mercury/ints/asm_fast.gc.memprof/exception.trans_opt
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
lib/mercury/ints/asm_fast.gc.memprof/graph.opt
lib/mercury/ints/asm_fast.gc.memprof/graph.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/group.opt
lib/mercury/ints/asm_fast.gc.memprof/group.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/hash_table.opt
lib/mercury/ints/asm_fast.gc.memprof/hash_table.trans_opt
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
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
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
lib/mercury/ints/asm_fast.gc.memprof/ops.opt
lib/mercury/ints/asm_fast.gc.memprof/ops.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/parser.opt
lib/mercury/ints/asm_fast.gc.memprof/parser.trans_opt
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
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
lib/mercury/ints/asm_fast.gc.memprof/relation.opt
lib/mercury/ints/asm_fast.gc.memprof/relation.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/require.opt
lib/mercury/ints/asm_fast.gc.memprof/require.trans_opt
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
lib/mercury/ints/asm_fast.gc.memprof/set_ordlist.opt
lib/mercury/ints/asm_fast.gc.memprof/set_ordlist.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/set_unordlist.opt
lib/mercury/ints/asm_fast.gc.memprof/set_unordlist.trans_opt
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
lib/mercury/ints/asm_fast.gc.memprof/store.opt
lib/mercury/ints/asm_fast.gc.memprof/store.trans_opt
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
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
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
lib/mercury/ints/asm_fast.gc.memprof/type_desc.opt
lib/mercury/ints/asm_fast.gc.memprof/type_desc.trans_opt
lib/mercury/ints/asm_fast.gc.memprof/varset.opt
lib/mercury/ints/asm_fast.gc.memprof/varset.trans_opt
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
lib/mercury/ints/asm_fast.gc.prof/assoc_list.opt
lib/mercury/ints/asm_fast.gc.prof/assoc_list.trans_opt
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
lib/mercury/ints/asm_fast.gc.prof/bintree.opt
lib/mercury/ints/asm_fast.gc.prof/bintree.trans_opt
lib/mercury/ints/asm_fast.gc.prof/bintree_set.opt
lib/mercury/ints/asm_fast.gc.prof/bintree_set.trans_opt
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
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
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
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
lib/mercury/ints/asm_fast.gc.prof/exception.opt
lib/mercury/ints/asm_fast.gc.prof/exception.trans_opt
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
lib/mercury/ints/asm_fast.gc.prof/graph.opt
lib/mercury/ints/asm_fast.gc.prof/graph.trans_opt
lib/mercury/ints/asm_fast.gc.prof/group.opt
lib/mercury/ints/asm_fast.gc.prof/group.trans_opt
lib/mercury/ints/asm_fast.gc.prof/hash_table.opt
lib/mercury/ints/asm_fast.gc.prof/hash_table.trans_opt
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
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
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
lib/mercury/ints/asm_fast.gc.prof/ops.opt
lib/mercury/ints/asm_fast.gc.prof/ops.trans_opt
lib/mercury/ints/asm_fast.gc.prof/parser.opt
lib/mercury/ints/asm_fast.gc.prof/parser.trans_opt
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
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
lib/mercury/ints/asm_fast.gc.prof/relation.opt
lib/mercury/ints/asm_fast.gc.prof/relation.trans_opt
lib/mercury/ints/asm_fast.gc.prof/require.opt
lib/mercury/ints/asm_fast.gc.prof/require.trans_opt
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
lib/mercury/ints/asm_fast.gc.prof/set_ordlist.opt
lib/mercury/ints/asm_fast.gc.prof/set_ordlist.trans_opt
lib/mercury/ints/asm_fast.gc.prof/set_unordlist.opt
lib/mercury/ints/asm_fast.gc.prof/set_unordlist.trans_opt
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
lib/mercury/ints/asm_fast.gc.prof/store.opt
lib/mercury/ints/asm_fast.gc.prof/store.trans_opt
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
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
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
lib/mercury/ints/asm_fast.gc.prof/type_desc.opt
lib/mercury/ints/asm_fast.gc.prof/type_desc.trans_opt
lib/mercury/ints/asm_fast.gc.prof/varset.opt
lib/mercury/ints/asm_fast.gc.prof/varset.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/Mercury/opts
lib/mercury/ints/asm_fast.gc.tr.debug/Mercury/trans_opts
lib/mercury/ints/asm_fast.gc.tr.debug/array.opt
lib/mercury/ints/asm_fast.gc.tr.debug/array.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/assoc_list.opt
lib/mercury/ints/asm_fast.gc.tr.debug/assoc_list.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/bag.opt
lib/mercury/ints/asm_fast.gc.tr.debug/bag.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/benchmarking.opt
lib/mercury/ints/asm_fast.gc.tr.debug/benchmarking.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/bimap.opt
lib/mercury/ints/asm_fast.gc.tr.debug/bimap.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/bintree.opt
lib/mercury/ints/asm_fast.gc.tr.debug/bintree.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/bintree_set.opt
lib/mercury/ints/asm_fast.gc.tr.debug/bintree_set.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/bitmap.opt
lib/mercury/ints/asm_fast.gc.tr.debug/bitmap.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/bool.opt
lib/mercury/ints/asm_fast.gc.tr.debug/bool.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/bt_array.opt
lib/mercury/ints/asm_fast.gc.tr.debug/bt_array.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/builtin.opt
lib/mercury/ints/asm_fast.gc.tr.debug/builtin.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/char.opt
lib/mercury/ints/asm_fast.gc.tr.debug/char.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/construct.opt
lib/mercury/ints/asm_fast.gc.tr.debug/construct.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/counter.opt
lib/mercury/ints/asm_fast.gc.tr.debug/counter.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/deconstruct.opt
lib/mercury/ints/asm_fast.gc.tr.debug/deconstruct.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/dir.opt
lib/mercury/ints/asm_fast.gc.tr.debug/dir.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/enum.opt
lib/mercury/ints/asm_fast.gc.tr.debug/enum.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/eqvclass.opt
lib/mercury/ints/asm_fast.gc.tr.debug/eqvclass.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/exception.opt
lib/mercury/ints/asm_fast.gc.tr.debug/exception.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/float.opt
lib/mercury/ints/asm_fast.gc.tr.debug/float.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/gc.opt
lib/mercury/ints/asm_fast.gc.tr.debug/gc.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/getopt.opt
lib/mercury/ints/asm_fast.gc.tr.debug/getopt.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/graph.opt
lib/mercury/ints/asm_fast.gc.tr.debug/graph.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/group.opt
lib/mercury/ints/asm_fast.gc.tr.debug/group.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/hash_table.opt
lib/mercury/ints/asm_fast.gc.tr.debug/hash_table.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/int.opt
lib/mercury/ints/asm_fast.gc.tr.debug/int.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/integer.opt
lib/mercury/ints/asm_fast.gc.tr.debug/integer.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/io.opt
lib/mercury/ints/asm_fast.gc.tr.debug/io.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/lexer.opt
lib/mercury/ints/asm_fast.gc.tr.debug/lexer.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/library.opt
lib/mercury/ints/asm_fast.gc.tr.debug/library.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/list.opt
lib/mercury/ints/asm_fast.gc.tr.debug/list.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/map.opt
lib/mercury/ints/asm_fast.gc.tr.debug/map.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/math.opt
lib/mercury/ints/asm_fast.gc.tr.debug/math.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/mer_std.opt
lib/mercury/ints/asm_fast.gc.tr.debug/mer_std.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/multi_map.opt
lib/mercury/ints/asm_fast.gc.tr.debug/multi_map.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/ops.opt
lib/mercury/ints/asm_fast.gc.tr.debug/ops.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/parser.opt
lib/mercury/ints/asm_fast.gc.tr.debug/parser.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/pprint.opt
lib/mercury/ints/asm_fast.gc.tr.debug/pprint.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/pqueue.opt
lib/mercury/ints/asm_fast.gc.tr.debug/pqueue.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/private_builtin.opt
lib/mercury/ints/asm_fast.gc.tr.debug/private_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/profiling_builtin.opt
lib/mercury/ints/asm_fast.gc.tr.debug/profiling_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/prolog.opt
lib/mercury/ints/asm_fast.gc.tr.debug/prolog.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/queue.opt
lib/mercury/ints/asm_fast.gc.tr.debug/queue.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/random.opt
lib/mercury/ints/asm_fast.gc.tr.debug/random.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/rational.opt
lib/mercury/ints/asm_fast.gc.tr.debug/rational.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/rbtree.opt
lib/mercury/ints/asm_fast.gc.tr.debug/rbtree.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/relation.opt
lib/mercury/ints/asm_fast.gc.tr.debug/relation.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/require.opt
lib/mercury/ints/asm_fast.gc.tr.debug/require.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/rtti_implementation.opt
lib/mercury/ints/asm_fast.gc.tr.debug/rtti_implementation.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/set.opt
lib/mercury/ints/asm_fast.gc.tr.debug/set.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/set_bbbtree.opt
lib/mercury/ints/asm_fast.gc.tr.debug/set_bbbtree.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/set_ordlist.opt
lib/mercury/ints/asm_fast.gc.tr.debug/set_ordlist.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/set_unordlist.opt
lib/mercury/ints/asm_fast.gc.tr.debug/set_unordlist.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/sparse_bitset.opt
lib/mercury/ints/asm_fast.gc.tr.debug/sparse_bitset.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/stack.opt
lib/mercury/ints/asm_fast.gc.tr.debug/stack.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/std_util.opt
lib/mercury/ints/asm_fast.gc.tr.debug/std_util.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/store.opt
lib/mercury/ints/asm_fast.gc.tr.debug/store.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/string.opt
lib/mercury/ints/asm_fast.gc.tr.debug/string.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/table_builtin.opt
lib/mercury/ints/asm_fast.gc.tr.debug/table_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/term.opt
lib/mercury/ints/asm_fast.gc.tr.debug/term.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/term_io.opt
lib/mercury/ints/asm_fast.gc.tr.debug/term_io.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/time.opt
lib/mercury/ints/asm_fast.gc.tr.debug/time.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/tree234.opt
lib/mercury/ints/asm_fast.gc.tr.debug/tree234.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/type_desc.opt
lib/mercury/ints/asm_fast.gc.tr.debug/type_desc.trans_opt
lib/mercury/ints/asm_fast.gc.tr.debug/varset.opt
lib/mercury/ints/asm_fast.gc.tr.debug/varset.trans_opt
lib/mercury/ints/asm_fast.gc.tr/Mercury/opts
lib/mercury/ints/asm_fast.gc.tr/Mercury/trans_opts
lib/mercury/ints/asm_fast.gc.tr/array.opt
lib/mercury/ints/asm_fast.gc.tr/array.trans_opt
lib/mercury/ints/asm_fast.gc.tr/assoc_list.opt
lib/mercury/ints/asm_fast.gc.tr/assoc_list.trans_opt
lib/mercury/ints/asm_fast.gc.tr/bag.opt
lib/mercury/ints/asm_fast.gc.tr/bag.trans_opt
lib/mercury/ints/asm_fast.gc.tr/benchmarking.opt
lib/mercury/ints/asm_fast.gc.tr/benchmarking.trans_opt
lib/mercury/ints/asm_fast.gc.tr/bimap.opt
lib/mercury/ints/asm_fast.gc.tr/bimap.trans_opt
lib/mercury/ints/asm_fast.gc.tr/bintree.opt
lib/mercury/ints/asm_fast.gc.tr/bintree.trans_opt
lib/mercury/ints/asm_fast.gc.tr/bintree_set.opt
lib/mercury/ints/asm_fast.gc.tr/bintree_set.trans_opt
lib/mercury/ints/asm_fast.gc.tr/bitmap.opt
lib/mercury/ints/asm_fast.gc.tr/bitmap.trans_opt
lib/mercury/ints/asm_fast.gc.tr/bool.opt
lib/mercury/ints/asm_fast.gc.tr/bool.trans_opt
lib/mercury/ints/asm_fast.gc.tr/bt_array.opt
lib/mercury/ints/asm_fast.gc.tr/bt_array.trans_opt
lib/mercury/ints/asm_fast.gc.tr/builtin.opt
lib/mercury/ints/asm_fast.gc.tr/builtin.trans_opt
lib/mercury/ints/asm_fast.gc.tr/char.opt
lib/mercury/ints/asm_fast.gc.tr/char.trans_opt
lib/mercury/ints/asm_fast.gc.tr/construct.opt
lib/mercury/ints/asm_fast.gc.tr/construct.trans_opt
lib/mercury/ints/asm_fast.gc.tr/counter.opt
lib/mercury/ints/asm_fast.gc.tr/counter.trans_opt
lib/mercury/ints/asm_fast.gc.tr/deconstruct.opt
lib/mercury/ints/asm_fast.gc.tr/deconstruct.trans_opt
lib/mercury/ints/asm_fast.gc.tr/dir.opt
lib/mercury/ints/asm_fast.gc.tr/dir.trans_opt
lib/mercury/ints/asm_fast.gc.tr/enum.opt
lib/mercury/ints/asm_fast.gc.tr/enum.trans_opt
lib/mercury/ints/asm_fast.gc.tr/eqvclass.opt
lib/mercury/ints/asm_fast.gc.tr/eqvclass.trans_opt
lib/mercury/ints/asm_fast.gc.tr/exception.opt
lib/mercury/ints/asm_fast.gc.tr/exception.trans_opt
lib/mercury/ints/asm_fast.gc.tr/float.opt
lib/mercury/ints/asm_fast.gc.tr/float.trans_opt
lib/mercury/ints/asm_fast.gc.tr/gc.opt
lib/mercury/ints/asm_fast.gc.tr/gc.trans_opt
lib/mercury/ints/asm_fast.gc.tr/getopt.opt
lib/mercury/ints/asm_fast.gc.tr/getopt.trans_opt
lib/mercury/ints/asm_fast.gc.tr/graph.opt
lib/mercury/ints/asm_fast.gc.tr/graph.trans_opt
lib/mercury/ints/asm_fast.gc.tr/group.opt
lib/mercury/ints/asm_fast.gc.tr/group.trans_opt
lib/mercury/ints/asm_fast.gc.tr/hash_table.opt
lib/mercury/ints/asm_fast.gc.tr/hash_table.trans_opt
lib/mercury/ints/asm_fast.gc.tr/int.opt
lib/mercury/ints/asm_fast.gc.tr/int.trans_opt
lib/mercury/ints/asm_fast.gc.tr/integer.opt
lib/mercury/ints/asm_fast.gc.tr/integer.trans_opt
lib/mercury/ints/asm_fast.gc.tr/io.opt
lib/mercury/ints/asm_fast.gc.tr/io.trans_opt
lib/mercury/ints/asm_fast.gc.tr/lexer.opt
lib/mercury/ints/asm_fast.gc.tr/lexer.trans_opt
lib/mercury/ints/asm_fast.gc.tr/library.opt
lib/mercury/ints/asm_fast.gc.tr/library.trans_opt
lib/mercury/ints/asm_fast.gc.tr/list.opt
lib/mercury/ints/asm_fast.gc.tr/list.trans_opt
lib/mercury/ints/asm_fast.gc.tr/map.opt
lib/mercury/ints/asm_fast.gc.tr/map.trans_opt
lib/mercury/ints/asm_fast.gc.tr/math.opt
lib/mercury/ints/asm_fast.gc.tr/math.trans_opt
lib/mercury/ints/asm_fast.gc.tr/mer_std.opt
lib/mercury/ints/asm_fast.gc.tr/mer_std.trans_opt
lib/mercury/ints/asm_fast.gc.tr/multi_map.opt
lib/mercury/ints/asm_fast.gc.tr/multi_map.trans_opt
lib/mercury/ints/asm_fast.gc.tr/ops.opt
lib/mercury/ints/asm_fast.gc.tr/ops.trans_opt
lib/mercury/ints/asm_fast.gc.tr/parser.opt
lib/mercury/ints/asm_fast.gc.tr/parser.trans_opt
lib/mercury/ints/asm_fast.gc.tr/pprint.opt
lib/mercury/ints/asm_fast.gc.tr/pprint.trans_opt
lib/mercury/ints/asm_fast.gc.tr/pqueue.opt
lib/mercury/ints/asm_fast.gc.tr/pqueue.trans_opt
lib/mercury/ints/asm_fast.gc.tr/private_builtin.opt
lib/mercury/ints/asm_fast.gc.tr/private_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.tr/profiling_builtin.opt
lib/mercury/ints/asm_fast.gc.tr/profiling_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.tr/prolog.opt
lib/mercury/ints/asm_fast.gc.tr/prolog.trans_opt
lib/mercury/ints/asm_fast.gc.tr/queue.opt
lib/mercury/ints/asm_fast.gc.tr/queue.trans_opt
lib/mercury/ints/asm_fast.gc.tr/random.opt
lib/mercury/ints/asm_fast.gc.tr/random.trans_opt
lib/mercury/ints/asm_fast.gc.tr/rational.opt
lib/mercury/ints/asm_fast.gc.tr/rational.trans_opt
lib/mercury/ints/asm_fast.gc.tr/rbtree.opt
lib/mercury/ints/asm_fast.gc.tr/rbtree.trans_opt
lib/mercury/ints/asm_fast.gc.tr/relation.opt
lib/mercury/ints/asm_fast.gc.tr/relation.trans_opt
lib/mercury/ints/asm_fast.gc.tr/require.opt
lib/mercury/ints/asm_fast.gc.tr/require.trans_opt
lib/mercury/ints/asm_fast.gc.tr/rtti_implementation.opt
lib/mercury/ints/asm_fast.gc.tr/rtti_implementation.trans_opt
lib/mercury/ints/asm_fast.gc.tr/set.opt
lib/mercury/ints/asm_fast.gc.tr/set.trans_opt
lib/mercury/ints/asm_fast.gc.tr/set_bbbtree.opt
lib/mercury/ints/asm_fast.gc.tr/set_bbbtree.trans_opt
lib/mercury/ints/asm_fast.gc.tr/set_ordlist.opt
lib/mercury/ints/asm_fast.gc.tr/set_ordlist.trans_opt
lib/mercury/ints/asm_fast.gc.tr/set_unordlist.opt
lib/mercury/ints/asm_fast.gc.tr/set_unordlist.trans_opt
lib/mercury/ints/asm_fast.gc.tr/sparse_bitset.opt
lib/mercury/ints/asm_fast.gc.tr/sparse_bitset.trans_opt
lib/mercury/ints/asm_fast.gc.tr/stack.opt
lib/mercury/ints/asm_fast.gc.tr/stack.trans_opt
lib/mercury/ints/asm_fast.gc.tr/std_util.opt
lib/mercury/ints/asm_fast.gc.tr/std_util.trans_opt
lib/mercury/ints/asm_fast.gc.tr/store.opt
lib/mercury/ints/asm_fast.gc.tr/store.trans_opt
lib/mercury/ints/asm_fast.gc.tr/string.opt
lib/mercury/ints/asm_fast.gc.tr/string.trans_opt
lib/mercury/ints/asm_fast.gc.tr/table_builtin.opt
lib/mercury/ints/asm_fast.gc.tr/table_builtin.trans_opt
lib/mercury/ints/asm_fast.gc.tr/term.opt
lib/mercury/ints/asm_fast.gc.tr/term.trans_opt
lib/mercury/ints/asm_fast.gc.tr/term_io.opt
lib/mercury/ints/asm_fast.gc.tr/term_io.trans_opt
lib/mercury/ints/asm_fast.gc.tr/time.opt
lib/mercury/ints/asm_fast.gc.tr/time.trans_opt
lib/mercury/ints/asm_fast.gc.tr/tree234.opt
lib/mercury/ints/asm_fast.gc.tr/tree234.trans_opt
lib/mercury/ints/asm_fast.gc.tr/type_desc.opt
lib/mercury/ints/asm_fast.gc.tr/type_desc.trans_opt
lib/mercury/ints/asm_fast.gc.tr/varset.opt
lib/mercury/ints/asm_fast.gc.tr/varset.trans_opt
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
lib/mercury/ints/asm_fast.gc/assoc_list.opt
lib/mercury/ints/asm_fast.gc/assoc_list.trans_opt
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
lib/mercury/ints/asm_fast.gc/bintree.opt
lib/mercury/ints/asm_fast.gc/bintree.trans_opt
lib/mercury/ints/asm_fast.gc/bintree_set.opt
lib/mercury/ints/asm_fast.gc/bintree_set.trans_opt
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
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
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
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
lib/mercury/ints/asm_fast.gc/exception.opt
lib/mercury/ints/asm_fast.gc/exception.trans_opt
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
lib/mercury/ints/asm_fast.gc/graph.opt
lib/mercury/ints/asm_fast.gc/graph.trans_opt
lib/mercury/ints/asm_fast.gc/group.opt
lib/mercury/ints/asm_fast.gc/group.trans_opt
lib/mercury/ints/asm_fast.gc/hash_table.opt
lib/mercury/ints/asm_fast.gc/hash_table.trans_opt
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
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
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
lib/mercury/ints/asm_fast.gc/ops.opt
lib/mercury/ints/asm_fast.gc/ops.trans_opt
lib/mercury/ints/asm_fast.gc/parser.opt
lib/mercury/ints/asm_fast.gc/parser.trans_opt
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
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
lib/mercury/ints/asm_fast.gc/relation.opt
lib/mercury/ints/asm_fast.gc/relation.trans_opt
lib/mercury/ints/asm_fast.gc/require.opt
lib/mercury/ints/asm_fast.gc/require.trans_opt
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
lib/mercury/ints/asm_fast.gc/set_ordlist.opt
lib/mercury/ints/asm_fast.gc/set_ordlist.trans_opt
lib/mercury/ints/asm_fast.gc/set_unordlist.opt
lib/mercury/ints/asm_fast.gc/set_unordlist.trans_opt
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
lib/mercury/ints/asm_fast.gc/store.opt
lib/mercury/ints/asm_fast.gc/store.trans_opt
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
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
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
lib/mercury/ints/asm_fast.gc/type_desc.opt
lib/mercury/ints/asm_fast.gc/type_desc.trans_opt
lib/mercury/ints/asm_fast.gc/varset.opt
lib/mercury/ints/asm_fast.gc/varset.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
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
lib/mercury/ints/bintree.int
lib/mercury/ints/bintree.int2
lib/mercury/ints/bintree.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/bintree.mh
lib/mercury/ints/bintree.mih
lib/mercury/ints/bintree.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/bintree.opt
lib/mercury/ints/bintree.trans_opt
lib/mercury/ints/bintree_set.int
lib/mercury/ints/bintree_set.int2
lib/mercury/ints/bintree_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/bintree_set.mh
lib/mercury/ints/bintree_set.mih
lib/mercury/ints/bintree_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/bintree_set.opt
lib/mercury/ints/bintree_set.trans_opt
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
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
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
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
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
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
lib/mercury/ints/graph.int
lib/mercury/ints/graph.int2
lib/mercury/ints/graph.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/graph.mh
lib/mercury/ints/graph.mih
lib/mercury/ints/graph.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/graph.opt
lib/mercury/ints/graph.trans_opt
lib/mercury/ints/group.int
lib/mercury/ints/group.int2
lib/mercury/ints/group.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/group.mh
lib/mercury/ints/group.mih
lib/mercury/ints/group.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/group.opt
lib/mercury/ints/group.trans_opt
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 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
lib/mercury/ints/hlc.gc/assoc_list.opt
lib/mercury/ints/hlc.gc/assoc_list.trans_opt
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
lib/mercury/ints/hlc.gc/bintree.opt
lib/mercury/ints/hlc.gc/bintree.trans_opt
lib/mercury/ints/hlc.gc/bintree_set.opt
lib/mercury/ints/hlc.gc/bintree_set.trans_opt
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
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
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
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
lib/mercury/ints/hlc.gc/exception.opt
lib/mercury/ints/hlc.gc/exception.trans_opt
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
lib/mercury/ints/hlc.gc/graph.opt
lib/mercury/ints/hlc.gc/graph.trans_opt
lib/mercury/ints/hlc.gc/group.opt
lib/mercury/ints/hlc.gc/group.trans_opt
lib/mercury/ints/hlc.gc/hash_table.opt
lib/mercury/ints/hlc.gc/hash_table.trans_opt
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
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
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
lib/mercury/ints/hlc.gc/ops.opt
lib/mercury/ints/hlc.gc/ops.trans_opt
lib/mercury/ints/hlc.gc/parser.opt
lib/mercury/ints/hlc.gc/parser.trans_opt
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
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
lib/mercury/ints/hlc.gc/relation.opt
lib/mercury/ints/hlc.gc/relation.trans_opt
lib/mercury/ints/hlc.gc/require.opt
lib/mercury/ints/hlc.gc/require.trans_opt
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
lib/mercury/ints/hlc.gc/set_ordlist.opt
lib/mercury/ints/hlc.gc/set_ordlist.trans_opt
lib/mercury/ints/hlc.gc/set_unordlist.opt
lib/mercury/ints/hlc.gc/set_unordlist.trans_opt
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
lib/mercury/ints/hlc.gc/store.opt
lib/mercury/ints/hlc.gc/store.trans_opt
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
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
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
lib/mercury/ints/hlc.gc/type_desc.opt
lib/mercury/ints/hlc.gc/type_desc.trans_opt
lib/mercury/ints/hlc.gc/varset.opt
lib/mercury/ints/hlc.gc/varset.trans_opt
lib/mercury/ints/hlc.par.gc/Mercury/opts
lib/mercury/ints/hlc.par.gc/Mercury/trans_opts
lib/mercury/ints/hlc.par.gc/array.opt
lib/mercury/ints/hlc.par.gc/array.trans_opt
lib/mercury/ints/hlc.par.gc/assoc_list.opt
lib/mercury/ints/hlc.par.gc/assoc_list.trans_opt
lib/mercury/ints/hlc.par.gc/bag.opt
lib/mercury/ints/hlc.par.gc/bag.trans_opt
lib/mercury/ints/hlc.par.gc/benchmarking.opt
lib/mercury/ints/hlc.par.gc/benchmarking.trans_opt
lib/mercury/ints/hlc.par.gc/bimap.opt
lib/mercury/ints/hlc.par.gc/bimap.trans_opt
lib/mercury/ints/hlc.par.gc/bintree.opt
lib/mercury/ints/hlc.par.gc/bintree.trans_opt
lib/mercury/ints/hlc.par.gc/bintree_set.opt
lib/mercury/ints/hlc.par.gc/bintree_set.trans_opt
lib/mercury/ints/hlc.par.gc/bitmap.opt
lib/mercury/ints/hlc.par.gc/bitmap.trans_opt
lib/mercury/ints/hlc.par.gc/bool.opt
lib/mercury/ints/hlc.par.gc/bool.trans_opt
lib/mercury/ints/hlc.par.gc/bt_array.opt
lib/mercury/ints/hlc.par.gc/bt_array.trans_opt
lib/mercury/ints/hlc.par.gc/builtin.opt
lib/mercury/ints/hlc.par.gc/builtin.trans_opt
lib/mercury/ints/hlc.par.gc/char.opt
lib/mercury/ints/hlc.par.gc/char.trans_opt
lib/mercury/ints/hlc.par.gc/construct.opt
lib/mercury/ints/hlc.par.gc/construct.trans_opt
lib/mercury/ints/hlc.par.gc/counter.opt
lib/mercury/ints/hlc.par.gc/counter.trans_opt
lib/mercury/ints/hlc.par.gc/deconstruct.opt
lib/mercury/ints/hlc.par.gc/deconstruct.trans_opt
lib/mercury/ints/hlc.par.gc/dir.opt
lib/mercury/ints/hlc.par.gc/dir.trans_opt
lib/mercury/ints/hlc.par.gc/enum.opt
lib/mercury/ints/hlc.par.gc/enum.trans_opt
lib/mercury/ints/hlc.par.gc/eqvclass.opt
lib/mercury/ints/hlc.par.gc/eqvclass.trans_opt
lib/mercury/ints/hlc.par.gc/exception.opt
lib/mercury/ints/hlc.par.gc/exception.trans_opt
lib/mercury/ints/hlc.par.gc/float.opt
lib/mercury/ints/hlc.par.gc/float.trans_opt
lib/mercury/ints/hlc.par.gc/gc.opt
lib/mercury/ints/hlc.par.gc/gc.trans_opt
lib/mercury/ints/hlc.par.gc/getopt.opt
lib/mercury/ints/hlc.par.gc/getopt.trans_opt
lib/mercury/ints/hlc.par.gc/graph.opt
lib/mercury/ints/hlc.par.gc/graph.trans_opt
lib/mercury/ints/hlc.par.gc/group.opt
lib/mercury/ints/hlc.par.gc/group.trans_opt
lib/mercury/ints/hlc.par.gc/hash_table.opt
lib/mercury/ints/hlc.par.gc/hash_table.trans_opt
lib/mercury/ints/hlc.par.gc/int.opt
lib/mercury/ints/hlc.par.gc/int.trans_opt
lib/mercury/ints/hlc.par.gc/integer.opt
lib/mercury/ints/hlc.par.gc/integer.trans_opt
lib/mercury/ints/hlc.par.gc/io.opt
lib/mercury/ints/hlc.par.gc/io.trans_opt
lib/mercury/ints/hlc.par.gc/lexer.opt
lib/mercury/ints/hlc.par.gc/lexer.trans_opt
lib/mercury/ints/hlc.par.gc/library.opt
lib/mercury/ints/hlc.par.gc/library.trans_opt
lib/mercury/ints/hlc.par.gc/list.opt
lib/mercury/ints/hlc.par.gc/list.trans_opt
lib/mercury/ints/hlc.par.gc/map.opt
lib/mercury/ints/hlc.par.gc/map.trans_opt
lib/mercury/ints/hlc.par.gc/math.opt
lib/mercury/ints/hlc.par.gc/math.trans_opt
lib/mercury/ints/hlc.par.gc/mer_std.opt
lib/mercury/ints/hlc.par.gc/mer_std.trans_opt
lib/mercury/ints/hlc.par.gc/multi_map.opt
lib/mercury/ints/hlc.par.gc/multi_map.trans_opt
lib/mercury/ints/hlc.par.gc/ops.opt
lib/mercury/ints/hlc.par.gc/ops.trans_opt
lib/mercury/ints/hlc.par.gc/parser.opt
lib/mercury/ints/hlc.par.gc/parser.trans_opt
lib/mercury/ints/hlc.par.gc/pprint.opt
lib/mercury/ints/hlc.par.gc/pprint.trans_opt
lib/mercury/ints/hlc.par.gc/pqueue.opt
lib/mercury/ints/hlc.par.gc/pqueue.trans_opt
lib/mercury/ints/hlc.par.gc/private_builtin.opt
lib/mercury/ints/hlc.par.gc/private_builtin.trans_opt
lib/mercury/ints/hlc.par.gc/profiling_builtin.opt
lib/mercury/ints/hlc.par.gc/profiling_builtin.trans_opt
lib/mercury/ints/hlc.par.gc/prolog.opt
lib/mercury/ints/hlc.par.gc/prolog.trans_opt
lib/mercury/ints/hlc.par.gc/queue.opt
lib/mercury/ints/hlc.par.gc/queue.trans_opt
lib/mercury/ints/hlc.par.gc/random.opt
lib/mercury/ints/hlc.par.gc/random.trans_opt
lib/mercury/ints/hlc.par.gc/rational.opt
lib/mercury/ints/hlc.par.gc/rational.trans_opt
lib/mercury/ints/hlc.par.gc/rbtree.opt
lib/mercury/ints/hlc.par.gc/rbtree.trans_opt
lib/mercury/ints/hlc.par.gc/relation.opt
lib/mercury/ints/hlc.par.gc/relation.trans_opt
lib/mercury/ints/hlc.par.gc/require.opt
lib/mercury/ints/hlc.par.gc/require.trans_opt
lib/mercury/ints/hlc.par.gc/rtti_implementation.opt
lib/mercury/ints/hlc.par.gc/rtti_implementation.trans_opt
lib/mercury/ints/hlc.par.gc/set.opt
lib/mercury/ints/hlc.par.gc/set.trans_opt
lib/mercury/ints/hlc.par.gc/set_bbbtree.opt
lib/mercury/ints/hlc.par.gc/set_bbbtree.trans_opt
lib/mercury/ints/hlc.par.gc/set_ordlist.opt
lib/mercury/ints/hlc.par.gc/set_ordlist.trans_opt
lib/mercury/ints/hlc.par.gc/set_unordlist.opt
lib/mercury/ints/hlc.par.gc/set_unordlist.trans_opt
lib/mercury/ints/hlc.par.gc/sparse_bitset.opt
lib/mercury/ints/hlc.par.gc/sparse_bitset.trans_opt
lib/mercury/ints/hlc.par.gc/stack.opt
lib/mercury/ints/hlc.par.gc/stack.trans_opt
lib/mercury/ints/hlc.par.gc/std_util.opt
lib/mercury/ints/hlc.par.gc/std_util.trans_opt
lib/mercury/ints/hlc.par.gc/store.opt
lib/mercury/ints/hlc.par.gc/store.trans_opt
lib/mercury/ints/hlc.par.gc/string.opt
lib/mercury/ints/hlc.par.gc/string.trans_opt
lib/mercury/ints/hlc.par.gc/table_builtin.opt
lib/mercury/ints/hlc.par.gc/table_builtin.trans_opt
lib/mercury/ints/hlc.par.gc/term.opt
lib/mercury/ints/hlc.par.gc/term.trans_opt
lib/mercury/ints/hlc.par.gc/term_io.opt
lib/mercury/ints/hlc.par.gc/term_io.trans_opt
lib/mercury/ints/hlc.par.gc/time.opt
lib/mercury/ints/hlc.par.gc/time.trans_opt
lib/mercury/ints/hlc.par.gc/tree234.opt
lib/mercury/ints/hlc.par.gc/tree234.trans_opt
lib/mercury/ints/hlc.par.gc/type_desc.opt
lib/mercury/ints/hlc.par.gc/type_desc.trans_opt
lib/mercury/ints/hlc.par.gc/varset.opt
lib/mercury/ints/hlc.par.gc/varset.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
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 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
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
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
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
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
lib/mercury/ints/relation.int
lib/mercury/ints/relation.int2
lib/mercury/ints/relation.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/relation.mh
lib/mercury/ints/relation.mih
lib/mercury/ints/relation.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/relation.opt
lib/mercury/ints/relation.trans_opt
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 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
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
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
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
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
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
lib/mercury/ints/string.int
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
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
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 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
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
The host specific installation subdirectories are actually taken by configure from its --host argument, which is exactly ${MACHINE_GNU_PLATFORM}. Use that for the PLIST instead of ${MACHINE_ARCH}--${LOWER_OPSYS}, which may lack the "elf" suffix on certain platforms.
2002-03-18 08:58:35 +01:00
lib/mercury/lib/${MACHINE_GNU_PLATFORM}/libgc.a
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/lib/${MACHINE_GNU_PLATFORM}/libgc_prof.a
lib/mercury/lib/${MACHINE_GNU_PLATFORM}/libpar_gc.a
The host specific installation subdirectories are actually taken by configure from its --host argument, which is exactly ${MACHINE_GNU_PLATFORM}. Use that for the PLIST instead of ${MACHINE_ARCH}--${LOWER_OPSYS}, which may lack the "elf" suffix on certain platforms.
2002-03-18 08:58:35 +01:00
lib/mercury/lib/asm_fast.gc.memprof/${MACHINE_GNU_PLATFORM}/libmer_browser.a
lib/mercury/lib/asm_fast.gc.memprof/${MACHINE_GNU_PLATFORM}/libmer_rt.a
lib/mercury/lib/asm_fast.gc.memprof/${MACHINE_GNU_PLATFORM}/libmer_std.a
lib/mercury/lib/asm_fast.gc.memprof/${MACHINE_GNU_PLATFORM}/libmer_trace.a
lib/mercury/lib/asm_fast.gc.prof/${MACHINE_GNU_PLATFORM}/libmer_browser.a
lib/mercury/lib/asm_fast.gc.prof/${MACHINE_GNU_PLATFORM}/libmer_rt.a
lib/mercury/lib/asm_fast.gc.prof/${MACHINE_GNU_PLATFORM}/libmer_std.a
lib/mercury/lib/asm_fast.gc.prof/${MACHINE_GNU_PLATFORM}/libmer_trace.a
lib/mercury/lib/asm_fast.gc.tr.debug/${MACHINE_GNU_PLATFORM}/libmer_browser.a
lib/mercury/lib/asm_fast.gc.tr.debug/${MACHINE_GNU_PLATFORM}/libmer_rt.a
lib/mercury/lib/asm_fast.gc.tr.debug/${MACHINE_GNU_PLATFORM}/libmer_std.a
lib/mercury/lib/asm_fast.gc.tr.debug/${MACHINE_GNU_PLATFORM}/libmer_trace.a
lib/mercury/lib/asm_fast.gc.tr/${MACHINE_GNU_PLATFORM}/libmer_browser.a
lib/mercury/lib/asm_fast.gc.tr/${MACHINE_GNU_PLATFORM}/libmer_rt.a
lib/mercury/lib/asm_fast.gc.tr/${MACHINE_GNU_PLATFORM}/libmer_std.a
lib/mercury/lib/asm_fast.gc.tr/${MACHINE_GNU_PLATFORM}/libmer_trace.a
lib/mercury/lib/asm_fast.gc/${MACHINE_GNU_PLATFORM}/libmer_browser.a
lib/mercury/lib/asm_fast.gc/${MACHINE_GNU_PLATFORM}/libmer_rt.a
lib/mercury/lib/asm_fast.gc/${MACHINE_GNU_PLATFORM}/libmer_std.a
lib/mercury/lib/asm_fast.gc/${MACHINE_GNU_PLATFORM}/libmer_trace.a
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/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/array.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/assoc_list.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/bag.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/benchmarking.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/bimap.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/bintree.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/bintree_set.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/bitmap.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/bool.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/bt_array.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/builtin.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/char.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/construct.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/counter.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/deconstruct.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/dir.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/enum.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/eqvclass.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/exception.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/float.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/gc.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/getopt.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/graph.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/group.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/hash_table.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/int.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/integer.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/io.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/lexer.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/library.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/list.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/map.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/math.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/mer_std.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/multi_map.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/ops.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/parser.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/pprint.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/pqueue.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/private_builtin.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/profiling_builtin.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/prolog.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/queue.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/random.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/rational.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/rbtree.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/relation.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/require.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/rtti_implementation.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/set.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/set_bbbtree.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/set_ordlist.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/set_unordlist.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/sparse_bitset.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/stack.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/std_util.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/store.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/string.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/table_builtin.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/term.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/term_io.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/time.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/tree234.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/type_desc.mih
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/varset.mih
The host specific installation subdirectories are actually taken by configure from its --host argument, which is exactly ${MACHINE_GNU_PLATFORM}. Use that for the PLIST instead of ${MACHINE_ARCH}--${LOWER_OPSYS}, which may lack the "elf" suffix on certain platforms.
2002-03-18 08:58:35 +01:00
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/libmer_browser.a
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/libmer_rt.a
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/libmer_std.a
lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/libmer_trace.a
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/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/Mercury/mihs
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/array.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/assoc_list.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/bag.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/benchmarking.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/bimap.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/bintree.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/bintree_set.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/bitmap.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/bool.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/bt_array.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/builtin.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/char.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/construct.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/counter.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/deconstruct.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/dir.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/enum.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/eqvclass.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/exception.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/float.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/gc.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/getopt.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/graph.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/group.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/hash_table.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/int.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/integer.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/io.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/lexer.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/library.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/list.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/map.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/math.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/mer_std.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/multi_map.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/ops.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/parser.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/pprint.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/pqueue.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/private_builtin.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/profiling_builtin.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/prolog.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/queue.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/random.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/rational.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/rbtree.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/relation.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/require.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/rtti_implementation.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/set.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/set_bbbtree.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/set_ordlist.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/set_unordlist.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/sparse_bitset.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/stack.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/std_util.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/store.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/string.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/table_builtin.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/term.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/term_io.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/time.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/tree234.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/type_desc.mih
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/varset.mih
The host specific installation subdirectories are actually taken by configure from its --host argument, which is exactly ${MACHINE_GNU_PLATFORM}. Use that for the PLIST instead of ${MACHINE_ARCH}--${LOWER_OPSYS}, which may lack the "elf" suffix on certain platforms.
2002-03-18 08:58:35 +01:00
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/libmer_browser.a
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/libmer_rt.a
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/libmer_std.a
lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/libmer_trace.a
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/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/Mercury/mihs
lib/mercury/mdb/mdb_doc
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
lib/mercury/mmake/Mmake.rules
lib/mercury/mmake/Mmake.vars
lib/mercury/modules/mer_browser.init
lib/mercury/modules/mer_rt.init
lib/mercury/modules/mer_std.init
man/man1/c2init.1
man/man1/mdb.1
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/html/mercury/faq.html
share/doc/html/mercury/faq_toc.html
share/doc/html/mercury/library.html
share/doc/html/mercury/library_toc.html
share/doc/html/mercury/mercury.html
share/doc/html/mercury/reference_manual.html
share/doc/html/mercury/reference_manual_foot.html
share/doc/html/mercury/reference_manual_toc.html
share/doc/html/mercury/transition_guide.html
share/doc/html/mercury/transition_guide_toc.html
share/doc/html/mercury/user_guide.html
share/doc/html/mercury/user_guide_foot.html
share/doc/html/mercury/user_guide_toc.html
share/doc/mercury/faq.dvi
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
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
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
share/examples/mercury/c_interface/mercury_calls_cplusplus/cpp_main.c
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 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
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
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
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
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
share/examples/mercury/solutions/one_solution.m
share/examples/mercury/solutions/some_solutions.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
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
@dirrm share/examples/mercury/tests/toplevel
@dirrm share/examples/mercury/tests/solutions
@dirrm share/examples/mercury/tests/rot13
@dirrm share/examples/mercury/tests/muz
@dirrm share/examples/mercury/tests/diff
@dirrm share/examples/mercury/tests/c_interface/simpler_cplusplus_calls_mercury
@dirrm share/examples/mercury/tests/c_interface/simpler_c_calls_mercury
@dirrm share/examples/mercury/tests/c_interface/mercury_calls_fortran
@dirrm share/examples/mercury/tests/c_interface/mercury_calls_cplusplus
@dirrm share/examples/mercury/tests/c_interface/mercury_calls_c
@dirrm share/examples/mercury/tests/c_interface/cplusplus_calls_mercury
@dirrm share/examples/mercury/tests/c_interface/c_calls_mercury
@dirrm share/examples/mercury/tests/c_interface
@dirrm share/examples/mercury/tests
@dirrm share/examples/mercury/solutions
@dirrm share/examples/mercury/rot13
@dirrm share/examples/mercury/muz
@dirrm share/examples/mercury/diff
@dirrm share/examples/mercury/c_interface/simpler_cplusplus_calls_mercury
@dirrm share/examples/mercury/c_interface/simpler_c_calls_mercury
@dirrm share/examples/mercury/c_interface/mercury_calls_fortran
@dirrm share/examples/mercury/c_interface/mercury_calls_cplusplus
@dirrm share/examples/mercury/c_interface/mercury_calls_c
@dirrm share/examples/mercury/c_interface/cplusplus_calls_mercury
@dirrm share/examples/mercury/c_interface/c_calls_mercury
@dirrm share/examples/mercury/c_interface
@dirrm share/examples/mercury
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
@dirrm share/emacs/site-lisp/mercury
@unexec ${RMDIR} %D/share/emacs/site-lisp 2>/dev/null || ${TRUE}
@unexec ${RMDIR} %D/share/emacs 2>/dev/null || ${TRUE}
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
@dirrm share/doc/mercury
@dirrm share/doc/html/mercury
@dirrm lib/mercury/modules
@dirrm lib/mercury/mmake
@dirrm lib/mercury/mdb
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
@dirrm lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc/Mercury
@dirrm lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}/inc
@dirrm lib/mercury/lib/hlc.par.gc/${MACHINE_GNU_PLATFORM}
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
@dirrm lib/mercury/lib/hlc.par.gc
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
@dirrm lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc/Mercury
@dirrm lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}/inc
The host specific installation subdirectories are actually taken by configure from its --host argument, which is exactly ${MACHINE_GNU_PLATFORM}. Use that for the PLIST instead of ${MACHINE_ARCH}--${LOWER_OPSYS}, which may lack the "elf" suffix on certain platforms.
2002-03-18 08:58:35 +01:00
@dirrm lib/mercury/lib/hlc.gc/${MACHINE_GNU_PLATFORM}
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
@dirrm lib/mercury/lib/hlc.gc
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
@dirrm lib/mercury/lib/asm_fast.gc/${MACHINE_GNU_PLATFORM}/inc/Mercury
@dirrm lib/mercury/lib/asm_fast.gc/${MACHINE_GNU_PLATFORM}/inc
The host specific installation subdirectories are actually taken by configure from its --host argument, which is exactly ${MACHINE_GNU_PLATFORM}. Use that for the PLIST instead of ${MACHINE_ARCH}--${LOWER_OPSYS}, which may lack the "elf" suffix on certain platforms.
2002-03-18 08:58:35 +01:00
@dirrm lib/mercury/lib/asm_fast.gc/${MACHINE_GNU_PLATFORM}
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
@dirrm lib/mercury/lib/asm_fast.gc.tr/${MACHINE_GNU_PLATFORM}/inc/Mercury
@dirrm lib/mercury/lib/asm_fast.gc.tr/${MACHINE_GNU_PLATFORM}/inc
The host specific installation subdirectories are actually taken by configure from its --host argument, which is exactly ${MACHINE_GNU_PLATFORM}. Use that for the PLIST instead of ${MACHINE_ARCH}--${LOWER_OPSYS}, which may lack the "elf" suffix on certain platforms.
2002-03-18 08:58:35 +01:00
@dirrm lib/mercury/lib/asm_fast.gc.tr/${MACHINE_GNU_PLATFORM}
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
@dirrm lib/mercury/lib/asm_fast.gc.tr.debug/${MACHINE_GNU_PLATFORM}/inc/Mercury
@dirrm lib/mercury/lib/asm_fast.gc.tr.debug/${MACHINE_GNU_PLATFORM}/inc
The host specific installation subdirectories are actually taken by configure from its --host argument, which is exactly ${MACHINE_GNU_PLATFORM}. Use that for the PLIST instead of ${MACHINE_ARCH}--${LOWER_OPSYS}, which may lack the "elf" suffix on certain platforms.
2002-03-18 08:58:35 +01:00
@dirrm lib/mercury/lib/asm_fast.gc.tr.debug/${MACHINE_GNU_PLATFORM}
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
@dirrm lib/mercury/lib/asm_fast.gc.tr.debug
@dirrm lib/mercury/lib/asm_fast.gc.tr
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
@dirrm lib/mercury/lib/asm_fast.gc.prof/${MACHINE_GNU_PLATFORM}/inc/Mercury
@dirrm lib/mercury/lib/asm_fast.gc.prof/${MACHINE_GNU_PLATFORM}/inc
The host specific installation subdirectories are actually taken by configure from its --host argument, which is exactly ${MACHINE_GNU_PLATFORM}. Use that for the PLIST instead of ${MACHINE_ARCH}--${LOWER_OPSYS}, which may lack the "elf" suffix on certain platforms.
2002-03-18 08:58:35 +01:00
@dirrm lib/mercury/lib/asm_fast.gc.prof/${MACHINE_GNU_PLATFORM}
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
@dirrm lib/mercury/lib/asm_fast.gc.prof
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
@dirrm lib/mercury/lib/asm_fast.gc.memprof/${MACHINE_GNU_PLATFORM}/inc/Mercury
@dirrm lib/mercury/lib/asm_fast.gc.memprof/${MACHINE_GNU_PLATFORM}/inc
The host specific installation subdirectories are actually taken by configure from its --host argument, which is exactly ${MACHINE_GNU_PLATFORM}. Use that for the PLIST instead of ${MACHINE_ARCH}--${LOWER_OPSYS}, which may lack the "elf" suffix on certain platforms.
2002-03-18 08:58:35 +01:00
@dirrm lib/mercury/lib/asm_fast.gc.memprof/${MACHINE_GNU_PLATFORM}
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
@dirrm lib/mercury/lib/asm_fast.gc.memprof
@dirrm lib/mercury/lib/asm_fast.gc
The host specific installation subdirectories are actually taken by configure from its --host argument, which is exactly ${MACHINE_GNU_PLATFORM}. Use that for the PLIST instead of ${MACHINE_ARCH}--${LOWER_OPSYS}, which may lack the "elf" suffix on certain platforms.
2002-03-18 08:58:35 +01:00
@dirrm lib/mercury/lib/${MACHINE_GNU_PLATFORM}
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
@dirrm lib/mercury/lib
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
@dirrm lib/mercury/ints/hlc.par.gc/Mercury
@dirrm lib/mercury/ints/hlc.par.gc
@dirrm lib/mercury/ints/hlc.gc/Mercury
@dirrm lib/mercury/ints/hlc.gc
@dirrm lib/mercury/ints/asm_fast.gc/Mercury
@dirrm lib/mercury/ints/asm_fast.gc.tr/Mercury
@dirrm lib/mercury/ints/asm_fast.gc.tr.debug/Mercury
@dirrm lib/mercury/ints/asm_fast.gc.tr.debug
@dirrm lib/mercury/ints/asm_fast.gc.tr
@dirrm lib/mercury/ints/asm_fast.gc.prof/Mercury
@dirrm lib/mercury/ints/asm_fast.gc.prof
@dirrm lib/mercury/ints/asm_fast.gc.memprof/Mercury
@dirrm lib/mercury/ints/asm_fast.gc.memprof
@dirrm lib/mercury/ints/asm_fast.gc
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
@dirrm lib/mercury/ints/Mercury
@dirrm lib/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
@dirrm lib/mercury/inc/private
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
@dirrm lib/mercury/inc/machdeps
@dirrm lib/mercury/inc
The host specific installation subdirectories are actually taken by configure from its --host argument, which is exactly ${MACHINE_GNU_PLATFORM}. Use that for the PLIST instead of ${MACHINE_ARCH}--${LOWER_OPSYS}, which may lack the "elf" suffix on certain platforms.
2002-03-18 08:58:35 +01:00
@dirrm lib/mercury/bin/${MACHINE_GNU_PLATFORM}
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
@dirrm lib/mercury/bin
@dirrm lib/mercury
Reference in a new issue Copy permalink