January 2008 - CLN-list

CLN 1.2.0
by Richard B. Kreckel 11 Feb '08

11 Feb '08

Hi, I am releasing CLN-1.2.0. This took much longer than I hoped it would, mainly because the focus of this release has been to support huge numbers, i.e. those with billions of decimal digits. And turnaround times when testing, debugging and benchmarking programs operating on numbers several GiB in size can be rather stultifying. Another major change is the introduction of C++ exceptions for error handling. The cl_abort() hook is not supported any more. This allows for much more flexible error handling on the side of your application. Please refer to the documentation to learn about existing exception types. Also, some types have changed which might require that you have a look at your application code: [su]intC is used for counter loops, [su]intE for exponents of all floating-point numbers, and cl_boolean has been replaced with standard C++ bool. As is to be expected, if one pushes the limits of known digits, memory consumption becomes a critical issue. So, CLN 1.2.0's constants and transcendental functions are noticeably more memory efficient than in previous releases. There are two reasons for this: First, more use has been made of the streamed binary splitting implementation, only used casually in earlier versions: There, the rational series terms are not precomputed before starting the binary splitting algorithm but rather computed when they are needed. The second reason is that while performing the binary splitting, some intermediate integer results may become much larger than the result's precision warrants. As it turns out, that excess precision can simply be truncated by coercing the result into a cl_LF of appropriate length. Basically, this compresses the extra digits into the floating-point exponent. With some rational series, the savings are dramatic. As an extreme example, attached is a picture of the memory footprint when computing one million decimal digits of Euler's gamma. The red curve corresponds to CLN-1.1.x while the blue one to CLN 1.2.0. Here, making the operands smaller even saves computing time. The library has undergone tests with operands of billions of decimal digits and I have stopped finding errors many months ago. This makes me confident to trust a computation of over 1 billion decimal digits of Euler's constant gamma which took one week (and another week for a verification on another machine with even higher precision). Instead of pasting the result here, let me just write it in regexpese: decimal(gamma) =~ "0.57721566[0-9]{1001262760}39288477" According to Wikipedia [1] and Xavier Gourdon's list [2], this establishes the current world record. It more than eightfolds the previous world record by Alexander J. Yee and by the way confirms that earlier record's correctness. (I've emailed Mr. Gourdon, but he doesn't seem to be tracking numerical world records any more, so one cannot be so sure.) Oh, and last but not least, I should say a big THANK YOU to the people who made contributions to this release. You'll find the names in the ChangeLog. Enjoy -richy. [1] <http://en.wikipedia.org/wiki/Mathematical_constant> [2] <http://numbers.computation.free.fr/Constants/Gamma/gamma.html> [3] <http://numberworld.org/euler116m.html> -- Richard B. Kreckel <http://www.ginac.de/~kreckel/>

6 50

doc: "Obfuscating operators"
by Joerg Arndt 07 Feb '08

07 Feb '08

Regarding the entry "Obfuscating operators" in the doc: I strongly suggest to remove the section and enable the shortcut operators by default. People who do not want to use them don't have to. Giving a opinion as a fact is not very helpful. For me the shortcut operators as in a+=b are more readable than the long a=a+b form. You may want to keep the remark the in CLN there is no performance gain in using the shortcut forms so people who dislike them know they can stick to the long form without a performance penalty. cheers, jj

4 7

Re: [CLN-list] CLN on MacOS X
by Bruno Haible 23 Jan '08

23 Jan '08

