gcl-devel
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Gcl-devel] Re: more on a possible memory leak


From: Camm Maguire
Subject: [Gcl-devel] Re: more on a possible memory leak
Date: 19 May 2005 16:48:30 -0400
User-agent: Gnus/5.09 (Gnus v5.9.0) Emacs/21.2

Greetings, and thank you so much for your report!

GCL's gc algorithm is *conservative*, which means that it walks the C
stack to find any pointers looking like object pointers, and marking
same if found.  In the case you cite above, such pointers were found
on the stack, causing the GC to hold onto the temporary list.

Fortunately, improvements are relatively easy.  The problem is that in
certain places, GCL's C code opens up quite a large stack area which
winds up being uninitialized, meaning that it contains the last value
set presumably somewhere else down in a previous function call.  One
particularly does not want these 'stack holes' above GCL's top level
function.  One doesn't want these anywhere, but at least
stack-hole-held objects in gc's further down the stack can be freed by
a top level gc.

The worst such case I can see at present is in c_apply_n in funlink.c,
where the large switch statement on the number of arguments allocates
enough stack to handle the maximum case, but only initializes the case
actually used.  The patch below closes this.

Furthermore, at least on x86, gcc aligns the stack pointer on each
function call to 4 word boundaries.  If fewer than 4 words are placed
on the stack in the function call, the remaining space is a stack
hole.  In the patch below, the c_apply_n?? functions take two dummy
arguments for this reason.

With this patch, your example below looks like:

=============================================================================
GCL (GNU Common Lisp)  2.6.6 CLtL1    May 19 2005 20:24:36
Source License: LGPL(gcl,gmp), GPL(unexec,bfd)
Binary License:  GPL due to GPL'ed components: (READLINE BFD UNEXEC)
Modifications of this banner must retain notice of a compatible license
Dedicated to the memory of W. Schelter

Use (help) to get some basic information on how to use GCL.

>(setq si::*notify-gbc* t)

T

>(progn (format t "~a~%" (si::address (make-list 40000000))) (room) nil)
[GC for 211 CONS pages..
Breakpoint 2, mark_cons (x=0x86e000c) at gbc.c:238
(gdb) d
Delete all breakpoints? (y or n) y
(gdb) c
Continuing.
(T=0).GC finished]
[GC for 316 CONS pages..(T=1).GC finished]
[GC for 1431 CONS pages..(T=2).GC finished]
[GC for 2291 CONS pages..(T=4).GC finished]
[GC for 4325 CONS pages..(T=6).GC finished]
[GC for 6337 CONS pages..(T=9).GC finished]
[GC for 8866 CONS pages..(T=12).GC finished]
[GC for 11540 CONS pages..(T=16).GC finished]
[GC for 14360 CONS pages..(T=20).GC finished]
[GC for 17240 CONS pages..(T=24).GC finished]
[GC for 20134 CONS pages..(T=27).GC finished]
[GC for 10485 RELOCATABLE-BLOCKS pages..(T=35).GC finished]
[GC for 30201 CONS pages..(T=40).GC finished]
[GC for 45301 CONS pages..(T=59).GC finished]
[GC for 10485 RELOCATABLE-BLOCKS pages..(T=69).GC finished]
[GC for 67951 CONS pages..(T=89).GC finished]
[GC for 10485 RELOCATABLE-BLOCKS pages..(T=104).GC finished]
[GC for 94165 CONS pages..(T=124).GC finished]
[GC for 10485 RELOCATABLE-BLOCKS pages..(T=139).GC finished]
621483424

117387/120379 100.0%      15CONS RATIO LONG-FLOAT COMPLEX STRUCTURE
     2/28     27.1%         FIXNUM SHORT-FLOAT CHARACTER RANDOM-STATE READTABLE 
SPICE
    47/49     72.4%         SYMBOL STREAM
     1/2      12.8%         PACKAGE
     1/38     50.0%         ARRAY HASH-TABLE VECTOR BIT-VECTOR PATHNAME 
CCLOSURE CLOSURE
    16/32     86.3%         STRING
     3/27     97.5%         CFUN BIGNUM
     6/157    87.8%         SFUN GFUN VFUN AFUN CFDATA

   393/512                  contiguous (104 blocks)
       13774                hole
       10485   0.0%       4 relocatable

    117463 pages for cells
    142115 total pages
     87806 pages available
     32223 pages in heap but not gc'd + pages needed for gc marking
    262144 maximum pages
