Control: tags -1 + patch
the attached patch fixes the build with the updated eglibc and texinfo, however
fails in the tests. Stopping there. I don't see the test failures with an
updated libgc 7.2.
So maybe better to update libgc and guile-2.0 to 2.0.9.
diff -Nru guile-2.0-2.0.5+1/debian/changelog guile-2.0-2.0.5+1/debian/changelog
--- guile-2.0-2.0.5+1/debian/changelog 2012-03-18 19:31:09.000000000 +0100
+++ guile-2.0-2.0.5+1/debian/changelog 2013-05-13 20:25:30.000000000 +0200
@@ -1,3 +1,12 @@
+guile-2.0 (2.0.5+1-3.1) unstable; urgency=low
+
+ * Non maintainer upload.
+ * Remove the gets check. Closes: #701397.
+ * Rebuild for the libffi transition.
+ * Fix texinfo errors exposed by texinfo 5.1.
+
+ -- Matthias Klose <d...@debian.org> Mon, 13 May 2013 14:44:28 +0200
+
guile-2.0 (2.0.5+1-3) unstable; urgency=low
* Add 0003-Mark-mutex-with-owner-not-retained-threads-test-as-u.patch.
diff -Nru guile-2.0-2.0.5+1/debian/patches/gnulib-update.diff
guile-2.0-2.0.5+1/debian/patches/gnulib-update.diff
--- guile-2.0-2.0.5+1/debian/patches/gnulib-update.diff 1970-01-01
01:00:00.000000000 +0100
+++ guile-2.0-2.0.5+1/debian/patches/gnulib-update.diff 2013-05-13
14:43:53.000000000 +0200
@@ -0,0 +1,31 @@
+diff --git a/lib/stdio.in.h b/lib/stdio.in.h
+index 7e4d593..f7e06ad 100644
+--- a/lib/stdio.in.h
++++ b/lib/stdio.in.h
+@@ -699,22 +699,11 @@ _GL_WARN_ON_USE (getline, "getline is unportable - "
+ # endif
+ #endif
+
+-#if @GNULIB_GETS@
+-# if @REPLACE_STDIO_READ_FUNCS@ && @GNULIB_STDIO_H_NONBLOCKING@
+-# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
+-# undef gets
+-# define gets rpl_gets
+-# endif
+-_GL_FUNCDECL_RPL (gets, char *, (char *s) _GL_ARG_NONNULL ((1)));
+-_GL_CXXALIAS_RPL (gets, char *, (char *s));
+-# else
+-_GL_CXXALIAS_SYS (gets, char *, (char *s));
+-# undef gets
+-# endif
+-_GL_CXXALIASWARN (gets);
+ /* It is very rare that the developer ever has full control of stdin,
+- so any use of gets warrants an unconditional warning. Assume it is
+- always declared, since it is required by C89. */
++ so any use of gets warrants an unconditional warning; besides, C11
++ removed it. */
++#undef gets
++#if HAVE_RAW_DECL_GETS
+ _GL_WARN_ON_USE (gets, "gets is a security hole - use fgets instead");
+ #endif
+
diff -Nru guile-2.0-2.0.5+1/debian/patches/series
guile-2.0-2.0.5+1/debian/patches/series
--- guile-2.0-2.0.5+1/debian/patches/series 2012-03-18 19:29:45.000000000
+0100
+++ guile-2.0-2.0.5+1/debian/patches/series 2013-05-13 14:58:49.000000000
+0200
@@ -1,3 +1,5 @@
0001-Change-guile-to-guile-X.Y-for-info-pages.patch
0002-Mark-Unused-modules-are-removed-gc-test-as-unresolve.patch
0003-Mark-mutex-with-owner-not-retained-threads-test-as-u.patch
+gnulib-update.diff
+texinfo-docs.diff
diff -Nru guile-2.0-2.0.5+1/debian/patches/texinfo-docs.diff
guile-2.0-2.0.5+1/debian/patches/texinfo-docs.diff
--- guile-2.0-2.0.5+1/debian/patches/texinfo-docs.diff 1970-01-01
01:00:00.000000000 +0100
+++ guile-2.0-2.0.5+1/debian/patches/texinfo-docs.diff 2013-05-13
15:01:47.000000000 +0200
@@ -0,0 +1,332 @@
+Index: b/doc/ref/api-control.texi
+===================================================================
+--- a/doc/ref/api-control.texi 2012-01-30 21:36:48.000000000 +0000
++++ b/doc/ref/api-control.texi 2013-05-13 12:59:05.648041397 +0000
+@@ -1,7 +1,7 @@
+ @c -*-texinfo-*-
+ @c This is part of the GNU Guile Reference Manual.
+-@c Copyright (C) 1996, 1997, 2000, 2001, 2002, 2003, 2004, 2009, 2010, 2011,
2012
+-@c Free Software Foundation, Inc.
++@c Copyright (C) 1996, 1997, 2000, 2001, 2002, 2003, 2004, 2009, 2010,
++@c 2011, 2012, 2013 Free Software Foundation, Inc.
+ @c See the file guile.texi for copying conditions.
+
+ @node Control Mechanisms
+@@ -44,7 +44,7 @@
+ output port, then display a newline. We use @code{begin} to form a
+ compound expression out of this sequence of sub-expressions.
+
+-@deffn syntax begin expr1 expr2 @dots{}
++@deffn syntax begin expr @dots{}
+ The expression(s) are evaluated in left-to-right order and the value of
+ the last expression is returned as the value of the
+ @code{begin}-expression. This expression type is used when the
+@@ -200,7 +200,7 @@
+ @code{cond} ignores its boolean state; instead, @code{cond} evaluates
+ @var{guard} and applies the resulting procedure to the value(s) of
+ @var{test}, as if @var{guard} were the @var{consumer} argument of
+-@code{call-with-values}. Iff the result of that procedure call is a
++@code{call-with-values}. If the result of that procedure call is a
+ true value, it evaluates @var{expression} and applies the resulting
+ procedure to the value(s) of @var{test}, in the same manner as the
+ @var{guard} was called.
+@@ -212,18 +212,30 @@
+ @end deffn
+
+ @deffn syntax case key clause1 clause2 @dots{}
+-@var{key} may be any expression, the @var{clause}s must have the form
++@var{key} may be any expression, and the @var{clause}s must have the form
+
+ @lisp
+ ((@var{datum1} @dots{}) @var{expr1} @var{expr2} @dots{})
+ @end lisp
+
++or
++
++@lisp
++((@var{datum1} @dots{}) => @var{expression})
++@end lisp
++
+ and the last @var{clause} may have the form
+
+ @lisp
+ (else @var{expr1} @var{expr2} @dots{})
+ @end lisp
+
++or
++
++@lisp
++(else => @var{expression})
++@end lisp
++
+ All @var{datum}s must be distinct. First, @var{key} is evaluated. The
+ result of this evaluation is compared against all @var{datum} values using
+ @code{eqv?}. When this comparison succeeds, the expression(s) following
+@@ -234,6 +246,11 @@
+ @code{else}-clause, the expressions following the @code{else} are
+ evaluated. If there is no such clause, the result of the expression is
+ unspecified.
++
++For the @code{=>} clause types, @var{expression} is evaluated and the
++resulting procedure is applied to the value of @var{key}. The result of
++this procedure application is then the result of the
++@code{case}-expression.
+ @end deffn
+
+
+@@ -277,7 +294,7 @@
+ R5RS defines a construct for programming loops, calling @code{do}. In
+ addition, Guile has an explicit looping syntax called @code{while}.
+
+-@deffn syntax do ((variable init [step]) @dots{}) (test [expr @dots{}]) body
@dots{}
++@deffn syntax do ((variable init [step]) @dots{}) (test expr @dots{}) body
@dots{}
+ Bind @var{variable}s and evaluate @var{body} until @var{test} is true.
+ The return value is the last @var{expr} after @var{test}, if given. A
+ simple example will illustrate the basic form,
+@@ -348,7 +365,7 @@
+ Within @code{while}, two extra bindings are provided, they can be used
+ from both @var{cond} and @var{body}.
+
+-@deffn {Scheme Procedure} break break-arg...
++@deffn {Scheme Procedure} break break-arg @dots{}
+ Break out of the @code{while} form.
+ @end deffn
+
+@@ -477,17 +494,20 @@
+ @end deffn
+
+ @deffn {Scheme Procedure} make-prompt-tag [stem]
+-Make a new prompt tag. Currently prompt tags are generated symbols.
+-This may change in some future Guile version.
++Make a new prompt tag. A prompt tag is simply a unique object.
++Currently, a prompt tag is a fresh pair. This may change in some future
++Guile version.
+ @end deffn
+
+ @deffn {Scheme Procedure} default-prompt-tag
+ Return the default prompt tag. Having a distinguished default prompt
+ tag allows some useful prompt and abort idioms, discussed in the next
+-section.
++section. Note that @code{default-prompt-tag} is actually a parameter,
++and so may be dynamically rebound using @code{parameterize}.
++@xref{Parameters}.
+ @end deffn
+
+-@deffn {Scheme Procedure} abort-to-prompt tag val ...
++@deffn {Scheme Procedure} abort-to-prompt tag val1 val2 @dots{}
+ Unwind the dynamic and control context to the nearest prompt named @var{tag},
+ also passing the given values.
+ @end deffn
+@@ -557,9 +577,58 @@
+
+ Before moving on, we should mention that if the handler of a prompt is a
+ @code{lambda} expression, and the first argument isn't referenced, an abort to
+-that prompt will not cause a continuation to be reified. This can be an
++that prompt will not cause a continuation to be reified. This can be an
+ important efficiency consideration to keep in mind.
+
++@cindex continuation, escape
++One example where this optimization matters is @dfn{escape
++continuations}. Escape continuations are delimited continuations whose
++only use is to make a non-local exit---i.e., to escape from the current
++continuation. Such continuations are invoked only once, and for this
++reason they are sometimes called @dfn{one-shot continuations}. A common
++use of escape continuations is when throwing an exception
++(@pxref{Exceptions}).
++
++The constructs below are syntactic sugar atop prompts to simplify the
++use of escape continuations.
++
++@deffn {Scheme Procedure} call-with-escape-continuation proc
++@deffnx {Scheme Procedure} call/ec proc
++Call @var{proc} with an escape continuation.
++
++In the example below, the @var{return} continuation is used to escape
++the continuation of the call to @code{fold}.
++
++@lisp
++(use-modules (ice-9 control)
++ (srfi srfi-1))
++
++(define (prefix x lst)
++ ;; Return all the elements before the first occurrence
++ ;; of X in LST.
++ (call/ec
++ (lambda (return)
++ (fold (lambda (element prefix)
++ (if (equal? element x)
++ (return (reverse prefix)) ; escape `fold'
++ (cons element prefix)))
++ '()
++ lst))))
++
++(prefix 'a '(0 1 2 a 3 4 5))
++@result{} (0 1 2)
++@end lisp
++@end deffn
++
++@deffn {Scheme Syntax} let-escape-continuation k body @dots{}
++@deffnx {Scheme Syntax} let/ec k body @dots{}
++Bind @var{k} within @var{body} to an escape continuation.
++
++This is equivalent to
++@code{(call/ec (lambda (@var{k}) @var{body} @dots{}))}.
++@end deffn
++
++
+ @node Shift and Reset
+ @subsubsection Shift, Reset, and All That
+
+@@ -599,8 +668,9 @@
+ Likewise there is an abbreviation for @code{abort-to-prompt}, which
+ assumes the default prompt tag:
+
+-@deffn {Scheme Procedure} abort val...
+-Abort to the default prompt tag, passing @var{val...} to the handler.
++@deffn {Scheme Procedure} abort val1 val2 @dots{}
++Abort to the default prompt tag, passing @var{val1} @var{val2} @dots{}
++to the handler.
+ @end deffn
+
+ As mentioned before, @code{(ice-9 control)} also provides other
+@@ -627,19 +697,22 @@
+ operator is @dfn{+F+}. @code{shift} and @code{reset} are such
+ operators.
+
+-@deffn {Scheme Syntax} reset body...
+-Establish a prompt, and evaluate @var{body...} within that prompt.
++@deffn {Scheme Syntax} reset body1 body2 @dots{}
++Establish a prompt, and evaluate @var{body1} @var{body2} @dots{} within
++that prompt.
+
+ The prompt handler is designed to work with @code{shift}, described
+ below.
+ @end deffn
+
+-@deffn {Scheme Syntax} shift cont body...
+-Abort to the nearest @code{reset}, and evaluate @var{body...} in a
+-context in which the captured continuation is bound to @var{cont}.
+-
+-As mentioned above, both the @var{body...} expression and invocations of
+-@var{cont} implicitly establish a prompt.
++@deffn {Scheme Syntax} shift cont body1 body2 @dots{}
++Abort to the nearest @code{reset}, and evaluate @var{body1} @var{body2}
++@dots{} in a context in which the captured continuation is bound to
++@var{cont}.
++
++As mentioned above, taken together, the @var{body1} @var{body2} @dots{}
++expressions and the invocations of @var{cont} implicitly establish a
++prompt.
+ @end deffn
+
+ Interested readers are invited to explore Oleg Kiselyov's wonderful web
+@@ -803,7 +876,7 @@
+ parameters.
+
+ @rnindex values
+-@deffn {Scheme Procedure} values arg1 @dots{} argN
++@deffn {Scheme Procedure} values arg @dots{}
+ @deffnx {C Function} scm_values (args)
+ Delivers all of its arguments to its continuation. Except for
+ continuations created by the @code{call-with-values} procedure,
+@@ -817,12 +890,27 @@
+ @var{args}, so @var{args} should not be modified subsequently.
+ @end deffn
+
+-@deffn {C Function} scm_c_value_ref (values, idx)
++@deftypefn {C Function} SCM scm_c_values (SCM *base, size_t n)
++@code{scm_c_values} is an alternative to @code{scm_values}. It creates
++a new values object, and copies into it the @var{n} values starting from
++@var{base}.
++
++Currently this creates a list and passes it to @code{scm_values}, but we
++expect that in the future we will be able to use more a efficient
++representation.
++@end deftypefn
++
++@deftypefn {C Function} size_t scm_c_nvalues (SCM obj)
++If @var{obj} is a multiple-values object, returns the number of values
++it contains. Otherwise returns 1.
++@end deftypefn
++
++@deftypefn {C Function} SCM scm_c_value_ref (SCM obj, size_t idx)
+ Returns the value at the position specified by @var{idx} in
+-@var{values}. Note that @var{values} will ordinarily be a
++@var{obj}. Note that @var{obj} will ordinarily be a
+ multiple-values object, but it need not be. Any other object
+ represents a single value (itself), and is handled appropriately.
+-@end deffn
++@end deftypefn
+
+ @rnindex call-with-values
+ @deffn {Scheme Procedure} call-with-values producer consumer
+@@ -948,6 +1036,11 @@
+ This manual prefers to speak of throwing and catching exceptions, since
+ this terminology matches the corresponding Guile primitives.
+
++The exception mechanism described in this section has connections with
++@dfn{delimited continuations} (@pxref{Prompts}). In particular,
++throwing an exception is akin to invoking an @dfn{escape continuation}
++(@pxref{Prompt Primitives, @code{call/ec}}).
++
+
+ @node Catch
+ @subsubsection Catching Exceptions
+@@ -1220,10 +1313,10 @@
+ of exception should specify the additional arguments that are expected
+ for that kind of exception.
+
+-@deffn {Scheme Procedure} throw key . args
++@deffn {Scheme Procedure} throw key arg @dots{}
+ @deffnx {C Function} scm_throw (key, args)
+-Invoke the catch form matching @var{key}, passing @var{args} to the
+-@var{handler}.
++Invoke the catch form matching @var{key}, passing @var{arg} @dots{} to
++the @var{handler}.
+
+ @var{key} is a symbol. It will match catches of the same symbol or of
+ @code{#t}.
+@@ -1312,9 +1405,9 @@
+ conditions that are implemented on top of the exception primitives just
+ described.
+
+-@deffn {Scheme Procedure} error msg args @dots{}
++@deffn {Scheme Procedure} error msg arg @dots{}
+ Raise an error with key @code{misc-error} and a message constructed by
+-displaying @var{msg} and writing @var{args}.
++displaying @var{msg} and writing @var{arg} @enddots{}.
+ @end deffn
+
+ @deffn {Scheme Procedure} scm-error key subr message args data
+@@ -1696,8 +1789,8 @@
+ @deftypefnx {C Function} void scm_wrong_type_arg (char *@var{subr}, int
@var{argnum}, SCM @var{bad_value})
+ @deftypefnx {C Function} void scm_wrong_type_arg_msg (char *@var{subr}, int
@var{argnum}, SCM @var{bad_value}, const char *@var{expected})
+ @deftypefnx {C Function} void scm_memory_error (char *@var{subr})
+-Throw an error with the various keys described above.
+ @deftypefnx {C Function} void scm_misc_error (const char *@var{subr}, const
char *@var{message}, SCM @var{args})
++Throw an error with the various keys described above.
+
+ In @code{scm_wrong_num_args}, @var{proc} should be a Scheme symbol
+ which is the name of the procedure incorrectly invoked. The other
+Index: b/doc/r5rs/r5rs.texi
+===================================================================
+--- a/doc/r5rs/r5rs.texi 2012-01-30 21:36:48.000000000 +0000
++++ b/doc/r5rs/r5rs.texi 2013-05-13 13:01:44.717134944 +0000
+@@ -114,6 +114,8 @@
+ @c [For the macros in R5RS -RK]
+
+
++@end titlepage
++
+
+
+ @unnumbered Summary
+@@ -177,8 +179,6 @@
+
+ @page
+
+-@end titlepage
+-
+ @c INFO first page
+ @ifnottex
+
