[m-rev.] for review: doc/*.texi: typographical changes for printed output

Peter Moulder pmoulder at csse.monash.edu.au
Fri Aug 2 16:44:34 AEST 2002


Some of these diffs touch the copyright year lines, we might as well update
the years in the same commit.  What counts as a "significant change" for
copyright purposes?  E.g. is the list of years of CVS commits a good
enough approximation?

pjm.


Estimated hours taken: 1

Typographical changes for printed output.
Very little change made to the produced info files.

doc/faq.texi:
doc/library.texi:
doc/reference_manual.texi
doc/transition_guide.texi
doc/user_guide.texi
	Change en dashes to --, em dashes to ---, minus sign as @minus{}.
	 (Rendered as -,--,- respectively in info.)
	Use @: after `e.g.', `i.e.', etc. to indicate word space rather than
	 sentence space.
	Change `...' to `@dots{}'.
	Change " to `` or '' (other than in code).  (Rendered as " in info.)

Index: faq.texi
===================================================================
RCS file: /home/mercury1/repository/mercury/doc/faq.texi,v
retrieving revision 1.25
diff -d -u -r1.25 faq.texi
--- faq.texi	3 Oct 2001 11:37:51 -0000	1.25
+++ faq.texi	2 Aug 2002 05:12:17 -0000
@@ -55,7 +55,7 @@
 @author Zoltan Somogyi
 @page
 @vskip 0pt plus 1filll
-Copyright @copyright{} 1995-1997 The University of Melbourne.
+Copyright @copyright{} 1995--1997 The University of Melbourne.
 
 Permission is granted to make and distribute verbatim copies of
 this FAQ list provided the copyright notice and this permission notice
@@ -192,7 +192,7 @@
 @sp 1
 
 If you are using @samp{mmake} to recompile your program, and you are
-overriding the default grade (e.g. by setting @samp{GRADE=asm_fast} in your
+overriding the default grade (e.g.@: by setting @samp{GRADE=asm_fast} in your
 @samp{Mmake} file), you must make sure that you do @samp{mmake clean} every
 time you change grades.
 
Index: library.texi
===================================================================
RCS file: /home/mercury1/repository/mercury/doc/library.texi,v
retrieving revision 1.18
diff -d -u -r1.18 library.texi
--- library.texi	3 Oct 2001 11:37:51 -0000	1.18
+++ library.texi	2 Aug 2002 05:12:17 -0000
@@ -45,7 +45,7 @@
 @c @author Zoltan Somogyi
 @page
 @vskip 0pt plus 1filll
-Copyright @copyright{} 1995-1997 The University of Melbourne.
+Copyright @copyright{} 1995--1997 The University of Melbourne.
 
 Permission is granted to make and distribute verbatim copies of
 this manual provided the copyright notice and this permission notice
Index: reference_manual.texi
===================================================================
RCS file: /home/mercury1/repository/mercury/doc/reference_manual.texi,v
retrieving revision 1.253
diff -d -u -r1.253 reference_manual.texi
--- reference_manual.texi	26 Jul 2002 06:33:16 -0000	1.253
+++ reference_manual.texi	2 Aug 2002 05:12:18 -0000
@@ -54,7 +54,7 @@
 @author Ralph Becket
 @page
 @vskip 0pt plus 1filll
-Copyright @copyright{} 1995-2001 The University of Melbourne.
+Copyright @copyright{} 1995--2001 The University of Melbourne.
 
 Permission is granted to make and distribute verbatim copies of
 this manual provided the copyright notice and this permission notice
@@ -298,7 +298,7 @@
 A right curly bracket, @samp{@}}.
 
 @item ht_sep
-A ``head-tail separator'', i.e. a vertical bar, @samp{|}.
+A ``head-tail separator'', i.e.@: a vertical bar, @samp{|}.
 
 @item comma
 A comma, @samp{,}.
@@ -334,14 +334,14 @@
 an operator term, or a parenthesized term.
 
 A simple compound term is a name followed without any intervening
-whitespace by an open parenthesis (i.e. an open_ct token),
+whitespace by an open parenthesis (i.e.@: an open_ct token),
 a sequence of argument terms separated by commas, and a close
 parenthesis.  
 
-A list term is an open square bracket (i.e. an open_list token)
+A list term is an open square bracket (i.e.@: an open_list token)
 followed by a sequence of argument terms separated by commas,
-optionally followed by a vertical bar (i.e. a close_list token)
-followed by a term, followed by a close square bracket (i.e. a
+optionally followed by a vertical bar (i.e.@: a close_list token)
+followed by a term, followed by a close square bracket (i.e.@: a
 close_list token).  An empty list term is an open_list token
 followed by a close_list token.  List terms are parsed as follows:
 @example
@@ -361,7 +361,7 @@
 '[|]'(1, '[|]'(2, '[|]'(3, [])))
 @end example
 
-A tuple term is a left curly bracket (i.e. an open_curly token)
+A tuple term is a left curly bracket (i.e.@: an open_curly token)
 followed by a sequence of argument terms separated by commas,
 and a right curly bracket.  For example, @code{@{1, '2', "three"@}}
 is a valid tuple term.
@@ -380,7 +380,7 @@
 
 A higher-order term is a ``closure'' term, which can be any term 
 other than a name or an operator term, followed without
-any intervening whitespace by an open parenthesis (i.e. an open_ct token), 
+any intervening whitespace by an open parenthesis (i.e.@: an open_ct token), 
 a sequence of argument terms separated by commas, and a close
 parenthesis.  A higher-order term is equivalent to a simple compound term
 whose functor is the empty name, and whose arguments are the 
@@ -678,9 +678,9 @@
 but the operational semantics are different, and it is treated
 differently for the purposes of determinism inference (@pxref{Determinism}).
 Operationally, it executes the @var{CondGoal}, and if that succeeds, then
-execution continues with the @var{ThenGoal}; otherwise, i.e. if @var{CondGoal}
+execution continues with the @var{ThenGoal}; otherwise, i.e.@: if @var{CondGoal}
 fails, it executes the @var{ElseGoal}.  Note that @var{CondGoal} can be
-nondeterministic -- unlike Prolog, Mercury's if-then-else does not commit
+nondeterministic --- unlike Prolog, Mercury's if-then-else does not commit
 to the first solution of the condition if the condition succeeds.
 
 @item @code{@var{Term1} = @var{Term2}}
@@ -712,7 +712,7 @@
 A higher-order predicate call.
 @var{Var} must be a variable.
 The semantics are exactly the same as for the corresponding
-higher-order call using the @code{call/N} syntax, i.e.
+higher-order call using the @code{call/N} syntax, i.e.@: 
 @samp{call(Var)}, @samp{call(Var, Arg1)}, etc.
 
 @ifset aditi
@@ -1358,7 +1358,7 @@
 determined by the specified goal.  @xref{Higher-order}.
 
 A lambda expression introduces a new scope: any variables occurring in
-the arguments Arg1, Arg2, ... are locally quantified, i.e.
+the arguments Arg1, Arg2, @dots{} are locally quantified, i.e.@: 
 any occurrences of variables with that name in the lambda
 expression are considered to name a different variable than any
 variables with the same name that occur outside of the
@@ -1593,7 +1593,7 @@
 It should not be confused with the two-dash arrow used for DCGs
 or the one-dash arrow used for if-then-else.)
 If the @var{type} term is a functor of arity zero
-(i.e. one having zero arguments),
+(i.e.@: one having zero arguments),
 it names a monomorphic type.
 Otherwise, it names a polymorphic type;
 the arguments of the functor must be distinct type variables.
@@ -1851,7 +1851,7 @@
 types of the results of existentially typed predicates or functions.}.
 
 (Here ``match'' means to be an instance of,
-i.e. to be identical to for some substitution of the type parameters,
+i.e.@: to be identical to for some substitution of the type parameters,
 and ``exactly match'' means to be identical up to renaming of type parameters.)
 
 One type assignment @var{A} is said to be
@@ -2358,7 +2358,7 @@
 that the predicate should only be called with argument terms
 that satisfy the initial instantiatedness trees
 of one of the mode declarations in the set
-(i.e. the specified modes and the modes they imply
+(i.e.@: the specified modes and the modes they imply
 are the only allowed modes for this predicate or function).
 We refer to the assertion associated with a mode set
 as the @dfn{mode set constraint};
@@ -2504,7 +2504,7 @@
 To specify that a clause only applies to a given mode, each argument
 @var{Arg} of the clause head should be annotated with the corresponding
 argument mode @var{Mode}, using the @samp{::} mode qualification operator,
-i.e. @samp{@var{Arg} :: @var{Mode}}.
+i.e.@: @samp{@var{Arg} :: @var{Mode}}.
 
 For example, if append was declared as
 
@@ -2658,7 +2658,7 @@
 modes.  The insts @samp{mostly_unique} and @samp{mostly_dead}
 are equivalent to @samp{unique} and @samp{dead},
 except that only references which will be encountered during 
-forward execution are counted - it is OK for @samp{mostly_unique} or
+forward execution are counted --- it is OK for @samp{mostly_unique} or
 @samp{mostly_dead} values to be needed again on backtracking.
 
 Mercury defines some standard modes for manipulating ``mostly unique''
@@ -2679,7 +2679,7 @@
 @section Limitations of the current implementation
 
 The implementation of the mode analysis algorithm is not quite complete;
-as a result, it is not possible to use nested unique modes, i.e.
+as a result, it is not possible to use nested unique modes, i.e.@: 
 modes in which anything but the top level of a variable is unique.
 If you do, you will get unique mode errors when you try
 to get a unique field of a unique data structure.
@@ -2688,7 +2688,7 @@
 
 The Mercury compiler does not (yet) reuse @samp{dead}
 values.  The only destructive update in the current implementation occurs
-in library modules, e.g. for I/O and arrays.  We do however plan to
+in library modules, e.g.@: for I/O and arrays.  We do however plan to
 implement structure reuse and compile-time garbage collection
 in the very near future.
 
@@ -2754,9 +2754,9 @@
 yes             failure         semidet         nondet
 @end example
 
-(Note: the "Can fail?" column here indicates only whether the procedure
+(Note: the ``Can fail?'' column here indicates only whether the procedure
 can fail before producing at least one solution; attempts to find a
- at emph{second} solution to a particular call, e.g. for a procedure
+ at emph{second} solution to a particular call, e.g.@: for a procedure
 with determinism @samp{multi}, are always allowed to fail.)
 
 The determinism of each mode of a predicate or function
@@ -2814,14 +2814,14 @@
 
 If there is no mode declaration for a function, then the default
 mode for that function is considered to have been declared as @samp{det}.
-If you want to write a partial function, i.e. one whose determinism
+If you want to write a partial function, i.e.@: one whose determinism
 is @samp{semidet}, then you must explicitly declare the mode and determinism.
 
 In Mercury, a function is supposed to be a true mathematical function
 of its arguments; that is, the value of the function's result should
 be determined only by the values of its arguments.  Hence, for
 any mode of a function that specifies that all the arguments are fully
-input (i.e. for which the initial inst of all the arguments is a ground inst),
+input (i.e.@: for which the initial inst of all the arguments is a ground inst),
 the determinism of that mode can only be
 @samp{det}, @samp{semidet}, @samp{erroneous}, or @samp{failure}.
 
@@ -2925,10 +2925,10 @@
 The conjunction can succeed more than once
 if either @var{A} or @var{B} can succeed more than once
 and both @var{A} and @var{B} can succeed at least once.
-(If e.g. @var{A} can succeed at most zero times,
+(If e.g.@: @var{A} can succeed at most zero times,
 then even if @var{B} can succeed many times
 the maximum number of solutions of the conjunction is still zero.)
-Otherwise, i.e. if both @var{A} and @var{B} succeed at most once,
+Otherwise, i.e.@: if both @var{A} and @var{B} succeed at most once,
 the conjunction can succeed at most once.
 
 @item Switches
@@ -2999,7 +2999,7 @@
 It can succeed at most once
 if one of @var{A} and @var{B} can succeed at most once
 and the other can succeed at most zero times.
-Otherwise, i.e. if either @var{A} or @var{B} can succeed more than once,
+Otherwise, i.e.@: if either @var{A} or @var{B} can succeed more than once,
 or if both @var{A} and @var{B} can succeed at least once,
 it can succeed more than once.
 
@@ -3130,7 +3130,7 @@
 which one of possibly many solutions to a goal do you want?
 If you want all of them, you need to use the predicate
 @samp{solutions/2} in the standard library module @samp{std_util},
-which collects all of the solutions to a goal into a list --
+which collects all of the solutions to a goal into a list ---
 @pxref{Higher-order}.
 
 If you just want one solution and don't care which,
@@ -3174,9 +3174,9 @@
 @end example
 
 @noindent
-A call to that function, e.g. @samp{promise_only_solution(Pred)}, constitutes a
+A call to that function, e.g.@: @samp{promise_only_solution(Pred)}, constitutes a
 promise on the part of the caller that the argument @samp{Pred} has at most
-one solution, i.e. that
+one solution, i.e.@: that
 
 @example
 not some [X1, X2] (Pred(X1), Pred(X2), X1 \= X2)
@@ -3228,7 +3228,7 @@
 and if the right-most conjunct cannot fail,
 then rest of the conjunction is also in a single-solution
 context. 
-("Right-most" here refers to the order @emph{after} mode reordering.)
+(``Right-most'' here refers to the order @emph{after} mode reordering.)
 
 @item
 If an if-then-else is in a single-solution context, then the
@@ -3237,7 +3237,7 @@
 if-then-else is also in a single-solution context.
 
 @item
-For other compound goals, i.e. disjunctions, negations, and
+For other compound goals, i.e.@: disjunctions, negations, and
 (explicitly) existentially quantified goals, if the compound goal
 is in a single-solution context, then the immediate sub-goals of that
 compound goal are also in single-solution contexts.
@@ -3248,7 +3248,7 @@
 mode of a predicate (or function) do indeed occur in a single-solution context.
 
 You can declare two different modes of a predicate (or function) which differ
-only in ``cc-ness'' (i.e. one being @samp{multi} and the other
+only in ``cc-ness'' (i.e.@: one being @samp{multi} and the other
 @samp{cc_multi}, or one being @samp{nondet} and the other @samp{cc_nondet}).
 In that case, the compiler will select the appropriate one for each
 call depending on whether the call comes from a single-solution context
@@ -3373,9 +3373,9 @@
 and mode @samp{(in, in) is semidet}, but it is also legal
 for the type, mode and determinism to be more permissive:
 the type or the mode's initial insts may be more general
-(e.g. the type could be just the polymorphic type @samp{pred(T, T)})
+(e.g.@: the type could be just the polymorphic type @samp{pred(T, T)})
 and the mode's final insts or the determinism may be more
-specific (e.g. the determinism could be any of @samp{det},
+specific (e.g.@: the determinism could be any of @samp{det},
 @samp{failure} or @samp{erroneous}).
 The equality predicate must also be ``pure'' (@pxref{Impurity}).
 
@@ -3403,7 +3403,7 @@
 
 @item
 Any attempts to examine the representation of a variable of type @var{T}
-using facilities of the standard library (e.g. @samp{argument}/3
+using facilities of the standard library (e.g.@: @samp{argument}/3
 and @samp{functor/3} in @samp{std_util}) that do not have determinism
 @samp{cc_multi} or @samp{cc_nondet} will result in a run-time error.
 
@@ -3425,7 +3425,7 @@
 contains a contradiction, because the additional axioms for the user-defined
 equality contradict the standard equality axioms.  That implies that the
 implementation may compute any answer at all (@pxref{Semantics}),
-i.e. the behaviour of the program is undefined.}.
+i.e.@: the behaviour of the program is undefined.}.
 
 @end itemize
 
@@ -3512,7 +3512,7 @@
 
 You can also create higher-order function terms of non-zero arity
 and higher-order predicate terms by ``currying'',
-i.e. specifying the first few arguments to a predicate or function, but
+i.e.@: specifying the first few arguments to a predicate or function, but
 leaving the remaining arguments unspecified.  For example, the
 unification
 
@@ -3558,7 +3558,7 @@
 @end example
 
 Higher-order function terms of zero arity can only be created using
-an explicit lambda expression; you have to use e.g. @samp{(func) = foo}
+an explicit lambda expression; you have to use e.g.@: @samp{(func) = foo}
 rather than plain @samp{foo}, because the latter denotes the result
 of evaluating the function, rather than the function itself.
 
@@ -3631,7 +3631,7 @@
 @end example
 
 @noindent
-would bind @samp{Result} to the sum of @samp{[1, 2, 3]}, i.e. to 6.
+would bind @samp{Result} to the sum of @samp{[1, 2, 3]}, i.e.@: to 6.
 
 For functions, you use the builtin expression apply/N:
 
@@ -3848,7 +3848,7 @@
 modes, and declarations for abstract data types, abstract type class
 instances, functions, predicates, and (sub-)modules.
 The interface section may not contain definitions for functions or
-predicates (i.e. clauses), or definitions of (sub-)modules. 
+predicates (i.e.@: clauses), or definitions of (sub-)modules. 
 
 An @samp{:- implementation.} declaration indicates
 the start of the module's implementation section. 
@@ -3885,7 +3885,7 @@
 The names of predicates, functions, constructors, constructor fields,
 types, modes, insts, type classes,
 and (sub-)modules can be explicitly module qualified using the @samp{:}
-operator, e.g. @samp{module:name} or @samp{module:submodule:name}.
+operator, e.g.@: @samp{module:name} or @samp{module:submodule:name}.
 This is useful both for readability and for resolving name conflicts.
 Uses of entities imported using @code{use_module} declarations
 @emph{must} be explicitly module qualified.
@@ -4106,13 +4106,13 @@
 
 Any declarations in the parent module, including those in the
 parent module's implementation section, are visible in the parent's
-sub-modules, including indirect sub-modules (i.e. sub-sub-modules, etc.).
+sub-modules, including indirect sub-modules (i.e.@: sub-sub-modules, etc.).
 Similarly, declarations in the interfaces of any modules imported using an
 @samp{:- import_module} or a @samp{:- use_module} in the parent module
 are visible in the parent's sub-modules, including indirect sub-modules.
 
 Declarations in a child module are not visible in the parent module,
-or in "sibling" modules (other children of the same parent), or in
+or in ``sibling'' modules (other children of the same parent), or in
 other unrelated modules unless the child is explicitly imported using
 an @samp{:- import_module} or @samp{:- use_module} declaration.  It
 is an error to import a module without importing all of its parent
@@ -4139,10 +4139,10 @@
 define an equivalence type in a sub-module and export it
 as abstract type.
 @item
-Using @samp{mmake} to do parallel makes (e.g. @samp{mmake --jobs 2})
+Using @samp{mmake} to do parallel makes (e.g.@: @samp{mmake --jobs 2})
 doesn't always work correctly if you're using nested sub-modules.
 (The work-around is to use separate sub-modules instead of nested
-sub-modules, i.e. to put the sub-modules in separate source files.)
+sub-modules, i.e.@: to put the sub-modules in separate source files.)
 @end itemize
 
 @node Type classes
@@ -4176,7 +4176,7 @@
 The @code{typeclass} declaration gives the name of the type class that
 it is defining, the
 names of the type variables which are parameters to the type class, and the
-operations (i.e. methods) which form the interface of the type class.
+operations (i.e.@: methods) which form the interface of the type class.
 
 For example,
 
@@ -4209,7 +4209,7 @@
 have mode @samp{in}, the result has mode @samp{out}, and the determinism
 is @samp{det}.
 
-The number of parameters to the type class (e.g. @code{T}) is not limited. 
+The number of parameters to the type class (e.g.@: @code{T}) is not limited. 
 For example, the following is allowed:
 
 @example
@@ -4255,7 +4255,7 @@
 declaration for a particular type (or sequence of types, in
 the case of a multi-parameter type class) and typeclass.
 These restrictions ensure that there are no overlapping
-instance declarations, i.e. for each typeclass there is at
+instance declarations, i.e.@: for each typeclass there is at
 most one instance declaration that may be applied to any
 type (or sequence of types). 
 
@@ -4416,7 +4416,7 @@
 Likewise, if we call @samp{translate/3} with the first argument having type
 @samp{coordinate}, this will invoke @samp{coordinate_translate}.
 
-Further instances of the type class could be made, e.g. a type which represents
+Further instances of the type class could be made, e.g.@: a type that represents
 the point using polar coordinates.
 
 @node Abstract instance declarations
@@ -4607,9 +4607,9 @@
 @node Existential types
 @chapter Existential types
 
-Existentially quantified type variables (or simply "existential types"
+Existentially quantified type variables (or simply ``existential types''
 for short) are useful tools for data abstraction.  In combination with
-type classes, they allow you to write code in an "object oriented"
+type classes, they allow you to write code in an ``object oriented''
 style that is similar to the use of interfaces in Java or abstract
 base classes in C++.
 
@@ -4691,14 +4691,14 @@
 quantified type variable in the declaration of one of the predicates
 or functions that it calls, then its type is treated as an opaque type.
 This means that there are very few things which it is legal to do with
-such a variable -- basically you can only pass it to another procedure
+such a variable --- basically you can only pass it to another procedure
 expecting the same type, unify it with another value of the same
 type, put it in a polymorphic data structure, or pass it to a
 polymorphic procedure whose argument type is universally quantified.
 (Note, however, that the standard library includes some quite powerful
 procedures such as `io__write' which can be useful in this context.)
 
-A non-variable type (i.e. a type which is not a type variable)
+A non-variable type (i.e.@: a type that is not a type variable)
 is considered @emph{more general} than an
 existentially quantified type variable.  Type inference will therefore
 never infer an existentially quantified type for a predicate or
@@ -4808,11 +4808,11 @@
 combination with type class constraints.
 
 Type class constraints can be either universal or existential.
-Universal type class constraints are written using "<=",
+Universal type class constraints are written using @samp{<=},
 as described in @ref{Type class constraints on predicates and functions};
 they signify a constraint that the @emph{caller} must satisfy.
 Existential type class constraints are written in the same syntax
-as universal constraints, but using "=>" instead of "<=";
+as universal constraints, but using @samp{=>} instead of @samp{<=};
 they signify a constraint that the @emph{callee} must satisfy.
 (If a declaration has both universal and existential constraints,
 then the existential constraints must precede the universal constraints.)
@@ -4936,7 +4936,7 @@
 type named @samp{univ} which can hold values of any type. 
 You can form heterogeneous containers (containers that can hold values of
 different types at the same time) by using data structures
-that contain @code{univ}s, e.g. @samp{list(univ)}.
+that contain @code{univ}s, e.g.@: @samp{list(univ)}.
 
 The interface to @samp{std_util} includes the following:
 
@@ -5081,7 +5081,7 @@
 semantics guarantees to compute an answer in finite time for
 any program for which an answer would be computed in finite time for all
 possible executions under the strict commutative semantics
-(i.e. for all possible orderings of conjunctions and disjunctions).
+(i.e.@: for all possible orderings of conjunctions and disjunctions).
 
 Thus, to summarize, there are in fact a variety of different operational
 semantics for Mercury.  In one of them, the strict sequential semantics, there
@@ -5120,7 +5120,7 @@
 implementation if you are to be sure that it will be able to use the
 maximally efficient operational semantics on any implementation.
 However, if you do write code which works for all possible executions
-under commutative semantics (i.e. for all possible orderings of
+under commutative semantics (i.e.@: for all possible orderings of
 conjunctions and disjunctions), then you can be guaranteed that it
 will work correctly on every implementation, under every possible
 implementation-defined semantics.
@@ -5368,9 +5368,9 @@
 Mercury variables whose type is a type variable will be passed as
 @code{System.Object}.
 Mercury array types are mapped to CLR array types.
-When compiling with --no-high-level-data, all other Mercury variables
+When compiling with @option{--no-high-level-data}, all other Mercury variables
 are passed as @code{System.Object[]}.
-When compiling with --high-level-data,
+When compiling with @option{--high-level-data},
 Mercury variables whose type is a Mercury discriminated union type
 will be passed as a CLR type whose type name is determined from
 the Mercury type name (ignoring any type parameters) followed by
@@ -5555,16 +5555,16 @@
 @c Please keep this table in alphabetical order
 
 @item @samp{C}
-Use the string "C" to set the foreign language to C.
+Use the string @code{"C"} to set the foreign language to C.
 
 @item @samp{C#}
-Use the string "C#" to set the foreign language to C#.
+Use the string @code{"C#"} to set the foreign language to C#.
 
 @item @samp{IL}
-Use the string "IL" to set the foreign language to IL.
+Use the string @code{"IL"} to set the foreign language to IL.
 
 @item @samp{Managed C++}
-Use the string "MC++" to set the foreign language to Managed C++.
+Use the string @code{"MC++"} to set the foreign language to Managed C++.
 
 @end table
 
@@ -6071,7 +6071,7 @@
 You may not give a @samp{pragma import} declaration for a procedure
 with determinism @samp{nondet} or @samp{multi}.
 (It is however possible to define a @samp{nondet} or @samp{multi} procedure
-using @samp{pragma c_code} -- @pxref{Nondet pragma c_code}).
+using @samp{pragma c_code}.  @xref{Nondet pragma c_code}.)
 
 @node pragma c_code
 @subsection pragma c_code
@@ -6165,7 +6165,7 @@
 @subsection Nondet pragma c_code
 
 For procedures that can return more than one result on backtracking,
-i.e. those with determinism @samp{nondet} or @samp{multi},
+i.e.@: those with determinism @samp{nondet} or @samp{multi},
 the form of @samp{pragma c_code} declaration described previously
 does not suffice.  Instead, you should use a declaration of the form
 shown below:
@@ -6213,7 +6213,7 @@
 containing the fields specified by @var{LocalVars}, to access this saved state.
 
 Note @var{RetryCode} and @var{CommonCode} may not access the input
-variables -- only @var{FirstCode} should access the input variables.
+variables --- only @var{FirstCode} should access the input variables.
 If @var{RetryCode} or @var{CommonCode} need to access any of the input
 variables, then @var{FirstCode} should copy the values needed to the
 @var{LocalVars}.
@@ -6376,14 +6376,14 @@
 to ensure that the predicate has a proper declarative
 semantics.  If the @samp{io__state} arguments were
 left off, then the Mercury implementation might apply
-undesirable optimizations (e.g. reordering, duplicate
+undesirable optimizations (e.g.@: reordering, duplicate
 call elimination, tabling, lazy evaluation, @dots{})
 to this procedure, which could effect the behaviour
 of the program in unpredictable ways.
 
 Impure C code relaxes some of these restrictions.  
 Impure C code may perform I/O and although it cannot update its
-arguments directly (unless they have an appropriate unique mode, e.g.
+arguments directly (unless they have an appropriate unique mode, e.g.@: 
 @samp{di}) it may update something pointed to by its arguments.
 Impure C code procedures must still be type correct and mode correct.
 
@@ -6457,7 +6457,7 @@
 
 It is also possible to export Mercury procedures to C,
 so that you can call Mercury code from C (or from
-other languages that can interface to C, e.g. C++).
+other languages that can interface to C, e.g.@: C++).
 
 A declaration of the form
 
@@ -6841,7 +6841,7 @@
 where @var{reason} will be @samp{MR_undo} if the backtracking was due to
 a goal failing, @samp{MR_exception} if the backtracking was due to
 a goal throwing an exception, or @samp{MR_retry} if the backtracking
-was due to the use of the "retry" command in mdb, the Mercury debugger,
+was due to the use of the ``retry'' command in @command{mdb}, the Mercury debugger,
 or any similar user request in a debugger.
 The Mercury implementation also ensures that if the current choice point is
 pruned because execution commits to never backtracking to it,
@@ -6849,9 +6849,9 @@
 It also ensures that if execution requires that the current goal be
 solvable, then @code{(*@var{untrail_func})(@var{value}, MR_solve)}
 will be called.  This happens in calls to @code{solutions/2}, for example.
-(@code{MR_commit} is used for ``hard'' commits, i.e. when we commit
+(@code{MR_commit} is used for ``hard'' commits, i.e.@: when we commit
 to a solution and prune away the alternative solutions; @code{MR_solve}
-is used for ``soft'' commits, i.e. when we must commit to a solution
+is used for ``soft'' commits, i.e.@: when we must commit to a solution
 but do not prune away all the alternatives.)
 
 MR_gc is currently not used ---
@@ -6965,7 +6965,7 @@
 @end example
 
 @code{MR_choicepoint_newer(x, y)} true iff the choicepoint indicated by
- at samp{x} is newer than (i.e. was created more recently than) the
+ at samp{x} is newer than (i.e.@: was created more recently than) the
 choicepoint indicated by @samp{y}.  The null ChoicepointId is considered
 older than any non-null ChoicepointId.  If either of the choice points
 have been backtracked over, the behaviour is undefined.
@@ -6995,7 +6995,7 @@
 
 For an example, see the sample module below.
 
-Note that there is a cost to this -- you have to include
+Note that there is a cost to this --- you have to include
 an extra field in your data structure for each part of
 the data structure which you might update, you
 need to perform a test for each update to decide whether
@@ -7772,7 +7772,7 @@
 @cartouche
 @strong{Please note:}
 the current implementation of tabling does not support all the
-possible compilation grades (see the "Compilation model options"
+possible compilation grades (see the ``Compilation model options''
 section of the Mercury User's Guide) allowed by the Mercury
 implementation.  In particular, if you enable the use of trailing,
 or if you select a garbage collection method other than the default
@@ -7917,7 +7917,7 @@
 calls are ordered correctly, in the same way that @samp{io__state} arguments
 are used to ensure ordering of I/O operations. Within the clauses for
 predicates with a @samp{pragma aditi} declaration variables with
-type @samp{aditi__state} may only be passed to other database predicates --
+type @samp{aditi__state} may only be passed to other database predicates ---
 they may not be packaged into terms or passed to top-down Mercury predicates.
 This allows the compiler to remove all instances of @samp{aditi__state}
 variables from database predicates, and enforces the restriction that
Index: transition_guide.texi
===================================================================
RCS file: /home/mercury1/repository/mercury/doc/transition_guide.texi,v
retrieving revision 1.40
diff -d -u -r1.40 transition_guide.texi
--- transition_guide.texi	31 Jul 2002 06:52:04 -0000	1.40
+++ transition_guide.texi	2 Aug 2002 05:12:18 -0000
@@ -313,7 +313,7 @@
 The cut operator is not part of the Mercury language.
 In addition, the conditional operator @samp{-> ;}
 does not do a hard cut across the condition
-- only a soft cut which prunes away either the `then' goal or the `else' goal.
+--- only a soft cut which prunes away either the `then' goal or the `else' goal.
 If there are multiple solutions to the condition,
 they will all be found on backtracking.
 
@@ -411,7 +411,7 @@
 output, Mercury will in fact reorder the code so that it traverses
 the input list right-to-left and constructs the output list bottom-up
 rather than top-down.  In this particular case, the reordered code is still
-tail recursive - but it is tail-recursive on the first recursive call,
+tail recursive --- but it is tail-recursive on the first recursive call,
 not the second one!
 
 If the occasional loss of tail recursion causes efficiency problems,
@@ -503,7 +503,7 @@
 Prolog's various different all-solutions predicates (findall/3, bagof/3,
 and setof/3) all have semantic problems.
 Mercury has a different set of all-solutions predicates (solutions/2,
-solutions_set/2, and unsorted_solutions/2 -- all defined in the library
+solutions_set/2, and unsorted_solutions/2 --- all defined in the library
 module @samp{std_util}) that
 address the problems of the Prolog versions.
 To avoid the variable scoping problems of the Prolog
Index: user_guide.texi
===================================================================
RCS file: /home/mercury1/repository/mercury/doc/user_guide.texi,v
retrieving revision 1.316
diff -d -u -r1.316 user_guide.texi
--- user_guide.texi	29 Jul 2002 11:15:43 -0000	1.316
+++ user_guide.texi	2 Aug 2002 05:12:18 -0000
@@ -77,7 +77,7 @@
 @author Tyson Dowd
 @page
 @vskip 0pt plus 1filll
-Copyright @copyright{} 1995-2002 The University of Melbourne.
+Copyright @copyright{} 1995--2002 The University of Melbourne.
 
 Permission is granted to make and distribute verbatim copies of
 this manual provided the copyright notice and this permission notice
@@ -251,7 +251,7 @@
 the Mercury compiler is called @samp{mmc}
 (for ``Melbourne Mercury Compiler'').
 @pindex mmc
-Some of its options (e.g. @samp{-c}, @samp{-o}, and @samp{-I})
+Some of its options (e.g.@: @samp{-c}, @samp{-o}, and @samp{-I})
 have a similar meaning to that in other Unix compilers.
 
 Arguments to @samp{mmc} may be either file names (ending in @samp{.m}),
@@ -260,7 +260,7 @@
 the compiler will look for the source in files @file{foo.bar.baz.m},
 @file{bar.baz.m}, and @file{baz.m}, in that order.
 Note that if the file name does not include all the module
-qualifiers (e.g. if it is @file{bar.baz.m} or @file{baz.m}
+qualifiers (e.g.@: if it is @file{bar.baz.m} or @file{baz.m}
 rather than @file{foo.bar.baz.m}), then the module name in the
 @samp{:- module} declaration for that module must be fully qualified.
 To make the compiler look in another file for a module, use
@@ -499,7 +499,7 @@
 Mmake's builtin rules are defined by the file
 @file{@var{prefix}/lib/mercury/mmake/Mmake.rules}
 (where @var{prefix} is @file{/usr/local/mercury- at var{version}} by default,
-and @var{version} is the version number, e.g. @samp{0.6}),
+and @var{version} is the version number, e.g.@: @samp{0.6}),
 as well as the rules and variables in the automatically-generated
 @file{.dep} and @file{.dv} files.
 These rules define the following targets:
@@ -739,7 +739,7 @@
 for @code{MLFLAGS} and @code{EXTRA_MLFLAGS} (@code{ml} and @code{c2init}
 take the same set of options).
 (Note that compilation model options and extra files to be processed by
-c2init should not be specified in @code{C2INITFLAGS} - they should be
+c2init should not be specified in @code{C2INITFLAGS} --- they should be
 specified in @code{GRADEFLAGS} and @code{C2INITARGS}, respectively.)
 
 @item C2INITARGS and EXTRA_C2INITARGS
@@ -768,7 +768,7 @@
 @item INSTALL_PREFIX
 @vindex INSTALL_PREFIX
 The path to the root of the directory hierarchy where the libraries,
-etc. you are building should be installed.  The default is to install in
+etc.@: you are building should be installed.  The default is to install in
 the same location as the Mercury compiler being used to do the install.
 
 @item INSTALL
@@ -795,7 +795,7 @@
 you expect if those options are not subsumed by each of the grades listed.
 @end table
 
-Other variables also exist - see
+Other variables also exist --- see
 @file{@var{prefix}/lib/mercury/mmake/Mmake.vars} for a complete list.
 
 If you wish to temporarily change the flags passed to an executable,
@@ -886,7 +886,7 @@
 
 Often you will want to use a particular set of Mercury modules
 in more than one program.  The Mercury implementation
-includes support for developing libraries, i.e. sets of Mercury modules
+includes support for developing libraries, i.e.@: sets of Mercury modules
 intended for reuse.  It allows separate compilation of libraries
 and, on many platforms, it supports shared object libraries.
 
@@ -1053,7 +1053,7 @@
 machine architectures.
 
 In order to support the installation of a library into such a tree, you
-simply need to specify (e.g. in your @file{Mmakefile}) the path prefix
+simply need to specify (e.g.@: in your @file{Mmakefile}) the path prefix
 and the list of grades to install:
 
 @example
@@ -1218,12 +1218,12 @@
 information.  The three numbers at the start of the display are the
 event number, the call sequence number, and the call depth. 
 (You don't really need to pay too much attention to those.)
-They are followed by the event type (e.g. @samp{CALL} or @samp{EXIT}).
+They are followed by the event type (e.g.@: @samp{CALL} or @samp{EXIT}).
 After that comes the identification of the procedure
 in which the event occurred, consisting of the module-qualified name
 of the predicate or function to which the procedure belongs,
 followed by its arity, mode number and determinism.
-This may sometimes be followed by a "path"
+This may sometimes be followed by a ``path''
 (@pxref{Tracing of Mercury programs}).
 At the end is the file name and line number of the
 called procedure and (if available) also the file name
@@ -1285,7 +1285,7 @@
 
 To start the Emacs interface, you first need to put the following
 text in the file @file{.emacs} in your home directory,
-replacing "/usr/local/mercury-1.0" with the directory
+replacing ``/usr/local/mercury-1.0'' with the directory
 that your Mercury implementation was installed in.
 
 @example
@@ -1297,7 +1297,7 @@
 
 Build your program with debugging enabled, as described
 in @ref{Quick overview} or @ref{Preparing a program for debugging}.
-Then start up Emacs, e.g. using the command @samp{emacs},
+Then start up Emacs, e.g.@: using the command @samp{emacs},
 and type @kbd{M-x mdb @key{RET}}. Emacs will then prompt you for
 the mdb command to invoke
 
@@ -1313,21 +1313,21 @@
 Run mdb (like this): mdb ./hello arg1 arg2 ...
 @end example
 
-Emacs will then create several "buffers": one for the debugger prompt,
+Emacs will then create several ``buffers'': one for the debugger prompt,
 one for the input and output of the program being executed, and one or more
 for the source files.  By default, Emacs will split the display into two
-parts, called "windows", so that two of these buffers will be visible.
+parts, called ``windows'', so that two of these buffers will be visible.
 You can use the command @kbd{C-x o} to switch between windows,
 and you can use the command @kbd{C-x 2} to split a window into two
-windows.  You can use the "Buffers" menu to select which buffer is
+windows.  You can use the ``Buffers'' menu to select which buffer is
 displayed in each window.
 
 If you're using X-Windows, then it is a good idea
 to set the Emacs variable @samp{pop-up-frames} to @samp{t}
 before starting mdb, since this will cause each buffer to be
-displayed in a new "frame" (i.e. a new X window).
+displayed in a new ``frame'' (i.e.@: a new X window).
 You can set this variable interactively using the
- at samp{set-variable} command, i.e.
+ at samp{set-variable} command, i.e.@: 
 @kbd{M-x set-variable @key{RET} pop-up-frames @key{RET} t @key{RET}}.
 Or you can put @samp{(setq pop-up-frames t)} in the @file{.emacs}
 file in your home directory.
@@ -1368,16 +1368,16 @@
 the cursor to the relevant part of the source code and then
 selecting a command from the menu.
 You can set a break point on a line by moving the cursor to the
-appropriate line in your source code (e.g. with the arrow keys,
+appropriate line in your source code (e.g.@: with the arrow keys,
 or by clicking the mouse there), and then selecting
-the "Set breakpoint on line" command from the "Breakpoints"
-sub-menu of the "MDB" menu.  You can set a breakpoint on
+the ``Set breakpoint on line'' command from the ``Breakpoints''
+sub-menu of the ``MDB'' menu.  You can set a breakpoint on
 a procedure by moving the cursor over the procedure name
-and then selecting the "Set breakpoint on procedure"
+and then selecting the ``Set breakpoint on procedure''
 command from the same menu.  And you can display the value of
 a variable by moving the cursor over the variable name
-and then selecting the "Print variable" command from the
-"Data browsing" sub-menu of the "MDB" menu.
+and then selecting the ``Print variable'' command from the
+``Data browsing'' sub-menu of the ``MDB'' menu.
 Most of the menu commands also have keyboard short-cuts,
 which are displayed on the menu.
 
@@ -1526,7 +1526,7 @@
 then this will be the only goal with whose path has @samp{d2;c3;} as a prefix.
 If it is a compound goal,
 then its components will all have paths that have @samp{d2;c3;} as a prefix,
-e.g. if it is an if-then-else,
+e.g.@: if it is an if-then-else,
 then its three components will have the paths
 @samp{d2;c3;?;}, @samp{d2;c3;t;} and @samp{d2;c3;e;}.
 
@@ -1577,7 +1577,7 @@
 Mercury supports two broad ways of preparing a program for debugging.
 The simpler way is to compile a program in a debugging grade,
 which you can do directly by specifying a grade
-that includes the word ``debug'' (e.g. @samp{asm_fast.gc.debug}),
+that includes the word ``debug'' (e.g.@: @samp{asm_fast.gc.debug}),
 or indirectly by specifying the @samp{--debug} grade option
 to the compiler, linker, and other tools
 (in particular @code{mmc}, @code{mgnuc}, @code{ml}, and @code{c2init}).
@@ -1832,7 +1832,7 @@
 @cindex debugger interrupt
 @cindex interrupt, in debugger
 @cindex control-C
-If the debugger receives an interrupt (e.g. if the user presses control-C),
+If the debugger receives an interrupt (e.g.@: if the user presses control-C),
 it will stop at the next event regardless of what command it is executing
 at the time.
 @sp 1
@@ -1878,7 +1878,7 @@
 @item procedure specification
 @cindex procedure specification (in mdb)
 @cindex debugger procedure specification
-Some debugger commands, e.g. @samp{break},
+Some debugger commands, e.g.@: @samp{break},
 require a parameter that specifies a procedure.
 Such a procedure specification has
 the following components in the following order:
@@ -1971,7 +1971,7 @@
 The module names @var{module1}, @var{module2}, @dots{} specify
 which modules will be imported.  Note that you can also
 add new modules to the list of imports directly at the query prompt,
-by using a command of the form @samp{[@var{module}]}, e.g. @samp{[int]}.
+by using a command of the form @samp{[@var{module}]}, e.g.@: @samp{[int]}.
 You need to import all the modules that define symbols used in your query.
 Queries can only use symbols that are exported from a module;
 entities which are declared in a module's implementation section
@@ -2124,7 +2124,7 @@
 @item return [-NSans]
 @kindex return (mdb command)
 Continues the program until the program finished returning,
-i.e. until it reaches a port other than EXIT.
+i.e.@: until it reaches a port other than EXIT.
 Reports an error if the current event already refers to such a port.
 @sp 1
 The options @samp{-n} or @samp{--none}, @samp{-s} or @samp{--some},
@@ -2139,7 +2139,7 @@
 @item forward [-NSans]
 @kindex forward (mdb command)
 Continues the program until the program resumes forward execution,
-i.e. until it reaches a port other than REDO or FAIL.
+i.e.@: until it reaches a port other than REDO or FAIL.
 Reports an error if the current event already refers to such a port.
 @sp 1
 The options @samp{-n} or @samp{--none}, @samp{-s} or @samp{--some},
@@ -2290,7 +2290,7 @@
 This is a non-interactive version of the @samp{browse}
 command (see below).  Various settings
 which affect the way that terms are printed out
-(including e.g. the maximum term depth) can be set using
+(including e.g.@: the maximum term depth) can be set using
 the @samp{set} command.
 @sp 1
 The options @samp{-f} or @samp{--flat}, @samp{-p} or @samp{--pretty},
@@ -2710,7 +2710,7 @@
 @item modules
 @kindex modules (mdb command)
 Lists all the debuggable modules
-(i.e. modules that have debugging information).
+(i.e.@: modules that have debugging information).
 @sp 1
 @item procedures @var{module}
 @kindex procedures (mdb command)
@@ -2779,7 +2779,7 @@
 @item scroll @var{size}
 Sets the scroll window size to @var{size},
 which tells scroll control to stop and print a @samp{--more--} prompt
-after every @var{size - 1} events.
+after every @var{size} @minus{} 1 events.
 The default value of @var{size}
 is the value of the @samp{LINES} environment variable,
 which should correspond to the number of lines available on the terminal.
@@ -2824,18 +2824,18 @@
 Reports where contexts are being printed.
 @sp 1
 @item scope all
-Sets the default scope of new breakpoints to "all",
-i.e. by default, new breakpoints on procedures
+Sets the default scope of new breakpoints to ``all'',
+i.e.@: by default, new breakpoints on procedures
 will stop at all events in the procedure.
 @sp 1
 @item scope interface
-Sets the default scope of new breakpoints to "interface",
-i.e. by default, new breakpoints on procedures
+Sets the default scope of new breakpoints to ``interface'',
+i.e.@: by default, new breakpoints on procedures
 will stop at all interface events in the procedure.
 @sp 1
 @item scope entry
-Sets the default scope of new breakpoints to "entry",
-i.e. by default, new breakpoints on procedures
+Sets the default scope of new breakpoints to ``entry'',
+i.e.@: by default, new breakpoints on procedures
 will stop only at events representing calls to the procedure.
 @sp 1
 @item scope
@@ -2919,7 +2919,7 @@
 @item clear_histogram
 @kindex clear_histogram (mdb command)
 Clears the histogram printed by @samp{histogram_exp},
-i.e. sets the counts for all depths to zero.
+i.e.@: sets the counts for all depths to zero.
 @end table
 @node Developer commands
 @subsection Developer commands
@@ -3131,7 +3131,7 @@
 If you are using Mmake,
 then you pass these options to all the relevant programs
 by setting the @samp{GRADEFLAGS} variable in your Mmakefile,
-e.g. by adding the line @samp{GRADEFLAGS=--profiling}. 
+e.g.@: by adding the line @samp{GRADEFLAGS=--profiling}. 
 (For more information about the different grades,
 see @ref{Compilation model options}.)
 
@@ -3212,7 +3212,7 @@
 which counts all time spent executing the process,
 including time spent by the operating system working on behalf of the process,
 but not including time that the process was suspended
-(e.g. due to time slicing, or while waiting for input).
+(e.g.@: due to time slicing, or while waiting for input).
 When measuring real time,
 profiling counts even periods during which the process was suspended.
 When measuring user time only,
@@ -3250,7 +3250,7 @@
 and shows the execution time and call counts for each parent and child.
 It is sorted on the total amount of time spent
 in the procedure and all of its descendents
-(i.e. all of the procedures that it calls, directly or indirectly.)
+(i.e.@: all of the procedures that it calls, directly or indirectly.)
 
 @cindex Flat profile
 The flat profile presents the just execution time spent in each procedure.
@@ -3285,7 +3285,7 @@
 
 @cindex Garbage collection, profiling
 Note that any time spent in a C function
-(e.g. time spent in @samp{GC_malloc()},
+(e.g.@: time spent in @samp{GC_malloc()},
 which does memory allocation and garbage collection)
 is credited to the Mercury procedure that called that C function.
 
@@ -3483,7 +3483,7 @@
 
 On some operating systems,
 Mercury's profiling doesn't work properly with shared libraries.
-The symptom is errors ("map__lookup failed") or warnings from @samp{mprof}.
+The symptom is errors (@samp{map__lookup failed}) or warnings from @command{mprof}.
 On some systems, the problem occurs because the C implementation
 fails to conform to the semantics specified by the ISO C standard
 for programs that use shared libraries.
@@ -3494,7 +3494,7 @@
 If you get errors or warnings from @samp{mprof},
 and your program is dynamically linked,
 try rebuilding your application statically linked,
-e.g. by using @samp{MLFLAGS=--static} in your Mmakefile.
+e.g.@: by using @samp{MLFLAGS=--static} in your Mmakefile.
 Another work-around that sometimes works is to set the environment variable
 @samp{LD_BIND_NOW} to a non-null value before running the program.
 
@@ -3546,11 +3546,11 @@
 or long options preceded by @samp{--}.
 Options are case-sensitive.
 We call options that do not take arguments @dfn{flags}.
-Single-letter flags may be grouped with a single @samp{-}, e.g. @samp{-vVc}.
+Single-letter flags may be grouped with a single @samp{-}, e.g.@: @samp{-vVc}.
 Single-letter flags may be negated
-by appending another trailing @samp{-}, e.g. @samp{-v-}.
+by appending another trailing @samp{-}, e.g.@: @samp{-v-}.
 Long flags may be negated by preceding them with @samp{no-},
-e.g. @samp{--no-verbose}.
+e.g.@: @samp{--no-verbose}.
 @findex --no-
 
 @node Warning options
@@ -3956,7 +3956,7 @@
 @itemx --target-code-only
 @findex -C
 @findex --target-code-only
-Generate target code (i.e. C in @file{@var{module}.c},
+Generate target code (i.e.@: C in @file{@var{module}.c},
 assembler in @file{@var{module}.s} or @file{@var{module}.pic_s},
 IL in @file{@var{module}.il} or Java in @file{@var{module}.java}),
 but not object code.
@@ -4046,7 +4046,7 @@
 Output comments in the @file{@var{module}.c} file.
 This is primarily useful for trying to understand
 how the generated C code relates to the source code,
-e.g. in order to debug the compiler.
+e.g.@: in order to debug the compiler.
 The code may be easier to understand if you also use the
 @samp{--no-llds-optimize} option.
 @findex --no-llds-optimize
@@ -4693,7 +4693,7 @@
 @findex --profile-calls
 Similar to @samp{--profiling}, except that this option only gathers
 call counts, not timing information.  Useful on systems where time
-profiling is not supported -- but not as useful as @samp{--memory-profiling}.
+profiling is not supported --- but not as useful as @samp{--memory-profiling}.
 
 @sp 1
 @item @code{--profile-time} (grades: any grade containing @samp{.proftime})
@@ -4779,7 +4779,7 @@
 @cindex Addresses, reserved
 @cindex Data representation
 (This option is not intended for general use.)@*
-Treat the integer values from 0 up to @var{n} - 1 as reserved
+Treat the integer values from 0 up to @var{n} @minus{} 1 as reserved
 addresses that can be used to represent nullary constructors
 (constants) of discriminated union types.
 
@@ -4792,7 +4792,7 @@
 @cindex Objects, reserved
 @cindex Data representation
 (This option is not intended for general use.)@*
-Allocate up to @var{n} - 1 global objects for representing nullary
+Allocate up to @var{n} @minus{} 1 global objects for representing nullary
 constructors (constants) of discriminated union types.
 
 Note that reserved objects will only be used if reserved addresses
@@ -4817,7 +4817,7 @@
 (This option is not intended for general use.)@*
 Don't output base_type_layout structures or references to them.
 This option will generate smaller executables, but will not allow the
-use of code that uses the layout information (e.g. @samp{functor},
+use of code that uses the layout information (e.g.@: @samp{functor},
 @samp{arg}). Using such code will result in undefined behaviour at
 runtime.  The C code also needs to be compiled with
 @samp{-DNO_TYPE_LAYOUT}.
@@ -5056,13 +5056,13 @@
 @item --use-opt-files
 @findex --use-opt-files
 Perform inter-module optimization using any @samp{.opt} files which are 
-already built, e.g. those for the standard library, but do not build any
+already built, e.g.@: those for the standard library, but do not build any
 others.
 
 @item --use-trans-opt-files
 @findex --use-trans-opt-files
 Perform inter-module optimization using any @samp{.trans_opt} files which are 
-already built, e.g. those for the standard library, but do not build any
+already built, e.g.@: those for the standard library, but do not build any
 others.
 
 @sp 1
@@ -5080,7 +5080,7 @@
 This option significantly increases compilation time,
 link time, and intermediate disk space requirements,
 but in return reduces the size of the final
-executable, typically by about 10-20%.
+executable, typically by about 10--20%.
 This option is only useful with @samp{--procs-per-c-function 1},
 so this option automatically sets @samp{--procs-per-c-function 1}.
 
@@ -5090,7 +5090,7 @@
 
 N.B.  When using @samp{mmake}, the @samp{--split-c-files} option should
 not be placed in the @samp{MCFLAGS} variable.  Instead, use the
- at samp{@var{MODULE}.split} target, i.e. type @samp{mmake foo.split}
+ at samp{@var{MODULE}.split} target, i.e.@: type @samp{mmake foo.split}
 rather than @samp{mmake foo}.
 
 @end table
@@ -5777,7 +5777,7 @@
 @cindex Target code compilation options
 
 If you are using Mmake, you need to pass these options
-to the target code compiler (e.g. @samp{mgnuc}) rather
+to the target code compiler (e.g.@: @samp{mgnuc}) rather
 than to @samp{mmc}.
 
 @table @code
@@ -6250,7 +6250,7 @@
 @itemx --mdb-tty @var{filename}
 @findex -m (runtime option)
 @findex --mdb-tty (runtime option)
-Redirect all three debugger I/O streams -- input, output, and error messages --
+Redirect all three debugger I/O streams --- input, output, and error messages ---
 to the file or device specified by @var{filename}.
 
 @c --mdb-in-window is for use only by the mdb script, so it's
@@ -6282,7 +6282,7 @@
 @samp{MGNUC=MERCURY_C_COMPILER=@dots{} mgnuc} to your @samp{Mmake} file,
 or by using the @samp{--cc} option to @samp{mmc}.
 You may need to specify some option(s) to the C compiler
-to ensure that it uses an ANSI preprocessor (e.g. if you
+to ensure that it uses an ANSI preprocessor (e.g.@: if you
 are using the DEC Alpha/OSF 3.2 C compiler, you would need to
 pass @samp{--cc="cc -std"} to @samp{mmc} so that it will pass the
 @samp{-std} option to @samp{cc}).
--------------------------------------------------------------------------
mercury-reviews mailing list
post:  mercury-reviews at cs.mu.oz.au
administrative address: owner-mercury-reviews at cs.mu.oz.au
unsubscribe: Address: mercury-reviews-request at cs.mu.oz.au Message: unsubscribe
subscribe:   Address: mercury-reviews-request at cs.mu.oz.au Message: subscribe
--------------------------------------------------------------------------



More information about the reviews mailing list