NIL

>(si::gbc t)
[GC for 393 CONTIGUOUS-BLOCKS pages..(T=83).GC finished]

T

>(room)

117390/120379   0.1%      15CONS RATIO LONG-FLOAT COMPLEX STRUCTURE
     2/28     27.2%         FIXNUM SHORT-FLOAT CHARACTER RANDOM-STATE READTABLE 
SPICE
    47/49     72.4%         SYMBOL STREAM
     1/2      12.8%         PACKAGE
     1/38     50.0%         ARRAY HASH-TABLE VECTOR BIT-VECTOR PATHNAME 
CCLOSURE CLOSURE
    16/32     86.3%         STRING
     3/27     97.5%         CFUN BIGNUM
     6/157    87.8%         SFUN GFUN VFUN AFUN CFDATA

   393/512                1 contiguous (104 blocks)
       26214                hole
       10485   0.0%       4 relocatable

    117466 pages for cells
    154558 total pages
     87803 pages available
     19783 pages in heap but not gc'd + pages needed for gc marking
    262144 maximum pages

>(progn (format t "~a~%" (si::address (make-list 40000000))) (room) nil)
621496264

117390/120379 100.0%      15CONS RATIO LONG-FLOAT COMPLEX STRUCTURE
     2/28     37.2%         FIXNUM SHORT-FLOAT CHARACTER RANDOM-STATE READTABLE 
SPICE
    47/49     72.4%         SYMBOL STREAM
     1/2      12.8%         PACKAGE
     1/38     50.0%         ARRAY HASH-TABLE VECTOR BIT-VECTOR PATHNAME 
CCLOSURE CLOSURE
    16/32     86.3%         STRING
     3/27     97.5%         CFUN BIGNUM
     6/157    87.8%         SFUN GFUN VFUN AFUN CFDATA

   393/512                1 contiguous (104 blocks)
       26214                hole
       10485   0.0%       4 relocatable

    117466 pages for cells
    154558 total pages
     87803 pages available
     19783 pages in heap but not gc'd + pages needed for gc marking
    262144 maximum pages
NIL

>(loop for i from 1 do (print i) (make-list 40000000))

1 [GC for 120379 CONS pages..(T=87).GC finished]

2 [GC for 120379 CONS pages..(T=86).GC finished]

3 [GC for 120379 CONS pages..(T=86).GC finished]

4 [GC for 120379 CONS pages..(T=86).GC finished]

5 [GC for 120379 CONS pages..(T=86).GC finished]

6 [GC for 120379 CONS pages..(T=86).GC finished]

7 [GC for 120379 CONS pages..(T=85).GC finished]

8 [GC for 120379 CONS pages..(T=85).GC finished]

9 [GC for 120379 CONS pages..(T=86).GC finished]

10 [GC for 120379 CONS pages..(T=92).GC finished]

11 [GC for 120379 CONS pages..(T=86).GC finished]

12 [GC for 120379 CONS pages..(T=85).GC finished]

13 [GC for 120379 CONS pages..(T=86).GC finished]

14 [GC for 120379 CONS pages..(T=86).GC finished]

15 [GC for 120379 CONS pages..(T=89).GC finished]

16 [GC for 120379 CONS pages..(T=85).GC finished]

17 [GC for 120379 CONS pages..(T=85).GC finished]

18 [GC for 120379 CONS pages..(T=86).GC finished]

19 [GC for 120379 CONS pages..(T=85).GC finished]

...

=============================================================================

This patch can certainly be applied, but other stack holes might exist
which should be closed systematically if possible.  I am wondering if
there is a gcc switch which either initializes the stack to 0 when
allocated, or forgoes the 4 word alignment on function calls.  Would
any of you have time to search for such a solution?  

Take care,

=============================================================================
Index: o/funlink.c
===================================================================
RCS file: /cvsroot/gcl/gcl/o/funlink.c,v
retrieving revision 1.16.6.3
diff -u -r1.16.6.3 funlink.c
--- o/funlink.c 20 Mar 2004 02:03:59 -0000      1.16.6.3
+++ o/funlink.c 19 May 2005 20:34:02 -0000
@@ -263,265 +263,604 @@
 #define LCAST(a) (*a)
 /*  #endif */
 
