Binary files cln-orig/.git/index and cln-patched/.git/index differ
diff -Nru cln-orig/.git/logs/HEAD cln-patched/.git/logs/HEAD
--- cln-orig/.git/logs/HEAD	2011-02-14 08:43:11.879277706 +0100
+++ cln-patched/.git/logs/HEAD	2011-02-12 21:38:46.802579001 +0100
@@ -1 +1 @@
-0000000000000000000000000000000000000000 93c3e3c856be7d4306f81eaf909ae97c44a936c5 Jan private <jan@jan-laptop.resap.iam> 1297669391 +0100	clone: from git://www.ginac.de/cln.git
+0000000000000000000000000000000000000000 93c3e3c856be7d4306f81eaf909ae97c44a936c5 Jan private <jan@jan-laptop.resap.iam> 1297543126 +0100	clone: from git://www.ginac.de/cln.git
diff -Nru cln-orig/.git/logs/refs/heads/master cln-patched/.git/logs/refs/heads/master
--- cln-orig/.git/logs/refs/heads/master	2011-02-14 08:43:11.879277706 +0100
+++ cln-patched/.git/logs/refs/heads/master	2011-02-12 21:38:46.802579001 +0100
@@ -1 +1 @@
-0000000000000000000000000000000000000000 93c3e3c856be7d4306f81eaf909ae97c44a936c5 Jan private <jan@jan-laptop.resap.iam> 1297669391 +0100	clone: from git://www.ginac.de/cln.git
+0000000000000000000000000000000000000000 93c3e3c856be7d4306f81eaf909ae97c44a936c5 Jan private <jan@jan-laptop.resap.iam> 1297543126 +0100	clone: from git://www.ginac.de/cln.git
diff -Nru cln-orig/src/base/cl_low.h cln-patched/src/base/cl_low.h
--- cln-orig/src/base/cl_low.h	2011-02-14 08:43:11.939277706 +0100
+++ cln-patched/src/base/cl_low.h	2011-02-13 21:11:34.471965001 +0100
@@ -202,7 +202,9 @@
 // > arg1, arg2 : zwei 32-Bit-Zahlen
 // < 2^32*hi+lo : eine 64-Bit-Zahl
   extern "C" uint32 mulu32_ (uint32 arg1, uint32 arg2); // -> Low-Teil
