[m-rev.] diff: post_typecheck stack limit

Zoltan Somogyi zs at csse.unimelb.edu.au
Tue Dec 19 14:05:34 AEDT 2006
Previous message: [m-rev.] diff: instmap.m speedup
Next message: [m-rev.] diff: switch handling optimization
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]
compiler/post_typecheck.m:
	Limit stack consumption in debug grades when processing very long lists
	of variables.

	This reduces the time to compile training_cars_full.m from 250 seconds
	to 240.

	Rename some predicates to avoid ambiguities.

compiler/purity.m:
compiler/unify_proc.m:
	Conform to the change to post_typecheck.m.

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/include
cvs diff: Diffing boehm_gc/include/private
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/src/atomic_ops/sysdeps/gcc
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops/sysdeps/hpc
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops/sysdeps/ibmc
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops/sysdeps/icc
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops/sysdeps/msftc
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops/sysdeps/sunc
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/tests
cvs diff: Diffing boehm_gc/tests
cvs diff: Diffing boehm_gc/windows-untested
cvs diff: Diffing boehm_gc/windows-untested/vc60
cvs diff: Diffing boehm_gc/windows-untested/vc70
cvs diff: Diffing boehm_gc/windows-untested/vc71
cvs diff: Diffing browser
cvs diff: Diffing bytecode
cvs diff: Diffing compiler
Index: compiler/post_typecheck.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/post_typecheck.m,v
retrieving revision 1.112
diff -u -b -r1.112 post_typecheck.m
--- compiler/post_typecheck.m	6 Nov 2006 07:55:12 -0000	1.112
+++ compiler/post_typecheck.m	16 Dec 2006 09:16:14 -0000
@@ -5,11 +5,11 @@
 % This file may only be copied under the terms of the GNU General
 % Public License - see the file COPYING in the Mercury distribution.
 %-----------------------------------------------------------------------------%
-
+%
 % File      : post_typecheck.m
 % Author    : fjh
 % Purpose   : finish off type checking.
-
+%
 % This module does the final parts of type analysis:
 %
 %   - it resolves predicate overloading
@@ -51,7 +51,8 @@
 
 %-----------------------------------------------------------------------------%
 
-    % finish_preds(PredIds, ReportTypeErrors, NumErrors, !ModuleInfo, !Specs):
+    % post_typecheck_finish_preds(PredIds, ReportTypeErrors, NumErrors,
+    %   !ModuleInfo, !Specs):
     %
     % Check that the all of the types which have been inferred for the
     % variables in the clause do not contain any unbound type variables
@@ -64,27 +65,27 @@
     % make sense. NumErrors will be nonzero if there were errors which
     % should prevent further processing (e.g. polymorphism or mode analysis).
     %