-object
-c_apply_n(object (*fn)(), int n, object *x)
-{object res=Cnil;
- switch(n){
-    case 0:  res=LCAST(fn)();break;
-    case 1:  res=LCAST(fn)(x[0]);break;
-    case 2:  res=LCAST(fn)(x[0],x[1]);break;
-    case 3:  res=LCAST(fn)(x[0],x[1],x[2]);break;
-    case 4:  res=LCAST(fn)(x[0],x[1],x[2],x[3]);break;
-    case 5:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4]);break;
-    case 6:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5]);break;
-    case 7:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6]);break;
-    case 8:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7]);break;
-    case 9:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-         x[8]);break;
-    case 10:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-         x[8],x[9]);break;
-    case 11:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-         x[8],x[9],x[10]);break;
-    case 12:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-         x[8],x[9],x[10],x[11]);break;
-    case 13:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-         x[8],x[9],x[10],x[11],x[12]);break;
-    case 14:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-         x[8],x[9],x[10],x[11],x[12],x[13]);break;
-    case 15:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
-         x[8],x[9],x[10],x[11],x[12],x[13],x[14]);break;
-    case 16:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+static object
+c_apply_n0(object (*fn)(),object *x,object y,object z) {
+  return fn();
+}
+
+static object
+c_apply_n1(object (*fn)(),object *x,object y,object z) {
+  return fn(x[0]);
+}
+
+static object
+c_apply_n2(object (*fn)(),object *x,object y,object z) {
+  return fn(x[0],x[1]);
+}
+
+static object
+c_apply_n3(object (*fn)(),object *x,object y,object z) {
+  return fn(x[0],x[1],x[2]);
+}
+
+static object
+c_apply_n4(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3]);
+
+}
+
+static object
+c_apply_n5(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4]);
+
+}
+
+static object
+c_apply_n6(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5]);
+
+}
+
+static object
+c_apply_n7(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6]);
+
+}
+
+static object
+c_apply_n8(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7]);
+
+}
+
+static object
+c_apply_n9(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[8]);
+
+}
+
+static object
+c_apply_n10(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[8],x[9]);
+
+}
+
+static object
+c_apply_n11(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[8],x[9],x[10]);
+
+}
+
+static object
+c_apply_n12(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[8],x[9],x[10],x[11]);
+
+}
+
+static object
+c_apply_n13(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[8],x[9],x[10],x[11],x[12]);
+
+}
+
+static object
+c_apply_n14(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[8],x[9],x[10],x[11],x[12],x[13]);
+
+}
+
+static object
+c_apply_n15(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[8],x[9],x[10],x[11],x[12],x[13],x[14]);
+
+}
+
+static object
+c_apply_n16(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-         x[15]);break;
-    case 17:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[15]);
+
+}
+
+static object
+c_apply_n17(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-         x[15],x[16]);break;
-    case 18:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[15],x[16]);
+
+}
+
+static object
+c_apply_n18(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-         x[15],x[16],x[17]);break;
-    case 19:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[15],x[16],x[17]);
+
+}
+
+static object
+c_apply_n19(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-         x[15],x[16],x[17],x[18]);break;
-    case 20:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[15],x[16],x[17],x[18]);
+
+}
+
+static object
+c_apply_n20(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-         x[15],x[16],x[17],x[18],x[19]);break;
-    case 21:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[15],x[16],x[17],x[18],x[19]);
+
+}
+
+static object
+c_apply_n21(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-         x[15],x[16],x[17],x[18],x[19],x[20]);break;
-    case 22:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[15],x[16],x[17],x[18],x[19],x[20]);
+
+}
+
+static object
+c_apply_n22(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
-         x[15],x[16],x[17],x[18],x[19],x[20],x[21]);break;
-    case 23:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[15],x[16],x[17],x[18],x[19],x[20],x[21]);
+
+}
+
+static object
+c_apply_n23(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-         x[22]);break;
-    case 24:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[22]);
+
+}
+
+static object
+c_apply_n24(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-         x[22],x[23]);break;
-    case 25:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[22],x[23]);
+
+}
+
+static object
+c_apply_n25(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-         x[22],x[23],x[24]);break;
-    case 26:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[22],x[23],x[24]);
+
+}
+
+static object
+c_apply_n26(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-         x[22],x[23],x[24],x[25]);break;
-    case 27:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[22],x[23],x[24],x[25]);
+
+}
+
+static object
+c_apply_n27(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-         x[22],x[23],x[24],x[25],x[26]);break;
-    case 28:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[22],x[23],x[24],x[25],x[26]);
+
+}
+
+static object
+c_apply_n28(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-         x[22],x[23],x[24],x[25],x[26],x[27]);break;
-    case 29:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[22],x[23],x[24],x[25],x[26],x[27]);
+
+}
+
+static object
+c_apply_n29(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
-         x[22],x[23],x[24],x[25],x[26],x[27],x[28]);break;
-    case 30:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[22],x[23],x[24],x[25],x[26],x[27],x[28]);
+
+}
+
+static object
+c_apply_n30(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-         x[29]);break;
-    case 31:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[29]);
+
+}
+
+static object
+c_apply_n31(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-         x[29],x[30]);break;
-    case 32:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[29],x[30]);
+
+}
+
+static object
+c_apply_n32(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-         x[29],x[30],x[31]);break;
-    case 33:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[29],x[30],x[31]);
+
+}
+
+static object
+c_apply_n33(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-         x[29],x[30],x[31],x[32]);break;
-    case 34:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[29],x[30],x[31],x[32]);
+
+}
+
+static object
+c_apply_n34(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-         x[29],x[30],x[31],x[32],x[33]);break;
-    case 35:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[29],x[30],x[31],x[32],x[33]);
+
+}
+
+static object
+c_apply_n35(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-         x[29],x[30],x[31],x[32],x[33],x[34]);break;
-    case 36:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[29],x[30],x[31],x[32],x[33],x[34]);
+
+}
+
+static object
+c_apply_n36(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
-         x[29],x[30],x[31],x[32],x[33],x[34],x[35]);break;
-    case 37:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[29],x[30],x[31],x[32],x[33],x[34],x[35]);
+
+}
+
+static object
+c_apply_n37(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
          x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-         x[36]);break;