-  extern "C" uint32 mulu32_high;                        // -> High-Teil
+}  // namespace cln
+  extern "C" uint32 cln_mulu32_high;                        // -> High-Teil
+namespace cln {
 #if defined(__GNUC__) && defined(__m68k__) && !defined(NO_ASM)
   #define mulu32(x,y,hi_zuweisung,lo_zuweisung)  \
     ({ var uint32 _x = (x);       \
@@ -294,7 +296,7 @@
   #pragma aux mulu32_high_ = /* */ value [edx] modify [];
 #else
   #define mulu32(x,y,hi_zuweisung,lo_zuweisung)  \
-    { lo_zuweisung mulu32_(x,y); unused (hi_zuweisung mulu32_high); }
+    { lo_zuweisung mulu32_(x,y); unused (hi_zuweisung cln_mulu32_high); }
   #if (defined(__m68k__) || defined(__sparc__) || defined(__sparc64__) || defined(__arm__) || (defined(__i386__) && !defined(WATCOM) && !defined(MICROSOFT)) || defined(__x86_64__) || defined(__mips__) || defined(__hppa__)) && !defined(NO_ASM)
     // mulu32_ extern in Assembler
     #if defined(__sparc__) || defined(__sparc64__)
@@ -336,7 +338,9 @@
 // > arg1, arg2 : zwei 64-Bit-Zahlen
 // < 2^64*hi+lo : eine 128-Bit-Zahl
   extern "C" uint64 mulu64_ (uint64 arg1, uint64 arg2); // -> Low-Teil
-  extern "C" uint64 mulu64_high;                        // -> High-Teil
+}  // namespace cln
+  extern "C" uint64 cln_mulu64_high;                        // -> High-Teil
+namespace cln {
 #if defined(__GNUC__) && defined(__alpha__) && !defined(NO_ASM)
   #define mulu64(x,y,hi_zuweisung,lo_zuweisung)  \
     ({ var register uint64 _x = (x);	\
@@ -383,7 +387,7 @@
      })
 #else
   #define mulu64(x,y,hi_zuweisung,lo_zuweisung)  \
-    { lo_zuweisung mulu64_(x,y); hi_zuweisung mulu64_high; }
+    { lo_zuweisung mulu64_(x,y); hi_zuweisung cln_mulu64_high; }
   #if defined(__sparc64__) && !defined(NO_ASM)
     // mulu64_ extern in Assembler
     extern "C" uint64 _get_g2 (void);
@@ -424,7 +428,9 @@
   extern "C" uint32 divu_3216_1616_ (uint32 x, uint16 y); // -> Quotient q, Rest r
 #else
   extern "C" uint16 divu_3216_1616_ (uint32 x, uint16 y); // -> Quotient q
-  extern "C" uint16 divu_16_rest;                         // -> Rest r
+}  // namespace cln
+  extern "C" uint16 cln_divu_16_rest;                         // -> Rest r
+namespace cln {
 #endif
 #if defined(__GNUC__) && defined(__sparc64__) && !defined(NO_ASM)
   #define divu_3216_1616(x,y,q_zuweisung,r_zuweisung)  \
@@ -495,12 +501,12 @@
 #elif defined(__arm__) && !defined(NO_ASM)
   #define divu_3216_1616(x,y,q_zuweisung,r_zuweisung)  \
     { q_zuweisung divu_3216_1616_(x,y); /* extern in Assembler */	\
-      r_zuweisung divu_16_rest;						\
+      r_zuweisung cln_divu_16_rest;						\
     }
   #define NEED_VAR_divu_16_rest
 #else
   #define divu_3216_1616(x,y,q_zuweisung,r_zuweisung)  \
-    { q_zuweisung divu_3216_1616_(x,y); r_zuweisung divu_16_rest; }
+    { q_zuweisung divu_3216_1616_(x,y); r_zuweisung cln_divu_16_rest; }
   #define NEED_FUNCTION_divu_3216_1616_
 #endif
 
@@ -514,7 +520,9 @@
 // < uint16 r: x mod y
 // < x = q*y+r
   extern "C" uint32 divu_3216_3216_ (uint32 x, uint16 y); // -> Quotient q
-  extern "C" uint16 divu_16_rest;                         // -> Rest r
+}  // namespace cln
+  extern "C" uint16 cln_divu_16_rest;                         // -> Rest r
+namespace cln {
 #if defined(__GNUC__) && defined(__sparc64__) && !defined(NO_ASM)
   #define divu_3216_3216(x,y,q_zuweisung,r_zuweisung)  \
     ({var uint32 __x = (x);        \
@@ -564,7 +572,9 @@
 // < uint32 r: x mod y
 // < x = q*y+r
   extern "C" uint32 divu_3232_3232_ (uint32 x, uint32 y); // -> Quotient q
-  extern "C" uint32 divu_32_rest;                         // -> Rest r
+}  // namespace cln
+  extern "C" uint32 cln_divu_32_rest;                         // -> Rest r
+namespace cln {
 #if defined(__GNUC__) && defined(__sparc64__) && !defined(NO_ASM)
   #define divu_3232_3232(x,y,q_zuweisung,r_zuweisung)  \
     ({var uint32 __x = (x);        \
@@ -661,7 +671,9 @@
 // < uint32 r: x mod y
 // < x = q*y+r
   extern "C" uint32 divu_6432_3232_ (uint32 xhi, uint32 xlo, uint32 y); // -> Quotient q
-  extern "C" uint32 divu_32_rest;                                       // -> Rest r
+}  // namespace cln
+  extern "C" uint32 cln_divu_32_rest;                                       // -> Rest r
+namespace cln {
 #if defined(__GNUC__) && defined(__m68k__) && !defined(NO_ASM)
   #define divu_6432_3232(xhi,xlo,y,q_zuweisung,r_zuweisung)  \
     ({var uint32 __xhi = (xhi);						\
@@ -750,7 +762,7 @@
   #pragma aux divu_6432_3232_rest = /* */ value [edx] modify [];
 #else
   #define divu_6432_3232(xhi,xlo,y,q_zuweisung,r_zuweisung)  \
-    { q_zuweisung divu_6432_3232_(xhi,xlo,y); r_zuweisung divu_32_rest; }
+    { q_zuweisung divu_6432_3232_(xhi,xlo,y); r_zuweisung cln_divu_32_rest; }
   #if (defined(__m68k__) || defined(__sparc__) || defined(__sparc64__) || defined(__arm__) || (defined(__i386__) && !defined(WATCOM) && !defined(MICROSOFT)) || defined(__x86_64__) || defined(__hppa__)) && !defined(NO_ASM)
     // divu_6432_3232_ extern in Assembler
     #if defined(__sparc__) || defined(__sparc64__)
@@ -944,9 +956,11 @@
   // multiplication is slower or faster than our own divu_6464_6464_ routine.
   // Anyway, call our own routine.
   extern "C" uint64 divu_6464_6464_ (uint64 x, uint64 y); // -> Quotient q
-  extern "C" uint64 divu_64_rest;                         // -> Rest r
+}  // namespace cln
+  extern "C" uint64 cln_divu_64_rest;                         // -> Rest r
+namespace cln {
   #define divu_6464_6464(x,y,q_zuweisung,r_zuweisung)  \
-    { q_zuweisung divu_6464_6464_(x,y); r_zuweisung divu_64_rest; }
+    { q_zuweisung divu_6464_6464_(x,y); r_zuweisung cln_divu_64_rest; }
   #define NEED_VAR_divu_64_rest
   #define NEED_FUNCTION_divu_6464_6464_
 #endif
@@ -961,7 +975,9 @@
 // < uint64 r: x mod y
 // < x = q*y+r
   extern "C" uint64 divu_12864_6464_ (uint64 xhi, uint64 xlo, uint64 y); // -> Quotient q
-  extern "C" uint64 divu_64_rest;                                        // -> Rest r
+}  // namespace cln
+  extern "C" uint64 cln_divu_64_rest;                                        // -> Rest r
+namespace cln {
 #if defined(__GNUC__) && defined(__x86_64__) && !defined(NO_ASM)
   #define divu_12864_6464(xhi,xlo,y,q_zuweisung,r_zuweisung)  \
     ({var uint64 __xhi = (xhi);						\
@@ -981,7 +997,7 @@
     ({var uint64 ___q; divu_12864_6464(xhi,xlo,y,___q=,); ___q; })
 #else
   #define divu_12864_6464(xhi,xlo,y,q_zuweisung,r_zuweisung)  \
-    { q_zuweisung divu_12864_6464_(xhi,xlo,y); r_zuweisung divu_64_rest; }
+    { q_zuweisung divu_12864_6464_(xhi,xlo,y); r_zuweisung cln_divu_64_rest; }
   #define NEED_VAR_divu_64_rest
   #define NEED_FUNCTION_divu_12864_6464_
 #endif
diff -Nru cln-orig/src/base/digitseq/cl_asm_arm_.cc cln-patched/src/base/digitseq/cl_asm_arm_.cc
--- cln-orig/src/base/digitseq/cl_asm_arm_.cc	2011-02-14 08:43:11.947277706 +0100
+++ cln-patched/src/base/digitseq/cl_asm_arm_.cc	2011-02-13 21:14:22.339965002 +0100
@@ -110,18 +110,18 @@
 
 #ifdef MULU32_HIGH
 ptr_mulu32_high
-        IMPORT  mulu32_high
-        DCD     mulu32_high
+        IMPORT  cln_mulu32_high
+        DCD     cln_mulu32_high
 #endif
 #ifdef DIVU_16_REST
 ptr_divu_16_rest
-        IMPORT  divu_16_rest
-        DCD     divu_16_rest
+        IMPORT  cln_divu_16_rest
+        DCD     cln_divu_16_rest
 #endif
 #ifdef DIVU_32_REST
 ptr_divu_32_rest
-        IMPORT  divu_32_rest
-        DCD     divu_32_rest
+        IMPORT  cln_divu_32_rest
+        DCD     cln_divu_32_rest
 #endif
 
 #else
diff -Nru cln-orig/src/base/digitseq/cl_asm_hppa_.cc cln-patched/src/base/digitseq/cl_asm_hppa_.cc
--- cln-orig/src/base/digitseq/cl_asm_hppa_.cc	2011-02-14 08:43:11.951277706 +0100
+++ cln-patched/src/base/digitseq/cl_asm_hppa_.cc	2011-02-13 21:15:26.435965003 +0100
@@ -44,9 +44,9 @@
 #ifndef __GNUC__ /* mit GNU-C machen wir mulu32() als Macro, der inline multipliziert */
 
                 .SHORTDATA
-                .EXPORT mulu32_high
+                .EXPORT cln_mulu32_high
                 .ALIGN 8
-mulu32_high     .WORD           // 8 Byte Platz
+cln_mulu32_high .WORD           // 8 Byte Platz
                 .WORD
 
                 .CODE
@@ -56,8 +56,8 @@
 mulu32_         .PROC
                 .CALLINFO
                 .ENTER  // Input in %arg0,%arg1, Output in %ret0,mulu32_high
-                LDIL    L'mulu32_high-$global$,%r1
-                LDO     R'mulu32_high-$global$(%r1),%r1
+                LDIL    L'cln_mulu32_high-$global$,%r1
+                LDO     R'cln_mulu32_high-$global$(%r1),%r1
                                                 // %r1 = &x
                 STW     %arg0,0(%r1)            // x abspeichern
                 FLDWS   0(%r1),%fr4             // und in den Coprozessor laden
diff -Nru cln-orig/src/base/digitseq/cl_asm_i386_.cc cln-patched/src/base/digitseq/cl_asm_i386_.cc
--- cln-orig/src/base/digitseq/cl_asm_i386_.cc	2011-02-14 08:43:11.951277706 +0100
+++ cln-patched/src/base/digitseq/cl_asm_i386_.cc	2011-02-13 21:16:44.175965000 +0100
@@ -166,7 +166,7 @@
 C(mulu32_:)
             movl    4(%esp),%eax    // arg1
             mull    8(%esp)         // %edx|%eax := arg1 * arg2
-            movl    %edx,C(mulu32_high) // %edx = hi abspeichern
+            movl    %edx,C(cln_mulu32_high) // %edx = hi abspeichern
             ret                     // %eax = lo als Ergebnis
 
 #endif
@@ -182,7 +182,7 @@
             movl    4(%esp),%edx
             movl    8(%esp),%eax
             divl    12(%esp)       // x = %edx|%eax durch dividieren
-            movl    %edx,C(divu_32_rest) // Rest %edx = r abspeichern
+            movl    %edx,C(cln_divu_32_rest) // Rest %edx = r abspeichern
             ret                    // Quotient %eax = q als Ergebnis
 
 #endif
diff -Nru cln-orig/src/base/digitseq/cl_asm_m68k_.cc cln-patched/src/base/digitseq/cl_asm_m68k_.cc
--- cln-orig/src/base/digitseq/cl_asm_m68k_.cc	2011-02-14 08:43:11.951277706 +0100
+++ cln-patched/src/base/digitseq/cl_asm_m68k_.cc	2011-02-13 21:17:59.447965004 +0100
@@ -79,11 +79,11 @@
 | extern struct { uint32 lo; uint32 hi; } mulu32_ (uint32 arg1, uint32 arg2);
 | 2^32*hi+lo := arg1*arg2.
            DECLARE_FUNCTION(mulu32_)
-C(mulu32_:) | Input in d0,d1, Output in d0,mulu32_high
+C(mulu32_:) | Input in d0,d1, Output in d0,cln_mulu32_high
            movel $sp@(4),$d0
            movel $sp@(8),$d1
            mulul $d1,$d1:$d0
-           movel $d1,(C(mulu32_high)) | Adressierung?? Deklaration??
+           movel $d1,(C(cln_mulu32_high)) | Adressierung?? Deklaration??
            rts
 #endif
 
@@ -92,11 +92,11 @@
 | extern struct { uint32 q; uint32 r; } divu_6432_3232_ (uint32 xhi, uint32 xlo, uint32 y);
 | x = 2^32*xhi+xlo = q*y+r schreiben. Sei bekannt, daß 0 <= x < 2^32*y .
            DECLARE_FUNCTION(divu_6432_3232_)
-C(divu_6432_3232_:) | Input in d1,d0,d2, Output in d0,divu_32_rest
+C(divu_6432_3232_:) | Input in d1,d0,d2, Output in d0,cln_divu_32_rest
            movel $sp@(4),$d1
            movel $sp@(8),$d0
            divul $sp@(12),$d1:$d0 | x = d1|d0 durch y dividieren
-           movel $d1,(C(divu_32_rest)) | Rest ablegen | Adressierung?? Deklaration??
+           movel $d1,(C(cln_divu_32_rest)) | Rest ablegen | Adressierung?? Deklaration??
            rts
 #endif
 
diff -Nru cln-orig/src/base/digitseq/cl_asm_mips_.cc cln-patched/src/base/digitseq/cl_asm_mips_.cc
--- cln-orig/src/base/digitseq/cl_asm_mips_.cc	2011-02-14 08:43:11.951277706 +0100
+++ cln-patched/src/base/digitseq/cl_asm_mips_.cc	2011-02-13 21:18:30.211965000 +0100
@@ -91,7 +91,7 @@
         multu $5,$4             // arg1 * arg2
         mfhi $6                 // hi
         mflo $2                 // lo
-        sw $6,mulu32_high       // hi abspeichern // Adressierung?? Deklaration??
+        sw $6,cln_mulu32_high       // hi abspeichern // Adressierung?? Deklaration??
         j $31                   // return
         .end mulu32_
 
diff -Nru cln-orig/src/base/low/cl_low_div.cc cln-patched/src/base/low/cl_low_div.cc
--- cln-orig/src/base/low/cl_low_div.cc	2011-02-14 08:43:11.955277706 +0100
+++ cln-patched/src/base/low/cl_low_div.cc	2011-02-13 21:21:39.451965002 +0100
@@ -10,18 +10,18 @@
 // Implementation.
 
 #ifdef NEED_VAR_divu_16_rest
-uint16 divu_16_rest;
+uint16 cln_divu_16_rest;
 #endif
 
 #ifdef NEED_FUNCTION_divu_3216_1616_
-uint16 divu_16_rest;
+uint16 cln_divu_16_rest;
 namespace cln {
 #if 1
 // Most processors have a good 32 by 32 bit division, use that.
 uint16 divu_3216_1616_ (uint32 x, uint16 y)
 {
 	var uint16 q = floor(x,(uint32)y);
-	divu_16_rest = x - (uint32)q * (uint32)y;
+	cln_divu_16_rest = x - (uint32)q * (uint32)y;
 	return q;
 }
 #else
@@ -101,11 +101,11 @@
 #endif
 
 #ifdef NEED_VAR_divu_32_rest
-uint32 divu_32_rest;
+uint32 cln_divu_32_rest;
 #endif
 
 #ifdef NEED_FUNCTION_divu_6432_3232_
-uint32 divu_32_rest;
+uint32 cln_divu_32_rest;
 namespace cln {
 uint32 divu_6432_3232_(uint32 xhi, uint32 xlo, uint32 y)
 // Methode:
@@ -118,7 +118,7 @@
           var uint16 q0;
           var uint16 r1;
           divu_3216_1616(highlow32(low16(xhi),high16(xlo)),y, q1=,r1=);
-          divu_3216_1616(highlow32(r1,low16(xlo)),y, q0=,divu_32_rest=);
+          divu_3216_1616(highlow32(r1,low16(xlo)),y, q0=,cln_divu_32_rest=);
           return highlow32(q1,q0);
         }
     // y>=2^16
@@ -200,14 +200,14 @@
         if (r >= y)
           { q0 += 1; r -= y; }
        }// Quotient q0, Rest r fertig.
-        divu_32_rest = r >> s; // Rest
+        cln_divu_32_rest = r >> s; // Rest
         return highlow32(q1,q0); // Quotient
 }   } }
 }  // namespace cln
 #endif
 
 #ifdef NEED_VAR_divu_64_rest
-uint64 divu_64_rest;
+uint64 cln_divu_64_rest;
 #endif
 
 #ifdef NEED_FUNCTION_divu_6464_6464_
@@ -242,7 +242,7 @@
       var uint32 q0;
       var uint32 r1;
       divu_6432_3232(0,high32(x),y, q1 = , r1 = );
-      divu_6432_3232(r1,low32(x),y, q0 = , divu_64_rest = );
+      divu_6432_3232(r1,low32(x),y, q0 = , cln_divu_64_rest = );
       return highlow64(q1,q0);
     }
     else
@@ -269,7 +269,7 @@
           if (x >= y)
             { q += 1; x -= y;
         }   }
-      divu_64_rest = x;
+      cln_divu_64_rest = x;
       return (uint64)q;
    }
 }
@@ -289,7 +289,7 @@
           var uint32 q0;
           var uint32 r1;
           divu_6432_3232(low32(xhi),high32(xlo),y, q1=,r1=);
-          divu_6432_3232(r1,low32(xlo),y, q0=,divu_64_rest=);
+          divu_6432_3232(r1,low32(xlo),y, q0=,cln_divu_64_rest=);
           return highlow64(q1,q0);
         }
     // y>=2^32
@@ -371,7 +371,7 @@
         if (r >= y)
           { q0 += 1; r -= y; }
        }// Quotient q0, Rest r fertig.
-        divu_64_rest = r >> s; // Rest
+        cln_divu_64_rest = r >> s; // Rest
         return highlow64(q1,q0); // Quotient
 }   } }
 }  // namespace cln