Ron Garret wrote: > Doesn't work on OS X Leopard. I have the same problem under all > permutations: > > make SUBDIR=base/digitseq > /bin/sh ../libtool --mode=compile gcc -m64 -O -DUNDERSCORE -c > cl_asm_.s > gcc -m64 -O -DUNDERSCORE -c cl_asm_.s -fno-common -DPIC -o .libs/ > cl_asm_.o > cl_asm_.s:171:suffix or operands invalid for `push' > cl_asm_.s:182:suffix or operands invalid for `pop' > [More of the same] > cl_asm_.s:984:suffix or operands invalid for `pop' > cl_asm_.s:985:suffix or operands invalid for `pop' > make[3]: *** [cl_asm_.lo] Error 1 > make[2]: *** [base/digitseq.target] Error 2 > make[1]: *** [base.target] Error 2 > make: *** [all] Error 2 > > At first I thought this meant that CLN was hard-coded for 32-bits. > Maybe I need -DNO_ASM or something like that? -DNO_ASM will certainly work around it. But before you try that, can you show the set of the compiler's predefines? Like this: $ touch empty.c $ gcc -m64 -E -dM empty.c | sort | uniq | grep -v FLT_ | grep -v DBL_ And this: $ grep define include/cln/config.h (I'm suspecting a confusion between i386 and x86_64 at the preprocessor level.) Bruno

3 4

[PATCH][cln_1-1] Replace (some of) MAYBE_INLINEs with ISO C++ compliant equivalent
by Alexei Sheplyakov 19 Jan '08

19 Jan '08

