[m-rev.] diff: post_typecheck and parallelism

Zoltan Somogyi zs at csse.unimelb.edu.au
Thu Oct 14 13:44:30 AEDT 2010
Previous message: [m-rev.] for review: C# exported proc arguments and documentation
Next message: [m-rev.] For post-commit review: Automatically parallelise non-atomic goals.
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]
Allow the post-typecheck pass to be done in parallel on different predicates.

compiler/post_typecheck.m:
	Make the change described above.

	Make the post_typecheck_finish_preds predicate do what its name says
	by moving the code to find missing type definitions to a different
	predicate.

	Improve the interface of post_typecheck_finish_preds with its caller.

	Inline a predicate in its caller where this improves the clarity
	of the code.

compiler/mercury_compile_front_end.m:
	Conform to the change above.

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/mercury_compile_front_end.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/mercury_compile_front_end.m,v
retrieving revision 1.5
diff -u -b -r1.5 mercury_compile_front_end.m
--- compiler/mercury_compile_front_end.m	5 Aug 2010 03:07:08 -0000	1.5
+++ compiler/mercury_compile_front_end.m	13 Oct 2010 06:29:17 -0000
@@ -248,29 +248,47 @@
         !:FoundError = yes,
         io.set_exit_status(1, !IO)
     ;
-        % Only report error messages for unbound type variables if we didn't
-        % get any type errors already; this avoids a lot of spurious
-        % diagnostics.
-        PostTypeCheckReportErrors = bool.not(FoundTypeError),
-        module_info_get_valid_predids(PredIds, !HLDS),
-        post_typecheck_finish_preds(PredIds, PostTypeCheckReportErrors,
-            NumPostTypeCheckErrors, !HLDS, !Specs),
+        check_for_missing_type_defns(!.HLDS, MissingTypeDefnSpecs),
+        !:Specs = !.Specs ++ MissingTypeDefnSpecs,
+        SomeMissingTypeDefns = contains_errors(Globals, MissingTypeDefnSpecs),
+
+        post_typecheck_finish_preds(!HLDS, NumPostTypeCheckErrors,
+            PostTypeCheckAlwaysSpecs, PostTypeCheckNoTypeErrorSpecs),
+        % If the main part of typecheck detected some errors, then some of
+        % the errors we detect during post-typecheck could be avalanche
+        % messages. We get post_typecheck to put all such messages into
+        % PostTypeCheckNoTypeErrorSpecs, and we report them only if did not
+        % find any errors during typecheck.
+        (
+            FoundTypeError = no,
+            PostTypeCheckSpecs = PostTypeCheckAlwaysSpecs
+                ++ PostTypeCheckNoTypeErrorSpecs,
+            !:Specs = !.Specs ++ PostTypeCheckSpecs
+        ;
+            FoundTypeError = yes,
+            !:Specs = !.Specs ++ PostTypeCheckAlwaysSpecs
+        ),
+        (
+            ( SomeMissingTypeDefns = yes
+            ; NumPostTypeCheckErrors > 0
+            )
+        ->
+            PostTypeCheckErrors = yes
+        ;
+            PostTypeCheckErrors = no
+        ),
         maybe_dump_hlds(!.HLDS, 19, "post_typecheck", !DumpInfo, !IO),
 
         % Stop here if `--typecheck-only' was specified.
         globals.lookup_bool_option(Globals, typecheck_only, TypecheckOnly),
         (
             TypecheckOnly = yes,
-            ( NumPostTypeCheckErrors > 0 ->
-                !:FoundError = yes
-            ;
-                true
-            )
+            !:FoundError = bool.or(!.FoundError, PostTypeCheckErrors)
         ;
             TypecheckOnly = no,
             (
                 ( FoundTypeError = yes
-                ; NumPostTypeCheckErrors > 0
+                ; PostTypeCheckErrors = yes
                 )
             ->
                 % XXX It would be nice if we could go on and mode-check the
Index: compiler/post_typecheck.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/post_typecheck.m,v
retrieving revision 1.139
diff -u -b -r1.139 post_typecheck.m
--- compiler/post_typecheck.m	4 Nov 2009 03:44:50 -0000	1.139
+++ compiler/post_typecheck.m	13 Oct 2010 06:27:15 -0000
@@ -46,31 +46,47 @@
 :- import_module parse_tree.error_util.
 :- import_module parse_tree.prog_data.
 
-:- import_module bool.
 :- import_module list.
 
 %-----------------------------------------------------------------------------%
 
-    % post_typecheck_finish_preds(PredIds, ReportTypeErrors, NumErrors,
-    %   !ModuleInfo, !Specs):
+    % Check that every abstract type in the module has at least one definition
+    % in either the interface or implementation of the module.
     %
-    % Check that the all of the types which have been inferred for the
-    % variables in the clause do not contain any unbound type variables
-    % other than those that occur in the types of head variables, and that
-    % there are no unsatisfied type class constraints, and if
-    % ReportErrors = yes, return the appropriate warning/error messages.
-    % Also bind any unbound type variables to the type `void'. Note that
-    % when checking assertions we take the conservative approach of warning
-    % about unbound type variables. There may be cases for which this doesn't
-    % make sense. NumErrors will be nonzero if there were errors which
-    % should prevent further processing (e.g. polymorphism or mode analysis).
+    % Note that a type may have several definitions, e.g. some foreign
+    % definitions and a default Mercury definition.
     %
