Fix compilation with clang.

This resolves some depending names that GCC generously accepts.

Thanks to Pawel Worach <pawel.worach@gmail.com>.

Configure: be more cross-compilation friendly.

Rewrite CL_GMP_SET_UINTD so it works for cross-compilation too.

Fix the documentation build failure (wrong texinfo).

Building PDF, PostScript, and DVI versions of the documentation fails
with the following error message(s):
../../doc/cln.texi:1170: Argument of @asis has an extra }.
<inserted text>
                @par
<to be read again>
                   }
According to texinfo maintainer @itemize @asis is illegal, one should
use @itemize @w{} instead.
See <http://lists.gnu.org/archive/html/bug-texinfo/2009-03/msg00016.html>.

Remove 'auto' keyword used as storage specifier.

That obsolete keyword is being rededicated in C++-0x to another use.

Finalize CLN 1.3.1 release.

Remove cl_null_string defintion.

It's been unused since the last release.

Add support for Renesas SH CPU (sh4).

This defines cl_word_alignment for sh4.
Thanks to Nobuhiro Iwamatsu <iwamatsu@nigauri.org>.

Fix double_approx(const cl_RA& x) on 64-Bit platforms.

When we extended immediate types on 64-bit platforms back for CLN
1.2.0, we broke the assumption that integers 2^53..2^55-1 are
bignums. This lead to segfaults when approximating a non-integer cl_RA
to double, as reported by Igor Khavkine <igor.kh@gmail.com>.

Finalize release 1.3.0.

Fix build breakage on Sparc.

With 7da4d3ae46279298acd5d65637499caab7b57071, the code that sed-converted
the $ to # in all the Sparc assembler files was removed. Let's hope that
we won't need it again.

Make the pi teaser program install.

Correctly forward-declare cl_print_* helpers.

cl_print_flags and friends were declared class in cln/io.h but class
elsewhere. Some compilers didn't like it.

Prepare for CLN 1.3.0 release.

Set version number and update copyright strings.

Prefer GMP's multiplication routine (if GMP version >= 4.0).

Recent GMP multiplication routines (mpn_mul) are somewhat faster than CLN's.
For huge operands, this is due to better tuned FFT. For medium-sized operands
it's due to more algorithms (Toom 3-way.) For small operands, I couldn't find
a difference. Let's just use mpn_mul if it's available.

For huge binsplit sums, this can half the runtimes, on amd64.

Git-ify some documentation.

We don't need that ChangeLog any more, since git already provides a patchset view.

Override automake's DEFAULT_INCLUDES.