ISO C++ demands (in 7.1.2.4) "If a function with external linkage is declared inline in one translation unit, it shall be declared inline in all translation units in which it appears; no diagnostic is required." MAYBE_INLINE violates this requirement. Moreover, it's pointless, since the compiler emits those functions anyway. This causes link errors on non-ELF platforms (such as woe32 and Darwin). Hence, I decided to replace MAYBE_INLINE with standard compliant (but more intrusive) code. Only fiew occurences of MAYBE_INLINE have been converted. However, this happens to be enough to build CLN as a woe32 DLL (after massive hacking of build scripts). --- src/complex/transcendental/cl_C_acosh.cc | 7 ++++--- src/complex/transcendental/cl_C_asinh_aux.cc | 11 ++++++----- src/complex/transcendental/cl_C_atanh_aux.cc | 10 ++++++---- src/float/dfloat/misc/cl_DF_signum.cc | 9 +++++++-- src/float/ffloat/misc/cl_FF_signum.cc | 10 ++++++++-- src/float/lfloat/misc/cl_LF_signum.cc | 9 +++++++-- src/float/misc/cl_F_signum.cc | 16 ++++++++++------ src/float/sfloat/misc/cl_SF_signum.cc | 9 +++++++-- src/integer/misc/cl_I_signum.cc | 9 +++++++-- src/integer/ring/cl_I_ring.cc | 5 ++++- src/rational/misc/cl_RA_signum.cc | 10 ++++++++-- src/rational/ring/cl_RA_ring.cc | 5 ++++- src/real/conv/cl_F_from_R_def.cc | 9 +++++++-- src/real/misc/cl_R_signum.cc | 19 ++++++++++++++----- 14 files changed, 99 insertions(+), 39 deletions(-) diff --git a/src/complex/transcendental/cl_C_acosh.cc b/src/complex/transcendental/cl_C_acosh.cc index 8c30669..f92989e 100644 --- a/src/complex/transcendental/cl_C_acosh.cc +++ b/src/complex/transcendental/cl_C_acosh.cc @@ -16,8 +16,9 @@ #include "cl_RA.h" #include "cln/float.h" -#undef MAYBE_INLINE -#define MAYBE_INLINE inline +#define INLINE static inline +#define INLINE_DECL(fcn) inline_ ## fcn +#define REALLY_INLINE __attribute__((always_inline)) #include "cl_F_from_R_def.cc" namespace cln { @@ -78,7 +79,7 @@ const cl_N acosh (const cl_N& z) } if (x < cl_I(-1)) { // x < -1 - var cl_F xf = cl_float(x); + var cl_F xf = inline_cl_float(x); var cl_F& x = xf; // x Float <= -1 // log(sqrt(x^2-1)-x), ein Float >=0, Imaginдrteil pi diff --git a/src/complex/transcendental/cl_C_asinh_aux.cc b/src/complex/transcendental/cl_C_asinh_aux.cc index 572c722..9d772c6 100644 --- a/src/complex/transcendental/cl_C_asinh_aux.cc +++ b/src/complex/transcendental/cl_C_asinh_aux.cc @@ -16,8 +16,9 @@ #include "cl_RA.h" #include "cln/float.h" -#undef MAYBE_INLINE -#define MAYBE_INLINE inline +#define INLINE static inline +#define INLINE_DECL(fcn) inline_ ## fcn +#define REALLY_INLINE __attribute__((always_inline)) #include "cl_F_from_R_def.cc" namespace cln { @@ -89,7 +90,7 @@ const cl_C_R asinh (const cl_R& x, const cl_R& y) return cl_C_R(0,scale_float(pi(),-1)); if (eq(y,-1)) // x=0, y=-1 -> v = -pi/2 return cl_C_R(0,-scale_float(pi(),-1)); - yf = cl_float(y); // y in Float umwandeln + yf = inline_cl_float(y); // y in Float umwandeln } else { DeclareType(cl_RT,y); // y Ratio @@ -99,7 +100,7 @@ const cl_C_R asinh (const cl_R& x, const cl_R& y) if (eq(numerator(y),-1)) // x=0, y=-1/2 -> v = -pi/6 return cl_C_R(0,-(pi()/6)); } - yf = cl_float(y); // y in Float umwandeln + yf = inline_cl_float(y); // y in Float umwandeln } } else { DeclareType(cl_F,y); @@ -135,7 +136,7 @@ const cl_C_R asinh (const cl_R& x, const cl_R& y) } if (eq(y,0)) { // y=0 - var cl_F xf = cl_float(x); // x in Float umwandeln + var cl_F xf = inline_cl_float(x); // x in Float umwandeln var cl_F& x = xf; // x Float if (zerop(x)) diff --git a/src/complex/transcendental/cl_C_atanh_aux.cc b/src/complex/transcendental/cl_C_atanh_aux.cc index 42cae75..90d5205 100644 --- a/src/complex/transcendental/cl_C_atanh_aux.cc +++ b/src/complex/transcendental/cl_C_atanh_aux.cc @@ -14,14 +14,16 @@ #include "cl_F_tran.h" #include "cl_R.h" -#undef MAYBE_INLINE -#define MAYBE_INLINE inline +#define INLINE static inline +#define INLINE_DECL(fcn) inline_ ## fcn +#define REALLY_INLINE __attribute__((always_inline)) #include "cl_F_from_R_def.cc" namespace cln { // Hilfsfunktion fьr atanh und atan: u+iv := artanh(x+iy). Liefert cl_C_R(u,v). +const cl_C_R atanh (const cl_R& x, const cl_R& y) __attribute__((flatten)); const cl_C_R atanh (const cl_R& x, const cl_R& y) { // Methode: @@ -56,7 +58,7 @@ const cl_C_R atanh (const cl_R& x, const cl_R& y) // x=0 -> u=0, v=atan(X=1,Y=y) (Fall y=0 ist inbegriffen) return cl_C_R(0, atan(1,y)); if (eq(y,0)) { - var cl_F xf = cl_float(x); // (float x) + var cl_F xf = inline_cl_float(x); // (float x) var cl_F& x = xf; // x Float if (zerop(x)) @@ -92,7 +94,7 @@ const cl_C_R atanh (const cl_R& x, const cl_R& y) var cl_F yf; if (rationalp(x)) { DeclareType(cl_RA,x); - yf = cl_float(y); + yf = inline_cl_float(y); xf = cl_float(x,yf); } else { DeclareType(cl_F,x); diff --git a/src/float/dfloat/misc/cl_DF_signum.cc b/src/float/dfloat/misc/cl_DF_signum.cc index 3101a93..524ad8f 100644 --- a/src/float/dfloat/misc/cl_DF_signum.cc +++ b/src/float/dfloat/misc/cl_DF_signum.cc @@ -15,11 +15,16 @@ #define MAYBE_INLINE inline #include "cl_DF_minusp.cc" #include "cl_DF_zerop.cc" +#ifndef INLINE2 +#define INLINE2 +#define REALLY_INLINE2 +#define INLINE2_DECL(name) name +#endif namespace cln { -MAYBE_INLINE2 -const cl_DF signum (const cl_DF& x) +INLINE2 const cl_DF INLINE2_DECL(signum) (const cl_DF& x) REALLY_INLINE2; +INLINE2 const cl_DF INLINE2_DECL(signum) (const cl_DF& x) { if (minusp(x)) { return cl_DF_minus1; } // x<0 -> -1.0 elif (zerop(x)) { return cl_DF_0; } // x=0 -> 0.0 diff --git a/src/float/ffloat/misc/cl_FF_signum.cc b/src/float/ffloat/misc/cl_FF_signum.cc index 69cb60e..6816012 100644 --- a/src/float/ffloat/misc/cl_FF_signum.cc +++ b/src/float/ffloat/misc/cl_FF_signum.cc @@ -16,10 +16,16 @@ #include "cl_FF_minusp.cc" #include "cl_FF_zerop.cc" +#ifndef INLINE2 +#define INLINE2 +#define REALLY_INLINE2 +#define INLINE2_DECL(name) name +#endif + namespace cln { -MAYBE_INLINE2 -const cl_FF signum (const cl_FF& x) +INLINE2 const cl_FF INLINE2_DECL(signum) (const cl_FF& x) REALLY_INLINE2; +INLINE2 const cl_FF INLINE2_DECL(signum) (const cl_FF& x) { if (minusp(x)) { return cl_FF_minus1; } // x<0 -> -1.0 elif (zerop(x)) { return cl_FF_0; } // x=0 -> 0.0 diff --git a/src/float/lfloat/misc/cl_LF_signum.cc b/src/float/lfloat/misc/cl_LF_signum.cc index eae4705..a0d31b1 100644 --- a/src/float/lfloat/misc/cl_LF_signum.cc +++ b/src/float/lfloat/misc/cl_LF_signum.cc @@ -16,11 +16,16 @@ #define MAYBE_INLINE inline #include "cl_LF_minusp.cc" #include "cl_LF_zerop.cc" +#ifndef INLINE2 +#define INLINE2 +#define REALLY_INLINE2 +#define INLINE2_DECL(name) name +#endif namespace cln { -MAYBE_INLINE2 -const cl_LF signum (const cl_LF& x) +INLINE2 const cl_LF INLINE2_DECL(signum) (const cl_LF& x) REALLY_INLINE2; +INLINE2 const cl_LF INLINE2_DECL(signum) (const cl_LF& x) { if (zerop(x)) { return x; } // x=0 -> 0.0 else // je nach Vorzeichen von x diff --git a/src/float/misc/cl_F_signum.cc b/src/float/misc/cl_F_signum.cc index 0b51f9e..08ba0b6 100644 --- a/src/float/misc/cl_F_signum.cc +++ b/src/float/misc/cl_F_signum.cc @@ -11,8 +11,12 @@ #include "cl_F.h" -#undef MAYBE_INLINE2 -#define MAYBE_INLINE2 inline +#undef INLINE2 +#undef INLINE2_DECL +#undef REALLY_INLINE2 +#define INLINE2 static inline +#define INLINE2_DECL(name) inline_ ## name +#define REALLY_INLINE2 __attribute__((always_inline)) #include "cl_SF_signum.cc" #include "cl_FF_signum.cc" #include "cl_DF_signum.cc" @@ -23,10 +27,10 @@ namespace cln { const cl_F signum (const cl_F& x) { floatcase(x - , return signum(x); - , return signum(x); - , return signum(x); - , return signum(x); + , return inline_signum(x); + , return inline_signum(x); + , return inline_signum(x); + , return inline_signum(x); ); } diff --git a/src/float/sfloat/misc/cl_SF_signum.cc b/src/float/sfloat/misc/cl_SF_signum.cc index b1239da..1374727 100644 --- a/src/float/sfloat/misc/cl_SF_signum.cc +++ b/src/float/sfloat/misc/cl_SF_signum.cc @@ -15,11 +15,16 @@ #define MAYBE_INLINE inline #include "cl_SF_minusp.cc" #include "cl_SF_zerop.cc" +#ifndef INLINE2 +#define INLINE2 +#define REALLY_INLINE2 +#define INLINE2_DECL(name) name +#endif namespace cln { -MAYBE_INLINE2 -const cl_SF signum (const cl_SF& x) +INLINE2 const cl_SF INLINE2_DECL(signum) (const cl_SF& x) REALLY_INLINE2; +INLINE2 const cl_SF INLINE2_DECL(signum) (const cl_SF& x) { if (minusp(x)) { return SF_minus1; } // x<0 -> -1.0 elif (zerop(x)) { return SF_0; } // x=0 -> 0.0 diff --git a/src/integer/misc/cl_I_signum.cc b/src/integer/misc/cl_I_signum.cc index bbd236a..7a8a8c9 100644 --- a/src/integer/misc/cl_I_signum.cc +++ b/src/integer/misc/cl_I_signum.cc @@ -10,11 +10,16 @@ // Implementation. #include "cl_I.h" +#ifndef INLINE +#define INLINE +#define REALLY_INLINE +#define INLINE_DECL(name) name +#endif namespace cln { -MAYBE_INLINE -const cl_I signum (const cl_I& x) +INLINE const cl_I INLINE_DECL(signum) (const cl_I& x) REALLY_INLINE; +INLINE const cl_I INLINE_DECL(signum) (const cl_I& x) { if (minusp(x)) { return -1; } // x<0 -> -1 elif (zerop(x)) { return 0; } // x=0 -> 0 diff --git a/src/integer/ring/cl_I_ring.cc b/src/integer/ring/cl_I_ring.cc index 0f4e6d7..c8538ef 100644 --- a/src/integer/ring/cl_I_ring.cc +++ b/src/integer/ring/cl_I_ring.cc @@ -13,7 +13,9 @@ CL_PROVIDE(cl_I_ring) #include "cln/integer.h" #include "cln/integer_io.h" +#define zerop inline_zerop #include "cl_I.h" +#undef zerop namespace cln { @@ -34,10 +36,11 @@ static const _cl_ring_element I_zero (cl_heap_ring* R) return _cl_ring_element(R, (cl_I)0); } +static cl_boolean I_zerop (cl_heap_ring* R, const _cl_ring_element& x) __attribute__((flatten)); static cl_boolean I_zerop (cl_heap_ring* R, const _cl_ring_element& x) { unused R; - return zerop(The(cl_I)(x)); + return inline_zerop(The(cl_I)(x)); } static const _cl_ring_element I_plus (cl_heap_ring* R, const _cl_ring_element& x, const _cl_ring_element& y) diff --git a/src/rational/misc/cl_RA_signum.cc b/src/rational/misc/cl_RA_signum.cc index 40f5380..fc80077 100644 --- a/src/rational/misc/cl_RA_signum.cc +++ b/src/rational/misc/cl_RA_signum.cc @@ -11,11 +11,17 @@ #include "cl_RA.h" #include "cl_I.h" +#ifndef INLINE +#define INLINE +#define REALLY_INLINE +#define INLINE_DECL(name) name +#endif + namespace cln { -MAYBE_INLINE -const cl_RA signum (const cl_RA& x) +INLINE const cl_RA INLINE_DECL(signum) (const cl_RA& x) REALLY_INLINE; +INLINE const cl_RA INLINE_DECL(signum) (const cl_RA& x) { if (minusp(x)) { return -1; } // x<0 -> -1 elif (zerop(x)) { return 0; } // x=0 -> 0 diff --git a/src/rational/ring/cl_RA_ring.cc b/src/rational/ring/cl_RA_ring.cc index a6aef66..420c87d 100644 --- a/src/rational/ring/cl_RA_ring.cc +++ b/src/rational/ring/cl_RA_ring.cc @@ -13,7 +13,9 @@ CL_PROVIDE(cl_RA_ring) #include "cln/rational.h" #include "cln/rational_io.h" +#define zerop inline_zerop #include "cl_RA.h" +#undef zerop namespace cln { @@ -34,10 +36,11 @@ static const _cl_ring_element RA_zero (cl_heap_ring* R) return _cl_ring_element(R, (cl_RA)0); } +static cl_boolean RA_zerop (cl_heap_ring* R, const _cl_ring_element& x) __attribute__((flatten)); static cl_boolean RA_zerop (cl_heap_ring* R, const _cl_ring_element& x) { unused R; - return zerop(The(cl_RA)(x)); + return inline_zerop(The(cl_RA)(x)); } static const _cl_ring_element RA_plus (cl_heap_ring* R, const _cl_ring_element& x, const _cl_ring_element& y) diff --git a/src/real/conv/cl_F_from_R_def.cc b/src/real/conv/cl_F_from_R_def.cc index 3c8e852..01d1082 100644 --- a/src/real/conv/cl_F_from_R_def.cc +++ b/src/real/conv/cl_F_from_R_def.cc @@ -10,11 +10,16 @@ // Implementation. #include "cl_R.h" +#ifndef INLINE +#define INLINE +#define INLINE_DECL(decl) decl +#define REALLY_INLINE +#endif namespace cln { -MAYBE_INLINE -const cl_F cl_float (const cl_R& x) +INLINE const cl_F INLINE_DECL(cl_float) (const cl_R& x) REALLY_INLINE; +INLINE const cl_F INLINE_DECL(cl_float) (const cl_R& x) { if (rationalp(x)) { DeclareType(cl_RA,x); diff --git a/src/real/misc/cl_R_signum.cc b/src/real/misc/cl_R_signum.cc index f151d6c..b225639 100644 --- a/src/real/misc/cl_R_signum.cc +++ b/src/real/misc/cl_R_signum.cc @@ -11,12 +11,20 @@ #include "cl_R.h" -#undef MAYBE_INLINE -#define MAYBE_INLINE inline +#undef INLINE +#undef REALLY_INLINE +#undef INLINE_DECL +#define INLINE static inline +#define REALLY_INLINE __attribute__((always_inline)) +#define INLINE_DECL(name) inline_ ## name #include "cl_I_signum.cc" #include "cl_RA_signum.cc" -#undef MAYBE_INLINE2 -#define MAYBE_INLINE2 inline +#undef INLINE2 +#undef INLINE2_DECL +#undef REALLY_INLINE2 +#define INLINE2 static inline +#define INLINE2_DECL(name) inline_ ## name +#define REALLY_INLINE2 __attribute__((always_inline)) #include "cl_SF_signum.cc" #include "cl_FF_signum.cc" #include "cl_DF_signum.cc" @@ -24,7 +32,8 @@ namespace cln { +const cl_R signum (const cl_R& x) __attribute__((flatten)); const cl_R signum (const cl_R& x) -GEN_R_OP1_7(x, signum, return) +GEN_R_OP1_7(x, inline_signum, return) } // namespace cln -- 1.5.3.7 Best regards, Alexei -- All science is either physics or stamp collecting.