-    case 38:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[36]);
+
+}
+
+static object
+c_apply_n38(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
          x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-         x[36],x[37]);break;
-    case 39:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[36],x[37]);
+
+}
+
+static object
+c_apply_n39(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
          x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-         x[36],x[37],x[38]);break;
-    case 40:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[36],x[37],x[38]);
+
+}
+
+static object
+c_apply_n40(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
          x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-         x[36],x[37],x[38],x[39]);break;
-    case 41:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[36],x[37],x[38],x[39]);
+
+}
+
+static object
+c_apply_n41(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
          x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-         x[36],x[37],x[38],x[39],x[40]);break;
-    case 42:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[36],x[37],x[38],x[39],x[40]);
+
+}
+
+static object
+c_apply_n42(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
          x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-         x[36],x[37],x[38],x[39],x[40],x[41]);break;
-    case 43:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[36],x[37],x[38],x[39],x[40],x[41]);
+
+}
+
+static object
+c_apply_n43(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
          x[29],x[30],x[31],x[32],x[33],x[34],x[35],
-         x[36],x[37],x[38],x[39],x[40],x[41],x[42]);break;
-    case 44:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[36],x[37],x[38],x[39],x[40],x[41],x[42]);
+
+}
+
+static object
+c_apply_n44(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
          x[29],x[30],x[31],x[32],x[33],x[34],x[35],
          x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-         x[43]);break;
-    case 45:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[43]);
+
+}
+
+static object
+c_apply_n45(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
          x[29],x[30],x[31],x[32],x[33],x[34],x[35],
          x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-         x[43],x[44]);break;
-    case 46:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[43],x[44]);
+
+}
+
+static object
+c_apply_n46(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
          x[29],x[30],x[31],x[32],x[33],x[34],x[35],
          x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-         x[43],x[44],x[45]);break;
-    case 47:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[43],x[44],x[45]);
+
+}
+
+static object
+c_apply_n47(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
          x[29],x[30],x[31],x[32],x[33],x[34],x[35],
          x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-         x[43],x[44],x[45],x[46]);break;
-    case 48:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[43],x[44],x[45],x[46]);
+
+}
+
+static object
+c_apply_n48(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
          x[29],x[30],x[31],x[32],x[33],x[34],x[35],
          x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-         x[43],x[44],x[45],x[46],x[47]);break;