-:- pred post_typecheck_finish_preds(list(pred_id)::in, bool::in, int::out,
-    module_info::in, module_info::out,
-    list(error_spec)::in, list(error_spec)::out) is det.
+:- pred check_for_missing_type_defns(module_info::in, list(error_spec)::out)
+    is det.
+
+    % post_typecheck_finish_preds(!ModuleInfo, NumErrors,
+    %   AlwaysSpecs, NoTypeErrorSpecs):
+    %
+    % Check that the types of variables in predicates contain no unbound type
+    % variables other than those that occur in the types of the predicate's
+    % head variables, and that there are no unsatisfied type class constraints.
+    % Also bind any unbound type variables to the type `void'.
+    %
+    % Return two lists of error messages. AlwaysSpecs will be the messages
+    % we want to print in all cases, and NoTypeErrorSpecs will be the messages
+    % we want to print only if type checking did not find any errors. The
+    % latter will be the kinds of errors that you can get as "avalanche"
+    % messages from type errors.
+    %
+    % Separately, we return NumBadErrors, the number of errors that prevent us
+    % from proceeding further in compilation. We do this separately since some
+    % errors (e.g. bad type for main) do NOT prevent us from going further.
+    %
+    % Note that when checking assertions we take the conservative approach
+    % of warning about unbound type variables. There may be cases for which
+    % this doesn't make sense.
+    %
+:- pred post_typecheck_finish_preds(module_info::in, module_info::out,
+    int::out, list(error_spec)::out, list(error_spec)::out) is det.
 
     % As above, but return the list of procedures containing unbound inst
     % variables instead of reporting the errors directly.
+    % XXX This is incredibly misleading.
     %
 :- pred post_typecheck_finish_pred_no_io(module_info::in, list(proc_id)::out,
     pred_info::in, pred_info::out) is det.
@@ -130,6 +146,7 @@
 :- import_module parse_tree.prog_util.
 
 :- import_module assoc_list.
+:- import_module bool.
 :- import_module int.
 :- import_module map.
 :- import_module maybe.
@@ -137,6 +154,7 @@
 :- import_module set.
 :- import_module solutions.
 :- import_module string.
+:- import_module set_tree234.
 :- import_module svmap.
 :- import_module svvarset.
 :- import_module term_io.
@@ -144,69 +162,79 @@
 
 %-----------------------------------------------------------------------------%
 
-post_typecheck_finish_preds(PredIds, ReportTypeErrors, NumErrors,
-        !ModuleInfo, !Specs) :-
-    post_typecheck_do_finish_preds(PredIds, ReportTypeErrors, !ModuleInfo,
-        0, TotalNumUnsatisfiedConstraints, !Specs),
-    check_for_missing_definitions(!.ModuleInfo, [], MissingTypeDefnSpecs),
-    NumMissingTypeDefns = list.length(MissingTypeDefnSpecs),
-    NumErrors = TotalNumUnsatisfiedConstraints + NumMissingTypeDefns,
-    !:Specs = !.Specs ++ MissingTypeDefnSpecs.
-
-:- pred post_typecheck_do_finish_preds(list(pred_id)::in, bool::in,
-    module_info::in, module_info::out, int::in, int::out,
-    list(error_spec)::in, list(error_spec)::out) is det.
-
-post_typecheck_do_finish_preds([], _,
-        !ModuleInfo, !TotalNumUnsatisfiedConstraints, !Specs).
-post_typecheck_do_finish_preds([PredId | PredIds], ReportTypeErrors,
-        !ModuleInfo, !TotalNumUnsatisfiedConstraints, !Specs) :-
-    post_typecheck_do_finish_pred(PredId, ReportTypeErrors,
-        !ModuleInfo, !TotalNumUnsatisfiedConstraints, !Specs),
-    post_typecheck_do_finish_preds(PredIds, ReportTypeErrors,
-        !ModuleInfo, !TotalNumUnsatisfiedConstraints, !Specs).
+post_typecheck_finish_preds(!ModuleInfo, NumBadErrors,
+        AlwaysSpecs, NoTypeErrorSpecs) :-
+    module_info_get_valid_predids(ValidPredIds, !ModuleInfo),
+    ValidPredIdSet = set_tree234.list_to_set(ValidPredIds),
+    module_info_get_preds(!.ModuleInfo, PredMap0),
+    map.to_assoc_list(PredMap0, PredIdsInfos0),
+    post_typecheck_do_finish_preds(!.ModuleInfo, ValidPredIdSet,
+        PredIdsInfos0, PredIdsInfos, NumBadErrors,
+        AlwaysSpecsList, NoTypeErrorSpecsList),
+    list.condense(AlwaysSpecsList, AlwaysSpecs),
+    list.condense(NoTypeErrorSpecsList, NoTypeErrorSpecs),
+    map.from_sorted_assoc_list(PredIdsInfos, PredMap),
+    module_info_set_preds(PredMap, !ModuleInfo).
+
+:- pred post_typecheck_do_finish_preds(module_info::in,
+    set_tree234(pred_id)::in,
+    assoc_list(pred_id, pred_info)::in, assoc_list(pred_id, pred_info)::out,
+    int::out, list(list(error_spec))::out, list(list(error_spec))::out) is det.
+
+post_typecheck_do_finish_preds(_, _, [], [], 0, [], []).
+post_typecheck_do_finish_preds(ModuleInfo, ValidPredIdSet,
+        [PredIdInfo0 | PredIdsInfos0], [PredIdInfo | PredIdsInfos],
+        NumBadErrors, [HeadAlwaysSpecs | TailAlwaysSpecs],
+        [HeadNoTypeErrorSpecs | TailNoTypeErrorSpecs]) :-
+    PredIdInfo0 = PredId - PredInfo0,
+    ( set_tree234.member(ValidPredIdSet, PredId) ->
+        post_typecheck_do_finish_pred(ModuleInfo, PredId, PredInfo0, PredInfo,
+            HeadNumBadErrors, HeadAlwaysSpecs, HeadNoTypeErrorSpecs)
+    ;
+        PredInfo = PredInfo0,
+        HeadNumBadErrors = 0,
+        HeadAlwaysSpecs = [],
+        HeadNoTypeErrorSpecs = []
+    ),
+    PredIdInfo = PredId - PredInfo,
+    post_typecheck_do_finish_preds(ModuleInfo, ValidPredIdSet,
+        PredIdsInfos0, PredIdsInfos, TailNumBadErrors,
+        TailAlwaysSpecs, TailNoTypeErrorSpecs),
+    NumBadErrors = HeadNumBadErrors + TailNumBadErrors.
+
+:- pred post_typecheck_do_finish_pred(module_info::in,
+    pred_id::in, pred_info::in, pred_info::out, int::out,
+    list(error_spec)::out, list(error_spec)::out) is det.
 
-:- pred post_typecheck_do_finish_pred(pred_id::in, bool::in,
-    module_info::in, module_info::out, int::in, int::out,
-    list(error_spec)::in, list(error_spec)::out) is det.
-
-post_typecheck_do_finish_pred(PredId, ReportTypeErrors, !ModuleInfo,
-        !TotalNumUnsatisfiedConstraints, !Specs) :-
-    some [!PredInfo] (
-        module_info_pred_info(!.ModuleInfo, PredId, !:PredInfo),
+post_typecheck_do_finish_pred(ModuleInfo, PredId, !PredInfo, NumBadErrors,
+        !:AlwaysSpecs, !:NoTypeErrorSpecs) :-
         (
             ( pred_info_is_imported(!.PredInfo)
             ; pred_info_is_pseudo_imported(!.PredInfo)
             )
         ->
-            post_typecheck_finish_imported_pred(!.ModuleInfo, PredId,
-                !PredInfo, !Specs)
+        % For imported preds, we just need to ensure that all constructors
+        % occurring in predicate mode declarations are module qualified.
+        post_typecheck_finish_imported_pred_no_io(ModuleInfo, ErrorProcs,
+            !PredInfo),
+        report_unbound_inst_vars(ModuleInfo, PredId, ErrorProcs, !PredInfo,
+            [], !:AlwaysSpecs),
+        check_for_indistinguishable_modes(ModuleInfo, PredId, !PredInfo,
+            !AlwaysSpecs),
+        !:NoTypeErrorSpecs = [],
+        NumBadErrors = 0
         ;
-            % Only report error messages for unbound type variables
-            % if we didn't get any type errors already; this avoids
-            % a lot of spurious diagnostics.
-            check_pred_type_bindings(!.ModuleInfo, PredId, !PredInfo,
-                ReportTypeErrors, NumUnsatisfiedConstraints, !Specs),
+        check_pred_type_bindings(ModuleInfo, PredId, !PredInfo,
+            NumBadErrors, !:NoTypeErrorSpecs),
 
-            post_typecheck_finish_pred_no_io(!.ModuleInfo, ErrorProcs,
-                !PredInfo),
-            report_unbound_inst_vars(!.ModuleInfo, PredId, ErrorProcs,
-                !PredInfo, !Specs),
-            check_for_indistinguishable_modes(!.ModuleInfo, PredId,
-                !PredInfo, !Specs),
+        post_typecheck_finish_pred_no_io(ModuleInfo, ErrorProcs, !PredInfo),
+        report_unbound_inst_vars(ModuleInfo, PredId, ErrorProcs, !PredInfo,
+            [], !:AlwaysSpecs),
+        check_for_indistinguishable_modes(ModuleInfo, PredId, !PredInfo,
+            !AlwaysSpecs),
 
             % Check that main/2 has the right type.
-            (
-                ReportTypeErrors = yes,
-                check_type_of_main(!.PredInfo, !Specs)
-            ;
-                ReportTypeErrors = no
-            ),
-
-            !:TotalNumUnsatisfiedConstraints =
-                !.TotalNumUnsatisfiedConstraints + NumUnsatisfiedConstraints
-        ),
-        module_info_set_pred_info(PredId, !.PredInfo, !ModuleInfo)
+        check_type_of_main(!.PredInfo, !AlwaysSpecs)
     ).
 
 %-----------------------------------------------------------------------------%
@@ -217,23 +245,21 @@
     % there are no unsatisfied type class constraints.
     %
 :- pred check_pred_type_bindings(module_info::in, pred_id::in,
-    pred_info::in, pred_info::out, bool::in, int::out,
-    list(error_spec)::in, list(error_spec)::out) is det.
+    pred_info::in, pred_info::out, int::out, list(error_spec)::out) is det.
 
-check_pred_type_bindings(ModuleInfo, PredId, !PredInfo, ReportErrs, NumErrors,
-        !Specs) :-
+check_pred_type_bindings(ModuleInfo, PredId, !PredInfo, NumBadErrors,
+        !:NoTypeErrorSpecs) :-
+    pred_info_get_unproven_body_constraints(!.PredInfo, UnprovenConstraints0),
+    !:NoTypeErrorSpecs = [],
     (
-        ReportErrs = yes,
-        pred_info_get_unproven_body_constraints(!.PredInfo,
-            UnprovenConstraints0),
-        UnprovenConstraints0 = [_ | _]
-    ->
+        UnprovenConstraints0 = [_ | _],
         list.sort_and_remove_dups(UnprovenConstraints0, UnprovenConstraints),
         report_unsatisfied_constraints(ModuleInfo, PredId, !.PredInfo,
-            UnprovenConstraints, !Specs),
-        list.length(UnprovenConstraints, NumErrors)
+            UnprovenConstraints, !NoTypeErrorSpecs),
+        list.length(UnprovenConstraints, NumBadErrors)
     ;
-        NumErrors = 0
+        UnprovenConstraints0 = [],
+        NumBadErrors = 0
     ),
 
     pred_info_get_clauses_info(!.PredInfo, ClausesInfo0),
@@ -248,18 +274,8 @@
         UnresolvedVarsTypes = []
     ;
         UnresolvedVarsTypes = [_ | _],
-        module_info_get_globals(ModuleInfo, Globals),
-        globals.lookup_bool_option(Globals, warn_unresolved_polymorphism,
-            WarnUnresolvedPolymorphism),
-        (
-            ReportErrs = yes,
-            WarnUnresolvedPolymorphism = yes
-        ->
             report_unresolved_type_warning(ModuleInfo, PredId, !.PredInfo,
-                VarSet, UnresolvedVarsTypes, !Specs)
-        ;
-            true
-        ),
+            VarSet, UnresolvedVarsTypes, !NoTypeErrorSpecs),
 
         % Bind all the type variables in `Set' to `void' ...
         pred_info_get_constraint_proofs(!.PredInfo, Proofs0),