diff -Nru cln-orig/src/base/low/cl_low_mul.cc cln-patched/src/base/low/cl_low_mul.cc
--- cln-orig/src/base/low/cl_low_mul.cc	2011-02-14 08:43:11.955277706 +0100
+++ cln-patched/src/base/low/cl_low_mul.cc	2011-02-13 21:19:49.715964997 +0100
@@ -10,11 +10,11 @@
 // Implementation.
 
 #ifdef NEED_VAR_mulu32_high
-uint32 mulu32_high;
+uint32 cln_mulu32_high;
 #endif
 
 #ifdef NEED_FUNCTION_mulu32_
-uint32 mulu32_high;
+uint32 cln_mulu32_high;
 namespace cln {
 uint32 mulu32_ (uint32 x, uint32 y)
 {
@@ -32,7 +32,7 @@
 	 hi += high16(mid); mid = highlow32_0(low16(mid));
 	 lo += mid; if (lo < mid) { hi += 1; } // 64-Bit-Addition
 	}
-	mulu32_high = hi; return lo;
+	cln_mulu32_high = hi; return lo;
 }
 }  // namespace cln
 #endif
@@ -42,7 +42,7 @@
 uint64 mulu32_w (uint32 arg1, uint32 arg2)
 {
 	var uint32 lo = mulu32_(arg1,arg2);
-	var uint32 hi = mulu32_high;
+	var uint32 hi = cln_mulu32_high;
 	return highlow64(hi,lo);
 }
 }  // namespace cln
@@ -50,11 +50,11 @@
 
 
 #ifdef NEED_VAR_mulu64_high
-uint64 mulu64_high;
+uint64 cln_mulu64_high;
 #endif
 
 #ifdef NEED_FUNCTION_mulu64_
-uint64 mulu64_high;
+uint64 cln_mulu64_high;
 namespace cln {
 extern "C" uint64 mulu64_ (uint64 x, uint64 y);
 uint64 mulu64_ (uint64 x, uint64 y)
@@ -73,7 +73,7 @@
 	 hi += high32(mid); mid = highlow64_0(low32(mid));
 	 lo += mid; if (lo < mid) { hi += 1; } // 128-Bit-Addition
 	}
-	mulu64_high = hi; return lo;
+	cln_mulu64_high = hi; return lo;
 }
 }  // namespace cln
 #endif