3 13

building documentation from CVS
by Alexei Sheplyakov 15 Jan '08

15 Jan '08

Hello! Is there any way to build the documentation with standard tools? doc/Makefile.in 55 ${srcdir}/${PACKAGE}.texi : ${srcdir}/${PACKAGE}.tex 56 cp $< $@ 57 ${EMACS} -batch $@ -load addnodes.el -f save-buffer Or I really have to install that monster? Best regards, Alexei -- All science is either physics or stamp collecting.

2 1

future GCC 4.3 and modules.h
by Ralf Wildenhues 10 Jan '08

10 Jan '08

Hello CLN people, Consider this code snippet: extern "C" void func () {} __asm__("\t.globl " "_GLOBAL__I_" "func"); static struct S { inline S () { } } S; On x86_64, with `g++-4.2 -fPIC -c a.cc', this results in | 0000000000000032 T _GLOBAL__I_func with mainline GCC (what will eventually be 4.3 or some other number), it has | 0000000000000032 t _GLOBAL__I_a.cc (and of course that will be `T' with the appropriate .globl directive). This affects .libs/cl_DF_globals.o and some of the other globals objects, and causes a link failure of the examples due to the CL_REQUIRE undefined references (global constructor keyed to ...). The hack below makes things work with mainline, but still needs to be redone properly, with a configure-time check and so on to not regress on g++ <= 4.2. If you like I can take a stab at writing so; I assume the test should make use of $lt_compiler_pic_CXX and the header file provide different defines based on whether -DPIC was given? (I'm not all that experienced with this stuff, so pointers are greatly appreciated.) Cheers, Ralf Index: include/cln/modules.h =================================================================== RCS file: /home/cvs/cln/include/cln/modules.h,v retrieving revision 1.19 diff -u -r1.19 modules.h --- include/cln/modules.h 7 May 2006 21:05:24 -0000 1.19 +++ include/cln/modules.h 26 May 2007 16:44:38 -0000 @@ -219,7 +219,7 @@ }; \ static _CL_REQUIRE_CLASSNAME(module,__LINE__) \ _CL_REQUIRE_CLASSNAME(module##_requirer,__LINE__); - #else + #elif 0 // gcc-3.0 -fuse-cxa-atexit doesn't have a single per-module destructor // function anymore. Instead, for each object's static constructor it // executes, it pushes the corresponding object's destructor onto a list. @@ -255,9 +255,42 @@ }; \ static _CL_REQUIRE_CLASSNAME(module,__LINE__) \ _CL_REQUIRE_CLASSNAME(module##_requirer,__LINE__); - #endif #define _CL_REQUIRE_CLASSNAME(module,line) __CL_REQUIRE_CLASSNAME(module,line) #define __CL_REQUIRE_CLASSNAME(module,line) cl_module__##module##__##line + #else + #define CL_PROVIDE(module) \ + extern "C" void cl_module__##module##__ctorend (void); \ + CL_GLOBALIZE_JUMP_LABEL(cl_module__##module##__ctorend) \ + CL_GLOBALIZE_CTORDTOR_LABEL( \ + ASM_UNDERSCORE_PREFIX CL_GLOBAL_CONSTRUCTOR_PREFIX \ + #module ".cc") \ + static int cl_module__##module##__counter; \ + struct cl_module__##module##__controller { \ + inline cl_module__##module##__controller () \ + { if (cl_module__##module##__counter++) \ + { CL_JUMP_TO(cl_module__##module##__ctorend); } \ + } \ + }; \ + static cl_module__##module##__controller cl_module__##module##__ctordummy; + #define CL_PROVIDE_END(module) \ + struct cl_module__##module##__destroyer { \ + inline cl_module__##module##__destroyer () \ + { CL_OUTPUT_LABEL (ASM_UNDERSCORE_PREFIX "cl_module__" #module "__ctorend"); } \ + }; \ + static cl_module__##module##__destroyer cl_module__##module##__dtordummy; + #define CL_REQUIRE(module) \ + extern "C" void cl_module__##module##__ctor (void) \ + __asm__ (ASM_UNDERSCORE_PREFIX CL_GLOBAL_CONSTRUCTOR_PREFIX \ + #module ".cc"); \ + struct _CL_REQUIRE_CLASSNAME(module,__LINE__) { \ + inline _CL_REQUIRE_CLASSNAME(module,__LINE__) () \ + { cl_module__##module##__ctor (); } \ + }; \ + static _CL_REQUIRE_CLASSNAME(module,__LINE__) \ + _CL_REQUIRE_CLASSNAME(module##_requirer,__LINE__); + #define _CL_REQUIRE_CLASSNAME(module,line) __CL_REQUIRE_CLASSNAME(module,line) + #define __CL_REQUIRE_CLASSNAME(module,line) cl_module__##module##__##line +#endif #else #define CL_PROVIDE(module) #define CL_PROVIDE_END(module)

3 15