Add support for riscv64 platform.

Update to recently found large Mersenne prime.

Support MIPS release 6.

MIPS release 6 is not full compatible with the previous releases, it removes
some instructions and changes encoding of some instruction.
the `multu' is included.

MIPS r6 drops `lo' and `hi' registers, and then removes `multu'/`mfhi'/`mflo'.
Instead it uses `mulu' to compute the low part and `muhu' to compute
the high part.

Update known-to-work-with compilers.

And while at it, remove some workarounds for ancient compilers.

Update to recently found large Mersenne prime.

Finalize CLN 1.3.4 release.

Remove workarounds for obsolete compilers.

Fix support for Mips*.

Patch by YunQiang Su <wzssyqa@gmail.com> (cf. Debian bug#748325).

Janitorial clean-up.

Remove some unused variables and convert files with CRNL line endings
to files with NL line endings.

Make float_format(uintE) more precise.

Due to a typo in the binary representation lfo ln(10)/ln(2), this
function could preduce slightly wrong sizes for really huge arguments.

Fix floating-point input from decimal string.

A bug was introduced in 3480230e: The divide-and-conquer method multiplies
with a power of the base, but this power is one too much if there is a
decimal point. This may happen because digits_to_I(...) is also called
from read_float(...). As a result, the number containd spurious zeros
(in the base used for reading it).

Thanks to Thomas Luthe <tluthe@physik.uni-bielefeld.de>.

Use 8-byte word alignment on arm64.

The previous patch cb76b5eb used 4-byte word alignment.
Thanks to Peter Green and Hector Oron for pointing out that
8-byte alignment should be used (cf. Debian bug #757623).

Fix support for Mips64.

Yunquiang Su <wzssyqa@gmail.com> proposed to use 64 bit [su]intD and
long [su]intC on mips64 and mips64el.

While at it, cleaned up the AArch64 definitions from cb76b5eb.

Add AArch64 support.

While building Fedora 21 for AArch64 we found out that your software is
not building for us. Attached is a fix which adds this architecture in
all required places.

Revert "Convert complex numbers to real numbers if imaginary part is floating-point 0.0."

This reverts commit 536a0ac50f6c90198982267943af4d551612a9d9.

Cf. <http://www.ginac.de/pipermail/ginac-devel/2014-January/002086.html/>.

Convert complex numbers to real numbers if imaginary part is floating-point 0.0.

This conversion worked only for rational imaginary parts.

Minor fixes for recent CLang.

Needed for CLang 3.2.

Add subdir-objects to Automake options.

This option is needed to keep automake 1.14 happy.

Finalize CLN 1.3.3 release.

* Removed some obsolete Makefile.devel.
* Updated autoconf tools.
* Updated version and copyright information.

Avoid compiler warning.

Support for Texinfo-5.0.

Changed some @itemx into @item. Surround the "Detailed Node Listing"
section of the info page menu with @detailmenu flag.

Support x32 ABI.

Fix autoconf test checking whether mp_limb_t needs to be long long,
which is needed on x32.

Update to recently found large Mersenne prime.

Fix some conversions to cl_SF, cl_FF, and cl_DF.

Some conversions failed to properly overflow/underflow with very large
exponents because of premature exponent truncation.

Fix integer input with leading zeros in power-of-two base.

Reading leading '0' characters in integers of base 2, 4, 8, 16, or 32
could result in a NUDS with leading zero digits. This is against the
rules. The result was a misbehaving cl_I down the road.

Thanks to Morgan Deters <mdeters@cs.nyu.edu> of the CVC4 team.

Detect s390x and sparc64 as 32-bit architectures.

CLN fails to build on s390x and sparc64 as it detects them as 32-bit
architectures, due to __s390__ and __sparc__ matching respectively both
s390 and s390x, and both sparc and sparc64. The patch below fixes the
issue. (Reported as Debian bug#639494.)

Thanks to Aurelien Jarno <aurel32@debian.org>.

Avoid input stream fail state when reading number at EOF.

istream::get() puts the stream in fail state when trying to read at
EOF. This is best avoided by first peek()ing what is available.

Fix bug in converting cl_LF to float, double.

Finalize CLN 1.3.2 release.

Fix scale_float for large factors on x86.

The routine scale_float(cl_LF, cl_I) in file cl_LF_scale_I.cc had not
been adapted to 64-bit exponents on systems where uintD is 32 bit.

Reported by Michael Miller <millermj@lemoyne.edu>.

Update documentation about infrastructure requirements.

Support for MSVC.

This patch works around problems MSVC has with extern "C" declarations
inside namespace cln. As a result, it should work with MS 32-bit compiler
version 16.00.30319.01.

Thanks to Jan Rheinländer <jrheinlaender@gmx.de>.

Fix yet another dependent base C++ language issue.

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.