[m-rev.] diff: factoring out sym name parsing

Zoltan Somogyi zs at unimelb.edu.au
Thu Apr 5 19:20:19 AEST 2012


compiler/prog_io_sym_name.m:
	Factor out some code that is common to several tests in a chain
	of if-then-elses.

	Provide a predicate to parse a term without having to first
	construct it.

compiler/prog_io_util.m:
	Factor out some code that is common to several tests in a chain
	of if-then-elses.

	Use the new predicate added to prog_io_sym_name where possible.

Zoltan.

cvs diff: Diffing .
cvs diff: Diffing analysis
cvs diff: Diffing bindist
cvs diff: Diffing boehm_gc
cvs diff: Diffing boehm_gc/Mac_files
cvs diff: Diffing boehm_gc/cord
cvs diff: Diffing boehm_gc/cord/private
cvs diff: Diffing boehm_gc/doc
cvs diff: Diffing boehm_gc/extra
cvs diff: Diffing boehm_gc/include
cvs diff: Diffing boehm_gc/include/extra
cvs diff: Diffing boehm_gc/include/private
cvs diff: Diffing boehm_gc/libatomic_ops
cvs diff: Diffing boehm_gc/libatomic_ops/doc
cvs diff: Diffing boehm_gc/libatomic_ops/src
cvs diff: Diffing boehm_gc/libatomic_ops/src/atomic_ops
cvs diff: Diffing boehm_gc/libatomic_ops/src/atomic_ops/sysdeps
cvs diff: Diffing boehm_gc/libatomic_ops/src/atomic_ops/sysdeps/armcc
cvs diff: Diffing boehm_gc/libatomic_ops/src/atomic_ops/sysdeps/gcc
cvs diff: Diffing boehm_gc/libatomic_ops/src/atomic_ops/sysdeps/hpc
cvs diff: Diffing boehm_gc/libatomic_ops/src/atomic_ops/sysdeps/ibmc
cvs diff: Diffing boehm_gc/libatomic_ops/src/atomic_ops/sysdeps/icc
cvs diff: Diffing boehm_gc/libatomic_ops/src/atomic_ops/sysdeps/msftc
cvs diff: Diffing boehm_gc/libatomic_ops/src/atomic_ops/sysdeps/sunc
cvs diff: Diffing boehm_gc/libatomic_ops/tests
cvs diff: Diffing boehm_gc/libatomic_ops-1.2
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/doc
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops/sysdeps
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/tests
cvs diff: Diffing boehm_gc/m4
cvs diff: Diffing boehm_gc/tests
cvs diff: Diffing browser
cvs diff: Diffing bytecode
cvs diff: Diffing compiler
Index: compiler/prog_io_sym_name.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/prog_io_sym_name.m,v
retrieving revision 1.4
diff -u -b -r1.4 prog_io_sym_name.m
--- compiler/prog_io_sym_name.m	23 May 2011 05:08:10 -0000	1.4
+++ compiler/prog_io_sym_name.m	5 Apr 2012 07:45:02 -0000
@@ -61,6 +61,15 @@
 :- pred try_parse_sym_name_and_no_args(term(T)::in, sym_name::out)
     is semidet.
 
+    % When given the first two argumeents Functor and FunctorArgs,
+    % try_parse_sym_name_and_args_from_f_args will do does exactly the same as
+    % what try_parse_sym_name_and_args would do when given the term
+    % term.functor(Functor, FunctorArgs, _), but it does so without
+    % requiring its caller to construct that term.
+    %
+:- pred try_parse_sym_name_and_args_from_f_args(const::in, list(term(T))::in,
+    sym_name::out, list(term(T))::out) is semidet.
+
     % parse_implicitly_qualified_sym_name_and_args(ModuleName, Term,
     %   VarSet, ContextPieces, Result):
     %
@@ -177,31 +186,39 @@
     ).
 
 try_parse_sym_name_and_args(Term, SymName, Args) :-