@@ -512,8 +528,11 @@
         words("but I'm afraid you'll have to work it out yourself."),
         words("My apologies.)")],
     Msg = simple_msg(Context,
-        [always(MainPieces), verbose_only(VerbosePieces)]),
-    Spec = error_spec(severity_warning, phase_type_check, [Msg]),
+        [option_is_set(warn_unresolved_polymorphism, yes,
+            [always(MainPieces), verbose_only(VerbosePieces)])]),
+    Severity = severity_conditional(warn_unresolved_polymorphism, yes,
+        severity_warning, no),
+    Spec = error_spec(Severity, phase_type_check, [Msg]),
     !:Specs = [Spec | !.Specs].
 
 :- func var_and_type_to_pieces(prog_varset, tvarset,
@@ -559,22 +578,6 @@
 post_typecheck_finish_pred_no_io(ModuleInfo, ErrorProcs, !PredInfo) :-
     propagate_types_into_modes(ModuleInfo, ErrorProcs, !PredInfo).
 
-    % For imported preds, we just need to ensure that all constructors
-    % occurring in predicate mode declarations are module qualified.
-    %
-:- pred post_typecheck_finish_imported_pred(module_info::in, pred_id::in,
-    pred_info::in, pred_info::out,
-    list(error_spec)::in, list(error_spec)::out) is det.
-
-post_typecheck_finish_imported_pred(ModuleInfo, PredId, !PredInfo, !Specs) :-
-    % XXX Maybe the rest should be replaced with a call to
-    % finish_ill_typed_pred? [zs]
-    post_typecheck_finish_imported_pred_no_io(ModuleInfo, ErrorProcs,
-        !PredInfo),
-    report_unbound_inst_vars(ModuleInfo, PredId, ErrorProcs, !PredInfo,
-        !Specs),
-    check_for_indistinguishable_modes(ModuleInfo, PredId, !PredInfo, !Specs).
-
 post_typecheck_finish_imported_pred_no_io(ModuleInfo, ErrorProcIds,
         !PredInfo) :-
     % Make sure the vartypes field in the clauses_info is valid for imported
@@ -1603,23 +1606,15 @@
 
 %-----------------------------------------------------------------------------%
 
-    % Check that every abstract type in a module has at least one definition
-    % in either the interface or implementation of the module.  A type may
-    % have several definitions, e.g. some foreign definitions and a default
-    % Mercury definition.
-    %
-:- pred check_for_missing_definitions(module_info::in,
-    list(error_spec)::in, list(error_spec)::out) is det.
-
-check_for_missing_definitions(ModuleInfo, !Specs) :-
+check_for_missing_type_defns(ModuleInfo, Specs) :-
     module_info_get_type_table(ModuleInfo, TypeTable),
-    foldl_over_type_ctor_defns(check_for_missing_definitions_2, TypeTable,
-        !Specs).
+    foldl_over_type_ctor_defns(check_for_missing_type_defns_2, TypeTable,
+        [], Specs).
 
-:- pred check_for_missing_definitions_2(type_ctor::in, hlds_type_defn::in,
+:- pred check_for_missing_type_defns_2(type_ctor::in, hlds_type_defn::in,
     list(error_spec)::in, list(error_spec)::out) is det.
 
-check_for_missing_definitions_2(TypeCtor, TypeDefn, !Specs) :-
+check_for_missing_type_defns_2(TypeCtor, TypeDefn, !Specs) :-
     (
         get_type_defn_status(TypeDefn, ImportStatus),
         status_defined_in_this_module(ImportStatus) = yes,
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/concurrency
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_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 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/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/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/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/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
--------------------------------------------------------------------------
Previous message: [m-rev.] for review: C# exported proc arguments and documentation
Next message: [m-rev.] For post-commit review: Automatically parallelise non-atomic goals.
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]
More information about the reviews mailing list