-:- pred finish_preds(list(pred_id)::in, bool::in, int::out,
+:- 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.
 
     % As above, but return the list of procedures containing unbound inst
     % variables instead of reporting the errors directly.
     %
-:- pred finish_pred_no_io(module_info::in, list(proc_id)::out,
+:- pred post_typecheck_finish_pred_no_io(module_info::in, list(proc_id)::out,
     pred_info::in, pred_info::out) is det.
 
-:- pred finish_imported_pred_no_io(module_info::in,
+:- pred post_typecheck_finish_imported_pred_no_io(module_info::in,
     list(proc_id)::out, pred_info::in, pred_info::out) is det.
 
-:- pred finish_ill_typed_pred(module_info::in, pred_id::in,
+:- pred post_typecheck_finish_ill_typed_pred(module_info::in, pred_id::in,
     pred_info::in, pred_info::out,
     list(error_spec)::in, list(error_spec)::out) is det.
 
     % Now that the assertion has finished being typechecked, remove it
     % from further processing and store it in the assertion_table.
     %
-:- pred finish_promise(promise_type::in, pred_id::in,
+:- pred post_typecheck_finish_promise(promise_type::in, pred_id::in,
     module_info::in, module_info::out,
     list(error_spec)::in, list(error_spec)::out) is det.
 
@@ -142,23 +143,34 @@
 
 %-----------------------------------------------------------------------------%
 
-finish_preds(PredIds, ReportTypeErrors, NumErrors, !ModuleInfo, !Specs) :-
-    do_finish_preds(PredIds, ReportTypeErrors, !ModuleInfo,
+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),
+    check_for_missing_definitions(!.ModuleInfo, [], MissingTypeDefnSpecs),
     NumMissingTypeDefns = list.length(MissingTypeDefnSpecs),
     NumErrors = TotalNumUnsatisfiedConstraints + NumMissingTypeDefns,
     !:Specs = !.Specs ++ MissingTypeDefnSpecs.
 
-:- pred do_finish_preds(list(pred_id)::in, bool::in,
+:- 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.
 
-do_finish_preds([], _, !ModuleInfo, !TotalNumUnsatisfiedConstraints, !Specs).
-do_finish_preds([PredId | PredIds], ReportTypeErrors, !ModuleInfo,
-!TotalNumUnsatisfiedConstraints,
-        !Specs) :-
+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).
+
+:- 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),
         (
@@ -166,15 +178,17 @@
             ; pred_info_is_pseudo_imported(!.PredInfo)
             )
         ->
-            finish_imported_pred(!.ModuleInfo, PredId, !PredInfo, !Specs)
+            post_typecheck_finish_imported_pred(!.ModuleInfo, PredId,
+                !PredInfo, !Specs)
         ;
             % 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_type_bindings(!.ModuleInfo, PredId, !PredInfo,
+            check_pred_type_bindings(!.ModuleInfo, PredId, !PredInfo,
                 ReportTypeErrors, NumUnsatisfiedConstraints, !Specs),
 
-            finish_pred_no_io(!.ModuleInfo, ErrorProcs, !PredInfo),
+            post_typecheck_finish_pred_no_io(!.ModuleInfo, ErrorProcs,
+                !PredInfo),
             report_unbound_inst_vars(!.ModuleInfo, PredId, ErrorProcs,
                 !PredInfo, !Specs),
             check_for_indistinguishable_modes(!.ModuleInfo, PredId,
@@ -192,21 +206,20 @@
                 !.TotalNumUnsatisfiedConstraints + NumUnsatisfiedConstraints
         ),
         module_info_set_pred_info(PredId, !.PredInfo, !ModuleInfo)
-    ),
-    do_finish_preds(PredIds, ReportTypeErrors, !ModuleInfo,
-        !TotalNumUnsatisfiedConstraints, !Specs). 
+    ).
+
 %-----------------------------------------------------------------------------%
 
     % Check that the all of the types which have been inferred for the
-    % variables in the clause do not contain any unbound type variables
+    % variables in the predicate 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.
     %
-:- pred check_type_bindings(module_info::in, pred_id::in,
+:- 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.
 
-check_type_bindings(ModuleInfo, PredId, !PredInfo, ReportErrs, NumErrors,
+check_pred_type_bindings(ModuleInfo, PredId, !PredInfo, ReportErrs, NumErrors,
         !Specs) :-
     (
         ReportErrs = yes,
@@ -228,7 +241,7 @@
     clauses_info_get_vartypes(ClausesInfo0, VarTypesMap0),
     map.to_assoc_list(VarTypesMap0, VarTypesList),
     set.init(Set0),
-    check_type_bindings_2(VarTypesList, HeadTypeParams,
+    check_var_type_bindings(VarTypesList, HeadTypeParams,
         [], UnresolvedVarsTypes, Set0, Set),
     (
         UnresolvedVarsTypes = []
@@ -253,14 +266,38 @@
         pred_info_set_constraint_map(ConstraintMap, !PredInfo)
     ).
 
-:- pred check_type_bindings_2(assoc_list(prog_var, mer_type)::in,
+    % The number of variables can be huge here (hundred of thousands for
+    % Doug Auclair's training_cars program). The code below prevents stack
+    % overflows in grades that do not permit tail recursion.
+    %
+:- pred check_var_type_bindings(assoc_list(prog_var, mer_type)::in,
     list(tvar)::in,
     assoc_list(prog_var, mer_type)::in, assoc_list(prog_var, mer_type)::out,
     set(tvar)::in, set(tvar)::out) is det.
 
-check_type_bindings_2([], _, !UnresolvedVarsTypes, !Set).
-check_type_bindings_2([Var - Type | VarTypes], HeadTypeParams,
-        !UnresolvedVarsTypes, !Set) :-
+check_var_type_bindings(VarTypes, HeadTypeParams, !UnresolvedVarsTypes,
+        !Set) :-
+    check_var_type_bindings_2(VarTypes, HeadTypeParams, 1000, LeftOverVarTypes,
+        !UnresolvedVarsTypes, !Set),
+    (
+        LeftOverVarTypes = []
+    ;
+        LeftOverVarTypes = [_ | _],
+        check_var_type_bindings(LeftOverVarTypes, HeadTypeParams,
+            !UnresolvedVarsTypes, !Set)
+    ).
+
+:- pred check_var_type_bindings_2(assoc_list(prog_var, mer_type)::in,
+    list(tvar)::in, int::in, assoc_list(prog_var, mer_type)::out,
+    assoc_list(prog_var, mer_type)::in, assoc_list(prog_var, mer_type)::out,
+    set(tvar)::in, set(tvar)::out) is det.
+
+check_var_type_bindings_2([], _, _, [], !UnresolvedVarsTypes, !Set).
+check_var_type_bindings_2([Var - Type | VarTypes], HeadTypeParams,
+        VarsToDo, LeftOverVarTypes, !UnresolvedVarsTypes, !Set) :-
+    ( VarsToDo < 0 ->
+        LeftOverVarTypes = [Var - Type | VarTypes]
+    ;
     type_vars(Type, TVars),
     set.list_to_set(TVars, TVarsSet0),
     set.delete_list(TVarsSet0, HeadTypeParams, TVarsSet1),
@@ -270,8 +307,9 @@
     ;
         true
     ),
-    check_type_bindings_2(VarTypes, HeadTypeParams,
-        !UnresolvedVarsTypes, !Set).
+        check_var_type_bindings_2(VarTypes, HeadTypeParams,
+            VarsToDo - 1, LeftOverVarTypes, !UnresolvedVarsTypes, !Set)
+    ).
 
     % Bind all the type variables in `UnboundTypeVarsSet' to the type `void'.
     %
@@ -405,14 +443,14 @@
 
 %-----------------------------------------------------------------------------%
 
-finish_pred_no_io(ModuleInfo, ErrorProcs, !PredInfo) :-
+post_typecheck_finish_pred_no_io(ModuleInfo, ErrorProcs, !PredInfo) :-
     propagate_types_into_modes(ModuleInfo, ErrorProcs, !PredInfo).
 
     % For ill-typed preds, we just need to set the modes up correctly
     % so that any calls to that pred from correctly-typed predicates
     % won't result in spurious mode errors.
     %
-finish_ill_typed_pred(ModuleInfo, PredId, !PredInfo, !Specs) :-
+post_typecheck_finish_ill_typed_pred(ModuleInfo, PredId, !PredInfo, !Specs) :-
     propagate_types_into_modes(ModuleInfo, ErrorProcs, !PredInfo),
     report_unbound_inst_vars(ModuleInfo, PredId, ErrorProcs, !PredInfo,
         !Specs),
@@ -421,19 +459,21 @@
     % For imported preds, we just need to ensure that all constructors
     % occurring in predicate mode declarations are module qualified.
     %
-:- pred finish_imported_pred(module_info::in, pred_id::in,
+:- 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.
 
-finish_imported_pred(ModuleInfo, PredId, !PredInfo, !Specs) :-
+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]
-    finish_imported_pred_no_io(ModuleInfo, ErrorProcs, !PredInfo),
+    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).
 
-finish_imported_pred_no_io(ModuleInfo, ErrorProcIds, !PredInfo) :-
+post_typecheck_finish_imported_pred_no_io(ModuleInfo, ErrorProcIds,
+        !PredInfo) :-
     % Make sure the var-types field in the clauses_info is valid for imported
     % predicates. Unification procedures have clauses generated, so they
     % already have valid var-types.
@@ -449,6 +489,7 @@
     ),
     propagate_types_into_modes(ModuleInfo, ErrorProcIds, !PredInfo).
 
+post_typecheck_finish_promise(PromiseType, PromiseId, !ModuleInfo, !Specs) :-
     % Now that the promise has finished being typechecked, and has had all
     % of its pred_ids identified, remove the promise from the list of pred ids
     % to be processed in the future and place the pred_id associated with the
@@ -458,8 +499,7 @@
     % predicate that is used in an assertion which assertion it is used in,
     % or for a promise ex declaration record in the promise ex table
     % the predicates used by the declaration.
-    %
-finish_promise(PromiseType, PromiseId, !ModuleInfo, !Specs) :-
+
     % Store the declaration in the appropriate table and get the goal
     % for the promise.
     store_promise(PromiseType, PromiseId, !ModuleInfo, Goal),
@@ -926,8 +966,7 @@
         pred_info_get_markers(!.PredInfo, Markers),
         module_info_get_predicate_table(ModuleInfo, PredTable),
         predicate_table_search_func_sym_arity(PredTable,
-            calls_are_fully_qualified(Markers),
-            PredName, Arity, PredIds),
+            calls_are_fully_qualified(Markers), PredName, Arity, PredIds),
 
         % Check if any of the candidate functions have argument/return types
         % which subsume the actual argument/return types of this function call,
@@ -937,8 +976,8 @@
         list.append(ArgTypes0, [TypeOfX], ArgTypes),
         pred_info_get_constraint_map(!.PredInfo, ConstraintMap),
         goal_info_get_goal_path(GoalInfo0, GoalPath),
-        ConstraintSearch = search_hlds_constraint_list(ConstraintMap, unproven,
-            GoalPath),
+        ConstraintSearch =
+            search_hlds_constraint_list(ConstraintMap, unproven, GoalPath),
         find_matching_pred_id(ModuleInfo, PredIds, TVarSet, ArgTypes,
             yes(ConstraintSearch), PredId, QualifiedFuncName)
     ->
@@ -1241,8 +1280,7 @@
         apply_rec_subst_to_type_list(ExistTSubst, ParentArgTypes,
             ActualArgTypes0),
 
-            % The kinds will be ignored when the types are converted back
-            % to tvars.
+        % The kinds will be ignored when the types are converted back to tvars.
         map.init(KindMap),
         apply_rec_subst_to_tvar_list(KindMap, ExistTSubst, ParentExistQVars,
             ActualExistQVarTypes),
@@ -1340,8 +1378,8 @@
         ConsId, FieldNumber) :-
     Ctor = ctor(_, _, SymName, CtorArgs, _Ctxt),
     (
-        get_constructor_containing_field_3(CtorArgs,
-            FieldName, 1, FieldNumber0)
+        get_constructor_containing_field_3(CtorArgs, FieldName,
+            1, FieldNumber0)
     ->
         list.length(CtorArgs, Arity),
         ConsId = cons(SymName, Arity),
Index: compiler/purity.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/purity.m,v
retrieving revision 1.108
diff -u -b -r1.108 purity.m
--- compiler/purity.m	6 Nov 2006 07:55:12 -0000	1.108
+++ compiler/purity.m	16 Dec 2006 09:16:14 -0000
@@ -223,7 +223,7 @@
     % Only report error messages for unbound type variables if we didn't get
     % any type errors already; this avoids a lot of spurious diagnostics.
     ReportTypeErrors = bool.not(FoundTypeError),
-    post_typecheck.finish_preds(PredIds, ReportTypeErrors, NumPostErrors,
+    post_typecheck_finish_preds(PredIds, ReportTypeErrors, NumPostErrors,
         !ModuleInfo, !Specs),
     ( NumPostErrors > 0 ->
         PostTypecheckError = yes
@@ -258,7 +258,7 @@
     % Finish processing of promise declarations.
     pred_info_get_goal_type(PredInfo, GoalType),
     ( GoalType = goal_type_promise(PromiseType) ->
-        post_typecheck.finish_promise(PromiseType, PredId, !ModuleInfo, !Specs)
+        post_typecheck_finish_promise(PromiseType, PredId, !ModuleInfo, !Specs)
     ;
         true
     ),
Index: compiler/unify_proc.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/unify_proc.m,v
retrieving revision 1.179
diff -u -b -r1.179 unify_proc.m
--- compiler/unify_proc.m	1 Dec 2006 15:04:27 -0000	1.179
+++ compiler/unify_proc.m	16 Dec 2006 09:17:29 -0000
@@ -584,11 +584,11 @@
     % so just go on to post_typecheck.
     (
         Item = clauses,
-        post_typecheck.finish_pred_no_io(!.ModuleInfo,
+        post_typecheck_finish_pred_no_io(!.ModuleInfo,
             ErrorProcs, PredInfo0, PredInfo)
     ;
         Item = declaration,
-        post_typecheck.finish_imported_pred_no_io(!.ModuleInfo,
+        post_typecheck_finish_imported_pred_no_io(!.ModuleInfo,
             ErrorProcs,  PredInfo0, PredInfo)
     ),
     expect(unify(ErrorProcs, []), this_file,
cvs diff: Diffing compiler/notes
cvs diff: Diffing debian
cvs diff: Diffing debian/patches
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_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/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/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/stream
cvs diff: Diffing extras/stream/tests
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/diff
cvs diff: Diffing samples/muz
cvs diff: Diffing samples/rot13
cvs diff: Diffing samples/solutions
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 tests
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/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.] diff: instmap.m speedup
Next message: [m-rev.] diff: switch handling optimization
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]
More information about the reviews mailing list