-    (
         Term = term.functor(Functor, FunctorArgs, _TermContext),
-        Functor = term.atom("."),
+    try_parse_sym_name_and_args_from_f_args(Functor, FunctorArgs,
+        SymName, Args).
+
+:- pragma inline(try_parse_sym_name_and_args_from_f_args/4).
+
+try_parse_sym_name_and_args_from_f_args(Functor, FunctorArgs, SymName, Args) :-
+    Functor = term.atom(FunctorName),
+    (
+        FunctorName = ".",
         FunctorArgs = [ModuleTerm, NameArgsTerm]
     ->
         NameArgsTerm = term.functor(term.atom(Name), Args, _),
         try_parse_symbol_name(ModuleTerm, Module),
         SymName = qualified(Module, Name)
     ;
-        Term = term.functor(term.atom(Name), Args, _),
-        SymName = string_to_sym_name_sep(Name, "__")
+        SymName = string_to_sym_name_sep(FunctorName, "__"),
+        Args = FunctorArgs
     ).
 
 try_parse_sym_name_and_no_args(Term, SymName) :-
-    (
         Term = term.functor(Functor, FunctorArgs, _TermContext),
-        Functor = term.atom("."),
+    Functor = term.atom(FunctorName),
+    (
+        FunctorName = ".",
         FunctorArgs = [ModuleTerm, NameArgsTerm]
     ->
         NameArgsTerm = term.functor(term.atom(Name), [], _),
         try_parse_symbol_name(ModuleTerm, Module),
         SymName = qualified(Module, Name)
     ;
-        Term = term.functor(term.atom(Name), [], _),
-        SymName = string_to_sym_name_sep(Name, "__")
+        FunctorArgs = [],
+        SymName = string_to_sym_name_sep(FunctorName, "__")
     ).
 
 %-----------------------------------------------------------------------------e
Index: compiler/prog_io_util.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/prog_io_util.m,v
retrieving revision 1.73
diff -u -b -r1.73 prog_io_util.m
--- compiler/prog_io_util.m	13 Feb 2012 00:11:46 -0000	1.73
+++ compiler/prog_io_util.m	5 Apr 2012 07:45:02 -0000
@@ -522,8 +522,10 @@
     convert_mode_list(AllowConstrainedInstVar, T0, T).
 
 convert_mode(AllowConstrainedInstVar, Term, Mode) :-
+    Term = term.functor(TermFunctor, TermArgs, _),
     (
-        Term = term.functor(term.atom(">>"), [InstTermA, InstTermB], _)
+        TermFunctor = term.atom(">>"),
+        TermArgs = [InstTermA, InstTermB]
     ->
         convert_inst(AllowConstrainedInstVar, InstTermA, InstA),
         convert_inst(AllowConstrainedInstVar, InstTermB, InstB),
@@ -537,7 +539,8 @@
         %   -> pred(<Mode1>, <Mode2>, ...) is <Det>
         %   )
 
-        Term = term.functor(term.atom("is"), [PredTerm, DetTerm], _),
+        TermFunctor = term.atom("is"),
+        TermArgs = [PredTerm, DetTerm],
         PredTerm = term.functor(term.atom("pred"), ArgModesTerms, _)
     ->
         DetTerm = term.functor(term.atom(DetString), [], _),
@@ -556,7 +559,8 @@
         %   -> func(<Mode1>, <Mode2>, ...) = <RetMode> is <Det>
         %   )
 
-        Term = term.functor(term.atom("is"), [EqTerm, DetTerm], _),
+        TermFunctor = term.atom("is"),
+        TermArgs = [EqTerm, DetTerm],
         EqTerm = term.functor(term.atom("="), [FuncTerm, RetModeTerm], _),
         FuncTerm = term.functor(term.atom("func"), ArgModesTerms, _)
     ->
@@ -578,7 +582,8 @@
         %   -> any_pred(<Mode1>, <Mode2>, ...) is <Det>
         %   )
 
-        Term = term.functor(term.atom("is"), [PredTerm, DetTerm], _),
+        TermFunctor = term.atom("is"),
+        TermArgs = [PredTerm, DetTerm],
         PredTerm = term.functor(term.atom("any_pred"), ArgModesTerms, _)
     ->
         DetTerm = term.functor(term.atom(DetString), [], _),
@@ -597,7 +602,8 @@
         %   -> any_func(<Mode1>, <Mode2>, ...) = <RetMode> is <Det>
         %   )
 
-        Term = term.functor(term.atom("is"), [EqTerm, DetTerm], _),
+        TermFunctor = term.atom("is"),
+        TermArgs = [EqTerm, DetTerm],
         EqTerm = term.functor(term.atom("="), [FuncTerm, RetModeTerm], _),
         FuncTerm = term.functor(term.atom("any_func"), ArgModesTerms, _)
     ->
@@ -613,7 +619,8 @@
     ;
         % If the sym_name_and_args fails, we should report the error
         % (we would need to call parse_qualified_term instead).