-    case 49:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[43],x[44],x[45],x[46],x[47]);
+
+}
+
+static object
+c_apply_n49(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
          x[29],x[30],x[31],x[32],x[33],x[34],x[35],
          x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-         x[43],x[44],x[45],x[46],x[47],x[48]);break;
-    case 50:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[43],x[44],x[45],x[46],x[47],x[48]);
+
+}
+
+static object
+c_apply_n50(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
          x[29],x[30],x[31],x[32],x[33],x[34],x[35],
          x[36],x[37],x[38],x[39],x[40],x[41],x[42],
-         x[43],x[44],x[45],x[46],x[47],x[48],x[49]);break;
-    case 51:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[43],x[44],x[45],x[46],x[47],x[48],x[49]);
+
+}
+
+static object
+c_apply_n51(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
          x[29],x[30],x[31],x[32],x[33],x[34],x[35],
          x[36],x[37],x[38],x[39],x[40],x[41],x[42],
          x[43],x[44],x[45],x[46],x[47],x[48],x[49],
-         x[50]);break;
-    case 52:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[50]);
+
+}
+
+static object
+c_apply_n52(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
          x[29],x[30],x[31],x[32],x[33],x[34],x[35],
          x[36],x[37],x[38],x[39],x[40],x[41],x[42],
          x[43],x[44],x[45],x[46],x[47],x[48],x[49],
-         x[50],x[51]);break;
-    case 53:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[50],x[51]);
+
+}
+
+static object
+c_apply_n53(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
          x[29],x[30],x[31],x[32],x[33],x[34],x[35],
          x[36],x[37],x[38],x[39],x[40],x[41],x[42],
          x[43],x[44],x[45],x[46],x[47],x[48],x[49],
-         x[50],x[51],x[52]);break;
-    case 54:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[50],x[51],x[52]);
+
+}
+
+static object
+c_apply_n54(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
          x[29],x[30],x[31],x[32],x[33],x[34],x[35],
          x[36],x[37],x[38],x[39],x[40],x[41],x[42],
          x[43],x[44],x[45],x[46],x[47],x[48],x[49],
-         x[50],x[51],x[52],x[53]);break;
-    case 55:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[50],x[51],x[52],x[53]);
+
+}
+
+static object
+c_apply_n55(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
          x[29],x[30],x[31],x[32],x[33],x[34],x[35],
          x[36],x[37],x[38],x[39],x[40],x[41],x[42],
          x[43],x[44],x[45],x[46],x[47],x[48],x[49],
-         x[50],x[51],x[52],x[53],x[54]);break;
-    case 56:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[50],x[51],x[52],x[53],x[54]);
+
+}
+
+static object
+c_apply_n56(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
          x[29],x[30],x[31],x[32],x[33],x[34],x[35],
          x[36],x[37],x[38],x[39],x[40],x[41],x[42],
          x[43],x[44],x[45],x[46],x[47],x[48],x[49],
-         x[50],x[51],x[52],x[53],x[54],x[55]);break;
-    case 57:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[50],x[51],x[52],x[53],x[54],x[55]);
+
+}
+
+static object
+c_apply_n57(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
          x[29],x[30],x[31],x[32],x[33],x[34],x[35],
          x[36],x[37],x[38],x[39],x[40],x[41],x[42],
          x[43],x[44],x[45],x[46],x[47],x[48],x[49],
-         x[50],x[51],x[52],x[53],x[54],x[55],x[56]);break;
-    case 58:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[50],x[51],x[52],x[53],x[54],x[55],x[56]);
+
+}
+
+static object
+c_apply_n58(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
@@ -529,8 +868,14 @@
          x[36],x[37],x[38],x[39],x[40],x[41],x[42],
          x[43],x[44],x[45],x[46],x[47],x[48],x[49],
          x[50],x[51],x[52],x[53],x[54],x[55],x[56],
-         x[57]);break;
-    case 59:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[57]);
+
+}
+
+static object
+c_apply_n59(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
@@ -538,8 +883,14 @@
          x[36],x[37],x[38],x[39],x[40],x[41],x[42],
          x[43],x[44],x[45],x[46],x[47],x[48],x[49],
          x[50],x[51],x[52],x[53],x[54],x[55],x[56],
-         x[57],x[58]);break;
-    case 60:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[57],x[58]);
+
+}
+
+static object
+c_apply_n60(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
@@ -547,8 +898,14 @@
          x[36],x[37],x[38],x[39],x[40],x[41],x[42],
          x[43],x[44],x[45],x[46],x[47],x[48],x[49],
          x[50],x[51],x[52],x[53],x[54],x[55],x[56],
-         x[57],x[58],x[59]);break;
-    case 61:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[57],x[58],x[59]);
+
+}
+
+static object
+c_apply_n61(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
@@ -556,8 +913,14 @@
          x[36],x[37],x[38],x[39],x[40],x[41],x[42],
          x[43],x[44],x[45],x[46],x[47],x[48],x[49],
          x[50],x[51],x[52],x[53],x[54],x[55],x[56],
-         x[57],x[58],x[59],x[60]);break;
-    case 62:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[57],x[58],x[59],x[60]);
+
+}
+
+static object
+c_apply_n62(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
@@ -565,8 +928,14 @@
          x[36],x[37],x[38],x[39],x[40],x[41],x[42],
          x[43],x[44],x[45],x[46],x[47],x[48],x[49],
          x[50],x[51],x[52],x[53],x[54],x[55],x[56],
-         x[57],x[58],x[59],x[60],x[61]);break;
-    case 63:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[57],x[58],x[59],x[60],x[61]);
+
+}
+
+static object
+c_apply_n63(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
@@ -574,8 +943,14 @@
          x[36],x[37],x[38],x[39],x[40],x[41],x[42],
          x[43],x[44],x[45],x[46],x[47],x[48],x[49],
          x[50],x[51],x[52],x[53],x[54],x[55],x[56],
-         x[57],x[58],x[59],x[60],x[61],x[62]);break;
-    case 64:  res=LCAST(fn)(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
+         x[57],x[58],x[59],x[60],x[61],x[62]);
+
+}
+
+static object
+c_apply_n64(object (*fn)(),object *x,object y,object z) {
+
+  return fn(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],
          x[8],x[9],x[10],x[11],x[12],x[13],x[14],
          x[15],x[16],x[17],x[18],x[19],x[20],x[21],
          x[22],x[23],x[24],x[25],x[26],x[27],x[28],
@@ -583,8 +958,85 @@
          x[36],x[37],x[38],x[39],x[40],x[41],x[42],
          x[43],x[44],x[45],x[46],x[47],x[48],x[49],
          x[50],x[51],x[52],x[53],x[54],x[55],x[56],
-         x[57],x[58],x[59],x[60],x[61],x[62],x[63]);break;
-  default: FEerror("Exceeded call-arguments-limit ",0);
+         x[57],x[58],x[59],x[60],x[61],x[62],x[63]);
+
+}
+
+/* #define mjoin(a,b) a ## b */
+/* #define Mjoin(a,b) mjoin(a,b) */
+
+#define CASE_N(a,b,c) case c : return Mjoin(c_apply_n,c)(a,b,Cnil,Cnil);break
+
+object
+c_apply_n(object (*fn)(), int n, object *x)
+{object res=Cnil;
+ switch(n){
+    CASE_N(fn,x,0);
+    CASE_N(fn,x,1);
+    CASE_N(fn,x,2);
+    CASE_N(fn,x,3);
+    CASE_N(fn,x,4);
+    CASE_N(fn,x,5);
+    CASE_N(fn,x,6);
+    CASE_N(fn,x,7);
+    CASE_N(fn,x,8);
+    CASE_N(fn,x,9);
+    CASE_N(fn,x,10);
+    CASE_N(fn,x,11);
+    CASE_N(fn,x,12);
+    CASE_N(fn,x,13);
+    CASE_N(fn,x,14);
+    CASE_N(fn,x,15);
+    CASE_N(fn,x,16);
+    CASE_N(fn,x,17);
+    CASE_N(fn,x,18);
+    CASE_N(fn,x,19);
+    CASE_N(fn,x,20);
+    CASE_N(fn,x,21);
+    CASE_N(fn,x,22);
+    CASE_N(fn,x,23);
+    CASE_N(fn,x,24);
+    CASE_N(fn,x,25);
+    CASE_N(fn,x,26);
+    CASE_N(fn,x,27);
+    CASE_N(fn,x,28);
+    CASE_N(fn,x,29);
+    CASE_N(fn,x,30);
+    CASE_N(fn,x,31);
+    CASE_N(fn,x,32);
+    CASE_N(fn,x,33);
+    CASE_N(fn,x,34);
+    CASE_N(fn,x,35);
+    CASE_N(fn,x,36);
+    CASE_N(fn,x,37);
+    CASE_N(fn,x,38);
+    CASE_N(fn,x,39);
+    CASE_N(fn,x,40);
+    CASE_N(fn,x,41);
+    CASE_N(fn,x,42);
+    CASE_N(fn,x,43);
+    CASE_N(fn,x,44);
+    CASE_N(fn,x,45);
+    CASE_N(fn,x,46);
+    CASE_N(fn,x,47);
+    CASE_N(fn,x,48);
+    CASE_N(fn,x,49);
+    CASE_N(fn,x,50);
+    CASE_N(fn,x,51);
+    CASE_N(fn,x,52);
+    CASE_N(fn,x,53);
+    CASE_N(fn,x,54);
+    CASE_N(fn,x,55);
+    CASE_N(fn,x,56);
+    CASE_N(fn,x,57);
+    CASE_N(fn,x,58);
+    CASE_N(fn,x,59);
+    CASE_N(fn,x,60);
+    CASE_N(fn,x,61);
+    CASE_N(fn,x,62);
+    CASE_N(fn,x,63);
+    CASE_N(fn,x,64);
+    default: FEerror("Exceeded call-arguments-limit ",0);
   } 
 
  return res;
Index: h/object.h
===================================================================
RCS file: /cvsroot/gcl/gcl/h/object.h,v
retrieving revision 1.18.4.1.2.1.2.5.6.1
diff -u -r1.18.4.1.2.1.2.5.6.1 object.h
--- h/object.h  5 Aug 2004 22:31:39 -0000       1.18.4.1.2.1.2.5.6.1
+++ h/object.h  19 May 2005 20:34:02 -0000
@@ -925,6 +925,7 @@
 #else
 #define COERCE_VA_LIST(new,vl,n) \
  object Xxvl[65]; \
+ memset(Xxvl,0,sizeof(Xxvl));\
  {int i; \
   new=Xxvl; \
   if (n >= 65) FEerror("Too plong vl",0); \
=============================================================================


Robert Boyer <address@hidden> writes:

> The short transcript below seems to indicate some sort
> of memory leak for conses.  The "loop" does not get past
> the 3rd allocation of 40,000,000 conses.  This problem
> does not seem to arise if one uses 30,000,000 instead
> of 40,000,000.
> 
> Bob and Warren
> 
> P. S. As in our previous messages on this matter today,
> we are using a maximum size 32 bit gcl.
> 
> 
> -------------------------------------------------------------------------------
> % /projects/hvg/compBio/tools/gcl-2.6.6/xbin/gcl
> GCL (GNU Common Lisp)  2.6.6 CLtL1    Mar  8 2005 22:20:59
> Source License: LGPL(gcl,gmp), GPL(unexec,bfd)
> Binary License:  GPL due to GPL'ed components: (BFD UNEXEC)
> Modifications of this banner must retain notice of a compatible license
> Dedicated to the memory of W. Schelter
> 
> Use (help) to get some basic information on how to use GCL.
> 
> >(setq si::*notify-gbc* t)
> 
> T
> 
> >(loop for i from 1 do (print i) (make-list 40000000))
> 
> 
> 1 [GC for 211 CONS pages..(T=0).GC finished]
> [GC for 316 CONS pages..(T=0).GC finished]
> [GC for 1431 CONS pages..(T=1).GC finished]
> [GC for 2291 CONS pages..(T=2).GC finished]
> [GC for 4325 CONS pages..(T=4).GC finished]
> [GC for 6337 CONS pages..(T=5).GC finished]
> [GC for 8866 CONS pages..(T=7).GC finished]
> [GC for 11540 CONS pages..(T=10).GC finished]
> [GC for 14360 CONS pages..(T=12).GC finished]
> [GC for 17240 CONS pages..(T=14).GC finished]
> [GC for 20134 CONS pages..(T=17).GC finished]
> [GC for 10485 RELOCATABLE-BLOCKS pages..(T=22).GC finished]
> [GC for 30201 CONS pages..(T=24).GC finished]
> [GC for 45301 CONS pages..(T=37).GC finished]
> [GC for 10485 RELOCATABLE-BLOCKS pages..(T=43).GC finished]
> [GC for 67951 CONS pages..(T=56).GC finished]
> [GC for 10485 RELOCATABLE-BLOCKS pages..(T=65).GC finished]
> [GC for 94165 CONS pages..(T=84).GC finished]
> [GC for 10485 RELOCATABLE-BLOCKS pages..(T=86).GC finished]
> 
> 2 [GC for 120379 CONS pages..(T=74).GC finished]
> [GC for 120379 CONS pages..(T=100).GC finished]
> [GC for 10485 RELOCATABLE-BLOCKS pages..(T=108).GC finished]
> [GC for 146593 CONS pages..(T=124).GC finished]
> [GC for 10485 RELOCATABLE-BLOCKS pages..(T=130).GC finished]
> [GC for 172807 CONS pages..(T=143).GC finished]
> 
> 3 [GC for 10485 RELOCATABLE-BLOCKS pages..(T=146).GC finished]
> [GC for 199021 CONS pages..(T=170).GC finished]
> [GC for 205353 CONS pages..(T=171).GC finished]
> [GC for 205353 CONS pages..(T=170).GC finished]
> [GC for 205353 CONS pages..(T=168).GC finished]
> [GC for 205353 CONS pages..(T=170).GC finished]
> [GC for 205353 CONS pages..(T=170).GC finished]
> [GC for 205353 CONS pages..(T=178).GC finished]
> [GC for 205353 CONS pages..(T=169).GC finished]
> [GC for 205353 CONS pages..(T=168).GC finished]
> [GC for 205353 CONS pages..(T=171).GC finished]
> [GC for 205353 CONS pages..(T=170).GC finished]
> [GC for 205353 CONS pages..(T=169).GC finished]
> [GC for 205353 CONS pages..(T=179).GC finished]
> [GC for 205353 CONS pages..(T=171).GC finished]
> [GC for 205353 CONS pages..(T=172).GC finished]
> [GC for 205353 CONS pages..(T=170).GC finished]
> [GC for 205353 CONS pages..(T=170).GC finished]
> [GC for 205353 CONS pages..(T=170).GC finished]
> [GC for 205353 CONS pages..(T=170).GC finished]
> [GC for 205353 CONS pages..(T=170).GC finished]
> [GC for 205353 CONS pages..(T=171).GC finished]
> [GC for 205353 CONS pages..(T=170).GC finished]
> [GC for 205353 CONS pages..(T=171).GC finished]
> [GC for 205353 CONS pages..(T=170).GC finished]
> [GC for 205353 CONS pages..(T=181).GC finished]
> [GC for 205353 CONS pages..(T=171).GC finished]
> [GC for 205353 CONS pages..(T=168).GC finished]
> [GC for 205353 CONS pages..(T=170).GC finished]
> [GC for 205353 CONS pages..(T=170).GC finished]
> [GC for 205353 CONS pages..(T=169).GC finished]
> [GC for 205353 CONS pages..(T=170).GC finished]
> [GC for 205353 CONS pages..(T=169).GC finished]
> [GC for 205353 CONS pages..(T=169).GC finished]
> [GC for 205353 CONS pages..(T=170).GC finished]
> [GC for 205353 CONS pages..(T=171).GC finished]
> [GC for 205353 CONS pages..[GC for 205353 CONS pages..(T=...).GC finished]
> 
> Error: The storage for CONS is exhausted.
>        Currently, 205353 pages are allocated.
>        Use ALLOCATE to expand the space.
> Fast links are on: do (si::use-fast-links nil) for debugging
> Error signalled by SYSTEM:TERMINAL-INTERRUPT.
> Broken at SYSTEM:UNIVERSAL-ERROR-HANDLER.  Type :H for Help.
> >>:q
> 
> Top level.
> >
> 
> 
> 

-- 
Camm Maguire                                            address@hidden
==========================================================================
"The earth is but one country, and mankind its citizens."  --  Baha'u'llah




reply via email to

[Prev in Thread] Current Thread [Next in Thread]