Automake adds all kinds of subdirectories to -I, the list of directories
to be searched for header files. However, CLN's header files are not
supposed to be included without the cln/ subdirectory, so adding
-Iinclude/cln can lead to conflicts with other header files. (The
problem at hand was a conflict between CLN's string.h and the C
library's string.h).

Fix compilation with GCC 4.4.

Use std::iostream functions instead of EOF and cl_EOF macros.
This enables us to get rid of the freadchar and funreadchar functions.
While at it, removed the extra signatures introduced for CLN-1.2.0
compatibilty. After all, the soname has been bumped.

Also updated largest known Mersenne prime in examples/perfnum.cc.

[build] Added some files to DISTCLEANFILES to please `make distcheck'.

[build] Correctly set CLN version for auto* tools.

The only effect of this change is correct tarball name. There's no actual
code changes.

List all source files so CLN builds from tarballs produced by 'make dist'.

build scripts: automatically set proper rpath for linking with GMP.

cl_asm_GF2.cc: fix compilation error on SPARC.

The code itself seems to be broken, so probably I should remove it...

build: require automake version at least 1.10

Previous versions don't define MKDIR_P and some other useful things. Since
automake 1.10 was released 2+ years ago this requirment is reasonable.

[BUGFIX] cln/config.h: fix include guard.

[BUGFIX]: cl_asm_.cc: fix include paths.

Proper fix would be to remove that file. YMMV, but on "modern" CPUs (k7,
pentium[234], k8) gcc generated code works 1.5 -- 2 times faster.

cl_{GV,SV}: use std::size_t for size of vectors (instead of obscure uintC).

Equip vectors (cl_[SG]V_*) with STL-alike size() method.

build: define EXTRA_PROGRAMS to shut up automake warnings.

Fix programs for timing 2-adic operations: tests/time{div,recip}2adic.cc

At least they compile and run now. TODO: deobfuscate the code and provide
helpful usage messages.

[bugfix] Actually compile in version info into the library.

src/base/cl_version.cc: don't #include "cl_sysdep.h", so the version info
actually gets compiled into the library.

Due to the changes introduced in 7da4d3ae ("build: switch to ordinary auto*
tools system") including "cln/version.h" after "cl_config.h" is no-op (yes,
this is intended).

[bugfix] build: generate cl_config.h properly.

cl_config.h file was useless due to stupid typo (#ifdef instead of #ifndef,
introduced in 7da4d3ae). Fix it.

benchmarks: time{catalan,euler,exp1,zeta3}.cc actually compile and work now.

These benchmarks use internal CLN functions. Even worse -- they expect to
find these functions in the global namespace. Declare internal CLN functions
in the namespace cln.

[bugfix] Public headers need GMP_DEMANDS_UINTD_* macros.

Put them back into cln/config.h.in (until a better solution is found).

Improve installation instructions.

[bugfix] install intparam.h (auto-generated) header.

Actually it's a bad idea to expose those defines to user, but CLN public
headers depend on them.

Remove libtool bits from the repository.

This makes packagers' life a bit easier.

don't expose configure generated headers to users.

Those HAVE_FOO collide with #define's introduced by a package which uses
CLN. The result is very funny (debugging this is not, though).

cln.texi: display copyright information in the info file, ...

... use @ifnottex instead of @ifinfo so relevant pages are included into
the HTML version of the manual.

tests: test_I_io: ignore read_integer() failures on woe32.

The test always fail on woe32, so ignore errors (but print relevant info).

build: compile benchmark programs too.

build: switch to ordinary auto* tools system.

Benefits:

1. If a header file gets modified, all dependent stuff gets rebuilt.
   No need for 'make clean' after each header modification, no more
   spurious errors, no more spurious rebuilds.
2. No more errors due to redefined preprocessor, compiler, and linker
   FLAGS.
3. Build scripts don't try to build every *.cc file which happen to
   lurk in the source directory.

tests: #include <iostream> and using namespace std; for std::cout and std::endl

Otherwise timing programs fail to compile.

Fix header paths braindamage in the tests directory too.

build: don't insist on turning on optimization.

Since there's no CL_REQUIRE/CL_PROVIDE junk any more, optimization is
not mandatory.

Use paths relative the `src' directory in the #include directives.

Typical CLN source file starts with

 // General includes.
 #include "cl_sysdep.h"

 // Specification.
 #include "cl_2DS.h"

 // Implementation.

 #include "cl_2D.h"
 #include "cl_DS.h"

It takes a while to figure out which files are included. So, use paths relative
to the `src' directory, like this:

 // General includes.
 #include "base/cl_sysdep.h"

 // Specification.
 #include "src/base/digitseq/cl_2DS.h"

 // Implementation.

 #include "base/digit/cl_2D.h"
 #include "base/digitseq/cl_DS.h"

This makes CLN less hacker hostile.

bump library version, since CLN doesn't export global object ctors any more.

Those cl_module__blah__firstglobalfun functions don't even exist any more.

remove CL_REQUIRE/CL_PROVIDE macro and associated autoconf tests.

Replace CL_REQUIRE/CL_PROVIDE(cl_UP) with portable code.

The order of initialization of non-local objects in different compilation units
is not specified in C++. Hence special care should be taken to avoid static
initialization order fiasco. CLN solved the problem with some evil (GCC
specific, and even GCC-version-specific) hack. Replace it with a technique
similar to one used in STL to initialize std::cout and friends.

Replace CL_REQUIRE/CL_PROVIDE(cl_UP_no_ring) with portable code.

The order of initialization of non-local objects in different compilation units
is not specified in C++. Hence special care should be taken to avoid static
initialization order fiasco. CLN solved the problem with some evil (GCC
specific, and even GCC-version-specific) hack. Replace it with a technique
similar to one used in STL to initialize std::cout and friends.

Replace CL_REQUIRE/CL_PROVIDE(cl_UP_named) with portable code.

The order of initialization of non-local objects in different compilation units
is not specified in C++. Hence special care should be taken to avoid static
initialization order fiasco. CLN solved the problem with some evil (GCC
specific, and even GCC-version-specific) hack. Replace it with a technique
similar to one used in STL to initialize std::cout and friends.

Replace CL_REQUIRE/CL_PROVIDE(cl_UP_unnamed) with portable code.

The order of initialization of non-local objects in different compilation units
is not specified in C++. Hence special care should be taken to avoid static
initialization order fiasco. CLN solved the problem with some evil (GCC
specific, and even GCC-version-specific) hack. Replace it with a technique
similar to one used in STL to initialize std::cout and friends.

Get rid CL_REQUIRE/CL_PROVIDE(cl_F_epsneg), it is not really necessary.

Move static variables [SFDL]F_negative_epsilon into LF_negative_epsilon()
function (which is the only user of those variables) in order to avoid
possible static order initialization problems. While at it, make
LF_negative_epsilon() function static.

Get rid CL_REQUIRE/CL_PROVIDE(cl_F_epspos), it is not really necessary.

Move static variables [SFDL]F_epsilon into LF_epsilon() function (which
is the only user of those variables) in order to avoid possible static
order initialization problems. While at it, make LF_epsilon() function
static.

Get rid CL_REQUIRE/CL_PROVIDE(cl_F_leastneg), it is not really necessary.

Move static variables least_negative_[SFDL]F into least_negative_LF() function
(which is the only user of those variables) in order to avoid possible static
order initialization problems. While at it, make least_negative_LF() function
static.

Get rid CL_REQUIRE/CL_PROVIDE(cl_F_leastpos), it is not really necessary.

Move static variables least_positive_[SFDL]F into least_positive_LF() function
(which is the only user of those variables) in order to avoid possible static
order initialization problems. While at it, make least_positive_LF() function
static.

Get rid CL_REQUIRE/CL_PROVIDE(cl_F_mostneg), it is not really necessary.

Move static variables most_negative_[SFDL]F into most_negative_LF() function
(which is the only user of those variables) in order to avoid possible static
order initialization problems. While at it, make most_negative_LF() function
static.

Get rid CL_REQUIRE/CL_PROVIDE(cl_F_mostpos), it is not really necessary.

Move static variables most_positive_[SFDL]F into most_positive_LF() function
(which is the only user of those variables) in order to avoid possible static
order initialization problems. While at it, make most_positive_LF() function
static.

Get rid of CL_REQUIRE/CL_PROVIDE(cl_fmt_floatstring)...

The code doesn't seem to initialize any static objects at all.

Get rid of CL_REQUIRE/CL_PROVIDE(cl_F_catalanconst_var).

Turn cl_[SDFL]F_catalanconst global variables into functions (which return
a reference to the static value) in order to avoid static initialization
order problems.

Get rid of CL_REQUIRE/CL_PROVIDE(cl_F_eulerconst_var).

Turn cl_[SDFL]F_eulerconst global variables into functions (which return
a reference to the static value) in order to avoid static initialization
order problems.

Get rid of CL_REQUIRE/CL_PROVIDE(cl_F_exp1_var).

Turn cl_[SDFL]F_exp1 global variables into functions (which return a reference
to the static value) in order to avoid static initialization order problems.

Get rid of CL_REQUIRE/CL_PROVIDE(cl_F_ln10_var).

Turn cl_[SDFL]F_ln10 global variables into functions (which return a constant
reference to the static value) in order to avoid static initialization order
problems.

Get rid of CL_REQUIRE/CL_PROVIDE(cl_F_ln2_var).

Turn cl_[SDFL]F_ln2 global variables into functions (which return a constant
reference to the static value) in order to avoid static initialization order
problems.

Get rid of CL_REQUIRE/CL_PROVIDE(cl_F_pi_var).

Turn cl_[SDFL]F_pi global variables into functions (which return a constant
reference to the static value) in order to avoid static initialization order
problems.

Replace CL_REQUIRE/CL_PROVIDE(cl_GV_I) with portable code.

The order of initialization of non-local objects in different compilation units
is not specified in C++. Hence special care should be taken to avoid static
initialization order fiasco. CLN solved the problem with some evil (GCC
specific, and even GCC-version-specific) hack. Replace it with a technique
similar to one used in STL to initialize std::cout and friends.

Replace CL_REQUIRE/CL_PROVIDE(cl_GV_number) with portable code.

The order of initialization of non-local objects in different compilation units
is not specified in C++. Hence special care should be taken to avoid static
initialization order fiasco. CLN solved the problem with some evil (GCC
specific, and even GCC-version-specific) hack. Replace it with a technique
similar to one used in STL to initialize std::cout and friends.

Replace CL_REQUIRE/CL_PROVIDE(cl_SV_number) with portable code.

The order of initialization of non-local objects in different compilation units
is not specified in C++. Hence special care should be taken to avoid static
initialization order fiasco. CLN solved the problem with some evil (GCC
specific, and even GCC-version-specific) hack. Replace it with a technique
similar to one used in STL to initialize std::cout and friends.

Replace CL_REQUIRE/CL_PROVIDE(cl_SV_ringelt) with portable code.

The order of initialization of non-local objects in different compilation units
is not specified in C++. Hence special care should be taken to avoid static
initialization order fiasco. CLN solved the problem with some evil (GCC
specific, and even GCC-version-specific) hack. Replace it with a technique
similar to one used in STL to initialize std::cout and friends.

Get rid CL_REQUIRE/CL_PROVIDE(cl_fmt_scaleexp), it is not necessary.

Move a bunch of static objects (tenth, SF_zero, FF_zero, etc) into
the function get_float_params (which is the only user of those variables)
in order to avoid possible static order initialization problems.

Remove CL_REQUIRE/CL_PROVIDE(cl_I_doublefactorial) as it's unnecessary.

The only user of doublefakul_table array is doublefactorial function, so
put that array inside it in order to avoid possible static initialization
order problems.

Remove CL_REQUIRE/CL_PROVIDE(cl_I_factorial) as it's not really necessary.

factorial() is the only function which uses fakul_table[] array, so move
it into that function in order to avoid possible static initialization
order problems.

Replace CL_REQUIRE/CL_PROVIDE(cl_MI) with portable code.

The order of initialization of non-local objects in different compilation units
is not specified in C++. Hence special care should be taken to avoid static
initialization order fiasco. CLN solved the problem with some evil (GCC
specific, and even GCC-version-specific) hack. Replace it with a technique
similar to one used in STL to initialize std::cout and friends.

Replace CL_REQUIRE/CL_PROVIDE(cl_RA_ring) with portable code.

The order of initialization of non-local objects in different compilation units
is not specified in C++. Hence special care should be taken to avoid static
initialization order fiasco. CLN solved the problem with some evil (GCC
specific, and even GCC-version-specific) hack. Replace it with a technique
similar to one used in STL to initialize std::cout and friends.

Replace CL_REQUIRE/CL_PROVIDE(cl_I_ring) with portable code.

The order of initialization of non-local objects in different compilation units
is not specified in C++. Hence special care should be taken to avoid static
initialization order fiasco. CLN solved the problem with some evil (GCC
specific, and even GCC-version-specific) hack. Replace it with a technique
similar to one used in STL to initialize std::cout and friends.

Replace CL_REQUIRE/CL_PROVIDE(cl_R_ring) with portable code.

The order of initialization of non-local objects in different compilation units
is not specified in C++. Hence special care should be taken to avoid static
initialization order fiasco. CLN solved the problem with some evil (GCC
specific, and even GCC-version-specific) hack. Replace it with a technique
similar to one used in STL to initialize std::cout and friends.

Replace CL_REQUIRE/CL_PROVIDE(cl_LF_globals) with portable code.

The order of initialization of non-local objects in different compilation units
is not specified in C++. Hence special care should be taken to avoid static
initialization order fiasco. CLN solved the problem with some evil (GCC
specific, and even GCC-version-specific) hack. Replace it with a technique
similar to one used in STL to initialize std::cout and friends.

Replace CL_REQUIRE/CL_PROVIDE(cl_FF_globals) with portable code.

The order of initialization of non-local objects in different compilation units
is not specified in C++. Hence special care should be taken to avoid static
initialization order fiasco. CLN solved the problem with some evil (GCC
specific, and even GCC-version-specific) hack. Replace it with a technique
similar to one used in STL to initialize std::cout and friends.

Get rid of CL_REQUIRE/CL_PROVIDE(cl_ieee).

While at it, remove work around for ancient (fixed in 8+ years) glibc/Linux
bug (the kernel and/or libc was initializing FPU into non-IEEE mode, so division
by 0 resulted in SIGFPE instead of NaN).

Replace CL_REQUIRE/CL_PROVIDE(cl_DF_globals) with portable code.

The order of initialization of non-local objects in different compilation units
is not specified in C++. Hence special care should be taken to avoid static
initialization order fiasco. CLN solved the problem with some evil (GCC
specific, and even GCC-version-specific) hack. Replace it with a technique
similar to one used in STL to initialize std::cout and friends.

Replace CL_REQUIRE/CL_PROVIDE(cl_C_ring) with portable code.

The order of initialization of non-local objects in different compilation units
is not specified in C++. Hence special care should be taken to avoid static
initialization order fiasco. CLN solved the problem with some evil (GCC
specific, and even GCC-version-specific) hack. Replace it with a technique
similar to one used in STL to initialize std::cout and friends.

Replace CL_REQUIRE/CL_PROVIDE(cl_symbol) with portable code.

The order of initialization of non-local objects in different compilation units
is not specified in C++. Hence special care should be taken to avoid static
initialization order fiasco. CLN solved the problem with some evil (GCC
specific, and even GCC-version-specific) hack. Replace it with a technique
similar to one used in STL to initialize std::cout and friends.

Replace CL_REQUIRE/CL_PROVIDE(cl_st_null) with portable code.

The order of initialization of non-local objects in different compilation units
is not specified in C++. Hence special care should be taken to avoid static
initialization order fiasco. CLN solved the problem with some evil (GCC
specific, and even GCC-version-specific) hack. Replace it with a technique
similar to one used in STL to initialize std::cout and friends.

Replace CL_REQUIRE/CL_PROVIDE(cl_no_ring) with portable code.

The order of initialization of non-local objects in different compilation units
is not specified in C++. Hence special care should be taken to avoid static
initialization order fiasco. CLN solved the problem with some evil (GCC
specific, and even GCC-version-specific) hack. Replace it with a technique
similar to one used in STL to initialize std::cout and friends.

Replace CL_REQUIRE/CL_PROVIDE(cl_random_def) with portable code.

The order of initialization of non-local objects in different compilation units
is not specified in C++. Hence special care should be taken to avoid static
initialization order fiasco. CLN solved the problem with some evil (GCC
specific, and even GCC-version-specific) hack. Replace it with a technique
similar to one used in STL to initialize std::cout and friends.

Replace CL_REQUIRE/CL_PROVIDE(cl_prin_globals) with portable code.

The order of initialization of non-local objects in different compilation units
is not specified in C++. Hence special care should be taken to avoid static
initialization order fiasco. CLN solved the problem with some evil (GCC
specific, and even GCC-version-specific) hack. Replace it with a technique
similar to one used in STL to initialize std::cout and friends.

replace CL_REQUIRE/CL_PROVIDE(cl_0_ring) with (more) portable code.

The order of initialization of non-local objects in different compilation units
is not specified in C++. Hence special care should be taken to avoid static
initialization order fiasco. CLN solved the problem with some evil (GCC
specific, and even GCC-version-specific) hack. Replace it with a technique
similar to one used in STL to initialize std::cout and friends.

Correct typo in definition of binomial.

(Reported by Warren Weckesser.)

Remove support for K&R C compilers.

Fix sparc64 build with -DNO_ASM and reduce compiler warnings.

Fix last ChangeLog entry.

Fix a bug in FN_to_NDS in configurations where intDsize < intPsize.

Fix VPATH build [Alexei Sheplyakov].

Re-esatblish 1.2.0 ABI, broken 2008-02-22 [Alexei Sheplyakov].

* src/float/input/cl_F_readparsed.cc: Add obsolete signature with index
args uintL.
* src/integer/input/cl_I_readparsed.cc: Likewise.
* src/rational/input/cl_RA_readparsed.cc: Likewise.

Finalize release 1.2.2.

Prepare for Release 1.2.2.

Re-establish ABI, broken 2008-01-20.

* src/float/ffloat/conv/cl_FF_from_float.cc: Add obsolete signature of
cl_float_to_FF_pointer.
* src/float/dfloat/conv/cl_DF_from_double.cc: Add obsolete signature of
cl_double_to_DF_pointer.

Fix hack from 2008-01-20 that broke on ARM.

Finalize release 1.2.1.

New file, for recreating the build prerequisites after a CVS checkout.

Fix bug introduced on 2008-02-23.