-        try_parse_sym_name_and_args(Term, Name, Args),
+        try_parse_sym_name_and_args_from_f_args(TermFunctor, TermArgs,
+            Name, Args),
         convert_inst_list(AllowConstrainedInstVar, Args, ConvertedArgs),
         Mode = user_defined_mode(Name, ConvertedArgs)
     ).
@@ -626,7 +633,8 @@
 convert_inst(_, term.variable(V0, _), inst_var(V)) :-
     term.coerce_var(V0, V).
 convert_inst(AllowConstrainedInstVar, Term, Result) :-
-    Term = term.functor(term.atom(Name), Args0, _Context),
+    Term = term.functor(Functor, Args0, _Context),
+    Functor = term.atom(Name),
     (
         convert_simple_builtin_inst(Name, Args0, Result0)
     ->
@@ -639,7 +647,8 @@
         % where <Mode1>, <Mode2>, ... are a list of modes,
         % and <Detism> is a determinism.
 
-        Name = "is", Args0 = [PredTerm, DetTerm],
+        Name = "is",
+        Args0 = [PredTerm, DetTerm],
         PredTerm = term.functor(term.atom("pred"), ArgModesTerm, _)
     ->
         DetTerm = term.functor(term.atom(DetString), [], _),
@@ -656,7 +665,8 @@
         % where <Mode1>, <Mode2>, ... are a list of modes,
         % <RetMode> is a mode, and <Detism> is a determinism.
 
-        Name = "is", Args0 = [EqTerm, DetTerm],
+        Name = "is",
+        Args0 = [EqTerm, DetTerm],
         EqTerm = term.functor(term.atom("="), [FuncTerm, RetModeTerm], _),
         FuncTerm = term.functor(term.atom("func"), ArgModesTerm, _)
     ->
@@ -676,7 +686,8 @@
         % where <Mode1>, <Mode2>, ... are a list of modes,
         % and <Detism> is a determinism.
 
-        Name = "is", Args0 = [PredTerm, DetTerm],
+        Name = "is",
+        Args0 = [PredTerm, DetTerm],
         PredTerm = term.functor(term.atom("any_pred"), ArgModesTerm, _)
     ->
         DetTerm = term.functor(term.atom(DetString), [], _),
@@ -693,7 +704,8 @@
         % where <Mode1>, <Mode2>, ... are a list of modes,
         % <RetMode> is a mode, and <Detism> is a determinism.
 
-        Name = "is", Args0 = [EqTerm, DetTerm],
+        Name = "is",
+        Args0 = [EqTerm, DetTerm],
         EqTerm = term.functor(term.atom("="), [FuncTerm, RetModeTerm], _),
         FuncTerm = term.functor(term.atom("any_func"), ArgModesTerm, _)
     ->
@@ -706,18 +718,33 @@
             arg_reg_types_unset, Detism),
         Result = any(shared, higher_order(FuncInst))
 
-    ; Name = "bound", Args0 = [Disj] ->
+    ;
+        Name = "bound",
+        Args0 = [Disj]
+    ->
         % `bound' insts
         parse_bound_inst_list(AllowConstrainedInstVar, Disj, shared, Result)
-    ; Name = "bound_unique", Args0 = [Disj] ->
+    ;
+        Name = "bound_unique",
+        Args0 = [Disj]
+    ->
         % `bound_unique' is for backwards compatibility - use `unique' instead.
         parse_bound_inst_list(AllowConstrainedInstVar, Disj, unique, Result)
-    ; Name = "unique", Args0 = [Disj] ->
+    ;
+        Name = "unique",
+        Args0 = [Disj]
+    ->
         parse_bound_inst_list(AllowConstrainedInstVar, Disj, unique, Result)
-    ; Name = "mostly_unique", Args0 = [Disj] ->
+    ;
+        Name = "mostly_unique",
+        Args0 = [Disj]
+    ->
         parse_bound_inst_list(AllowConstrainedInstVar, Disj, mostly_unique,
             Result)
-    ; Name = "=<", Args0 = [VarTerm, InstTerm] ->
+    ;
+        Name = "=<",
+        Args0 = [VarTerm, InstTerm]
+    ->
         AllowConstrainedInstVar = allow_constrained_inst_var,
         VarTerm = term.variable(Var, _),
         % Do not allow nested constrained_inst_vars.
@@ -726,7 +753,8 @@
             term.coerce_var(Var)), Inst)
     ;
         % Anything else must be a user-defined inst.
-        try_parse_sym_name_and_args(Term, QualifiedName, Args1),
+        try_parse_sym_name_and_args_from_f_args(Functor, Args0,
+            QualifiedName, Args1),
         (
             BuiltinModule = mercury_public_builtin_module,
             sym_name_get_module_name_default(QualifiedName, unqualified(""),
@@ -823,7 +851,8 @@
     InstTerm = term.functor(Functor, Args0, _),
     (
         Functor = term.atom(_),
-        try_parse_sym_name_and_args(InstTerm, SymName, Args1),
+        try_parse_sym_name_and_args_from_f_args(Functor, Args0,
+            SymName, Args1),
         list.length(Args1, Arity),
         ConsId = cons(SymName, Arity, cons_id_dummy_type_ctor)
     ;
cvs diff: Diffing compiler/notes
cvs diff: Diffing deep_profiler
cvs diff: Diffing deep_profiler/notes
cvs diff: Diffing doc
cvs diff: Diffing extras
cvs diff: Diffing extras/base64
cvs diff: Diffing extras/cgi
cvs diff: Diffing extras/complex_numbers
cvs diff: Diffing extras/complex_numbers/samples
cvs diff: Diffing extras/complex_numbers/tests
cvs diff: Diffing extras/curs
cvs diff: Diffing extras/curs/samples
cvs diff: Diffing extras/curses
cvs diff: Diffing extras/curses/sample
cvs diff: Diffing extras/dynamic_linking
cvs diff: Diffing extras/error
cvs diff: Diffing extras/fixed
cvs diff: Diffing extras/gator
cvs diff: Diffing extras/gator/generations
cvs diff: Diffing extras/gator/generations/1
cvs diff: Diffing extras/graphics
cvs diff: Diffing extras/graphics/easyx
cvs diff: Diffing extras/graphics/easyx/samples
cvs diff: Diffing extras/graphics/mercury_allegro
cvs diff: Diffing extras/graphics/mercury_allegro/examples
cvs diff: Diffing extras/graphics/mercury_allegro/samples
cvs diff: Diffing extras/graphics/mercury_allegro/samples/demo
cvs diff: Diffing extras/graphics/mercury_allegro/samples/mandel
cvs diff: Diffing extras/graphics/mercury_allegro/samples/pendulum2
cvs diff: Diffing extras/graphics/mercury_allegro/samples/speed
cvs diff: Diffing extras/graphics/mercury_cairo
cvs diff: Diffing extras/graphics/mercury_cairo/samples
cvs diff: Diffing extras/graphics/mercury_cairo/samples/data
cvs diff: Diffing extras/graphics/mercury_cairo/tutorial
cvs diff: Diffing extras/graphics/mercury_glfw
cvs diff: Diffing extras/graphics/mercury_glfw/samples
cvs diff: Diffing extras/graphics/mercury_glut
cvs diff: Diffing extras/graphics/mercury_opengl
cvs diff: Diffing extras/graphics/mercury_tcltk
cvs diff: Diffing extras/graphics/samples
cvs diff: Diffing extras/graphics/samples/calc
cvs diff: Diffing extras/graphics/samples/gears
cvs diff: Diffing extras/graphics/samples/maze
cvs diff: Diffing extras/graphics/samples/pent
cvs diff: Diffing extras/lazy_evaluation
cvs diff: Diffing extras/lex
cvs diff: Diffing extras/lex/samples
cvs diff: Diffing extras/lex/tests
cvs diff: Diffing extras/log4m
cvs diff: Diffing extras/logged_output
cvs diff: Diffing extras/monte
cvs diff: Diffing extras/moose
cvs diff: Diffing extras/moose/samples
cvs diff: Diffing extras/moose/tests
cvs diff: Diffing extras/mopenssl
cvs diff: Diffing extras/morphine
cvs diff: Diffing extras/morphine/non-regression-tests
cvs diff: Diffing extras/morphine/scripts
cvs diff: Diffing extras/morphine/source
cvs diff: Diffing extras/net
cvs diff: Diffing extras/odbc
cvs diff: Diffing extras/posix
cvs diff: Diffing extras/posix/samples
cvs diff: Diffing extras/quickcheck
cvs diff: Diffing extras/quickcheck/tutes
cvs diff: Diffing extras/references
cvs diff: Diffing extras/references/samples
cvs diff: Diffing extras/references/tests
cvs diff: Diffing extras/solver_types
cvs diff: Diffing extras/solver_types/library
cvs diff: Diffing extras/trailed_update
cvs diff: Diffing extras/trailed_update/samples
cvs diff: Diffing extras/trailed_update/tests
cvs diff: Diffing extras/windows_installer_generator
cvs diff: Diffing extras/windows_installer_generator/sample
cvs diff: Diffing extras/windows_installer_generator/sample/images
cvs diff: Diffing extras/xml
cvs diff: Diffing extras/xml/samples
cvs diff: Diffing extras/xml_stylesheets
cvs diff: Diffing java
cvs diff: Diffing java/runtime
cvs diff: Diffing library
cvs diff: Diffing m4
cvs diff: Diffing mdbcomp
cvs diff: Diffing profiler
cvs diff: Diffing robdd
cvs diff: Diffing runtime
cvs diff: Diffing runtime/GETOPT
cvs diff: Diffing runtime/machdeps
cvs diff: Diffing samples
cvs diff: Diffing samples/appengine
cvs diff: Diffing samples/appengine/war
cvs diff: Diffing samples/appengine/war/WEB-INF
cvs diff: Diffing samples/c_interface
cvs diff: Diffing samples/c_interface/c_calls_mercury
cvs diff: Diffing samples/c_interface/cplusplus_calls_mercury
cvs diff: Diffing samples/c_interface/mercury_calls_c
cvs diff: Diffing samples/c_interface/mercury_calls_cplusplus
cvs diff: Diffing samples/c_interface/mercury_calls_fortran
cvs diff: Diffing samples/c_interface/simpler_c_calls_mercury
cvs diff: Diffing samples/c_interface/simpler_cplusplus_calls_mercury
cvs diff: Diffing samples/c_interface/standalone_c
cvs diff: Diffing samples/concurrency
cvs diff: Diffing samples/concurrency/dining_philosophers
cvs diff: Diffing samples/concurrency/midimon
cvs diff: Diffing samples/diff
cvs diff: Diffing samples/java_interface
cvs diff: Diffing samples/java_interface/java_calls_mercury
cvs diff: Diffing samples/java_interface/mercury_calls_java
cvs diff: Diffing samples/lazy_list
cvs diff: Diffing samples/muz
cvs diff: Diffing samples/rot13
cvs diff: Diffing samples/solutions
cvs diff: Diffing samples/solver_types
cvs diff: Diffing samples/tests
cvs diff: Diffing samples/tests/c_interface
cvs diff: Diffing samples/tests/c_interface/c_calls_mercury
cvs diff: Diffing samples/tests/c_interface/cplusplus_calls_mercury
cvs diff: Diffing samples/tests/c_interface/mercury_calls_c
cvs diff: Diffing samples/tests/c_interface/mercury_calls_cplusplus
cvs diff: Diffing samples/tests/c_interface/mercury_calls_fortran
cvs diff: Diffing samples/tests/c_interface/simpler_c_calls_mercury
cvs diff: Diffing samples/tests/c_interface/simpler_cplusplus_calls_mercury
cvs diff: Diffing samples/tests/diff
cvs diff: Diffing samples/tests/muz
cvs diff: Diffing samples/tests/rot13
cvs diff: Diffing samples/tests/solutions
cvs diff: Diffing samples/tests/toplevel
cvs diff: Diffing scripts
cvs diff: Diffing slice
cvs diff: Diffing ssdb
cvs diff: Diffing tests
cvs diff: Diffing tests/analysis
cvs diff: Diffing tests/analysis/ctgc
cvs diff: Diffing tests/analysis/excp
cvs diff: Diffing tests/analysis/ext
cvs diff: Diffing tests/analysis/sharing
cvs diff: Diffing tests/analysis/table
cvs diff: Diffing tests/analysis/trail
cvs diff: Diffing tests/analysis/unused_args
cvs diff: Diffing tests/benchmarks
cvs diff: Diffing tests/debugger
cvs diff: Diffing tests/debugger/declarative
cvs diff: Diffing tests/dppd
cvs diff: Diffing tests/feedback
cvs diff: Diffing tests/feedback/mandelbrot
cvs diff: Diffing tests/feedback/mmc
cvs diff: Diffing tests/general
cvs diff: Diffing tests/general/accumulator
cvs diff: Diffing tests/general/string_format
cvs diff: Diffing tests/general/structure_reuse
cvs diff: Diffing tests/grade_subdirs
cvs diff: Diffing tests/hard_coded
cvs diff: Diffing tests/hard_coded/exceptions
cvs diff: Diffing tests/hard_coded/purity
cvs diff: Diffing tests/hard_coded/sub-modules
cvs diff: Diffing tests/hard_coded/typeclasses
cvs diff: Diffing tests/invalid
cvs diff: Diffing tests/invalid/purity
cvs diff: Diffing tests/misc_tests
cvs diff: Diffing tests/mmc_make
cvs diff: Diffing tests/mmc_make/lib
cvs diff: Diffing tests/par_conj
cvs diff: Diffing tests/recompilation
cvs diff: Diffing tests/stm
cvs diff: Diffing tests/stm/orig
cvs diff: Diffing tests/stm/orig/stm-compiler
cvs diff: Diffing tests/stm/orig/stm-compiler/test1
cvs diff: Diffing tests/stm/orig/stm-compiler/test10
cvs diff: Diffing tests/stm/orig/stm-compiler/test2
cvs diff: Diffing tests/stm/orig/stm-compiler/test3
cvs diff: Diffing tests/stm/orig/stm-compiler/test4
cvs diff: Diffing tests/stm/orig/stm-compiler/test5
cvs diff: Diffing tests/stm/orig/stm-compiler/test6
cvs diff: Diffing tests/stm/orig/stm-compiler/test7
cvs diff: Diffing tests/stm/orig/stm-compiler/test8
cvs diff: Diffing tests/stm/orig/stm-compiler/test9
cvs diff: Diffing tests/stm/orig/stm-compiler-par
cvs diff: Diffing tests/stm/orig/stm-compiler-par/bm1
cvs diff: Diffing tests/stm/orig/stm-compiler-par/bm2
cvs diff: Diffing tests/stm/orig/stm-compiler-par/stmqueue
cvs diff: Diffing tests/stm/orig/stm-compiler-par/test1
cvs diff: Diffing tests/stm/orig/stm-compiler-par/test10
cvs diff: Diffing tests/stm/orig/stm-compiler-par/test11
cvs diff: Diffing tests/stm/orig/stm-compiler-par/test2
cvs diff: Diffing tests/stm/orig/stm-compiler-par/test3
cvs diff: Diffing tests/stm/orig/stm-compiler-par/test4
cvs diff: Diffing tests/stm/orig/stm-compiler-par/test5
cvs diff: Diffing tests/stm/orig/stm-compiler-par/test6
cvs diff: Diffing tests/stm/orig/stm-compiler-par/test7
cvs diff: Diffing tests/stm/orig/stm-compiler-par/test8
cvs diff: Diffing tests/stm/orig/stm-compiler-par/test9
cvs diff: Diffing tests/stm/orig/stm-compiler-par-asm_fast
cvs diff: Diffing tests/stm/orig/stm-compiler-par-asm_fast/test1
cvs diff: Diffing tests/stm/orig/stm-compiler-par-asm_fast/test2
cvs diff: Diffing tests/stm/orig/stm-compiler-par-asm_fast/test3
cvs diff: Diffing tests/stm/orig/stm-compiler-par-asm_fast/test4
cvs diff: Diffing tests/stm/orig/stm-compiler-par-asm_fast/test5
cvs diff: Diffing tests/stm/orig/stm-compiler-par-asm_fast/test6
cvs diff: Diffing tests/stm/orig/stm-compiler-par-asm_fast/test7
cvs diff: Diffing tests/stm/orig/stm-compiler-par-asm_fast/test8
cvs diff: Diffing tests/stm/orig/stm-compiler-par-asm_fast/test9
cvs diff: Diffing tests/tabling
cvs diff: Diffing tests/term
cvs diff: Diffing tests/trailing
cvs diff: Diffing tests/valid
cvs diff: Diffing tests/warnings
cvs diff: Diffing tools
cvs diff: Diffing trace
cvs diff: Diffing util
cvs diff: Diffing vim
cvs diff: Diffing vim/after
cvs diff: Diffing vim/ftplugin
cvs diff: Diffing vim/syntax
--------------------------------------------------------------------------
mercury-reviews mailing list
Post messages to:       mercury-reviews at csse.unimelb.edu.au
Administrative Queries: owner-mercury-reviews at csse.unimelb.edu.au
Subscriptions:          mercury-reviews-request at csse.unimelb.edu.au
--------------------------------------------------------------------------



More information about the reviews mailing list