const char * gen::dbgprint() const {
    if (Serial_IsOpen() != 1) {
      unsigned char mode[6] = {0, 5, 0, 0, 0, 0};
      Serial_Open(mode);
    }
    string S=this->print(context0);      
    Serial_Write((unsigned char *)S.c_str(), S.size());
    return "";
    // Serial_Close(1);
  }  

Program received signal SIGTRAP, Trace/breakpoint trap.
giac::gen::dbgprint (this=0x881dfd04) at kgen.cc:12733
12733      const char * gen::dbgprint() const {
(gdb) The program being debugged was signaled while in a function called from GDB.
GDB remains in the frame where the signal was received.
To change this behavior use "set unwindonsignal on".
Evaluation of the expression containing the function
(giac::gen::dbgprint() const) will be abandoned.
When the function is done executing, GDB will silently stop.

$12 = {classes = {0x0, 0x813ace8 <malloc_heap+45504>, 0x0, 0x813afec <malloc_heap+46276>, 0x0, 0x0, 0x0, 0x813af84 <malloc_heap+46172>, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x813b088 <malloc_heap+46432>, 0x813c540 <malloc_heap+51736>}, stats = 0x812fb6c <malloc_heap+68>}

//#define ALLOCSMALL

/* also define GINT_MALLOC in Makefile, does not work with OFF/ON */
/* #define GINT_MALLOC  */
#ifdef GINT_MALLOC
#include <gint/kmalloc.h>
#else
#ifdef ALLOCSMALL
#undef ALLOCSMALL
#endif
#endif

static inline size_t allocround(size_t size){
  return (size < 8) ? 8 : ((size + 3) & ~3);
}

static inline size_t allocmin(size_t a,size_t b){
  return a<b?a:b;
}

#ifdef ALLOCSMALL

typedef struct  {
  int i1,i2,i3,i4;
} two_int; // 8

typedef struct  {
  int i1,i2,i3,i4;
} four_int ; // 16

typedef struct  {
  int i1,i2,i3,i4,i5,i6;
} six_int; // 24
  
typedef struct  {
  int i1,i2,i3,i4,i5,i6,i7,i8;
} eight_int; // 32
  
// ALLOCA  constants must be multiples of 2*32
#define ALLOC8 32*32
#define ALLOC16 32*32
#define ALLOC24 24*32

static unsigned int freeslot8[ALLOC8/32]={
  0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
  0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
  0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
  0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
  0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
  0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
  0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
  0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
};
static unsigned int freeslot16[ALLOC16/32]={
  0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
  0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
  0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
  0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
  0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
  0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
  0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
  0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
};
static unsigned int freeslot24[ALLOC24/32]={
  0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
  0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
  0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
  0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
  0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
  0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
};
static two_int slottab8[ALLOC8];
static four_int slottab16[ALLOC16];
static six_int slottab24[ALLOC24];
  
unsigned freeslotpos(unsigned n){
  unsigned r=1;
  if ( (n<<16)==0 ){
    r+= 16;
    n>>=16;
  }
  if ( (n<<24)==0 ) {
    r+= 8;
    n>>=8;
  }
  if ( (n<<28)==0 ) {
    r+= 4;
    n>>=4;
  }
  if ( (n<<30)==0 ) {
    r+= 2;
    n>>=2;
  }
  r -= n&1;
  return r;
}
  
void * slotalloc(size_t size){
  int i,pos;
  if (size<=8){
    for (i=0;i<ALLOC8/32;){
      if (!(freeslot8[i] || freeslot8[i+1])){
    i+=2;
    continue;
      }
      if (freeslot8[i]){
    pos=freeslotpos(freeslot8[i]);
    freeslot8[i] &= ~(1<<pos);
    return (void *) (slottab8+i*32+pos);
      }
      i++;
      pos=freeslotpos(freeslot8[i]);
      freeslot8[i] &= ~(1<<pos);
      return (void *) (slottab8+i*32+pos);
    }
    return kmalloc(size,NULL);
  }
  if (size<=16){
    for (i=0;i<ALLOC16/32;){
      if (!(freeslot16[i] || freeslot16[i+1])){
    i+=2;
    continue;
      }
      if (freeslot16[i]){
    pos=freeslotpos(freeslot16[i]);
    freeslot16[i] &= ~(1<<pos);
    return (void *) (slottab16+i*32+pos);
      }
      ++i;
      pos=freeslotpos(freeslot16[i]);
      freeslot16[i] &= ~(1<<pos);
      return (void *) (slottab16+i*32+pos);
    }
    return kmalloc(size,NULL);
  }
  if (size<=24){
    for (i=0;i<ALLOC24/32;){
      if (!(freeslot24[i] || freeslot24[i+1])){
    i+=2;
    continue;
      }
      if (freeslot24[i]){
    pos=freeslotpos(freeslot24[i]);
    freeslot24[i] &= ~(1<<pos);
    return (void *) (slottab24+i*32+pos);
      }
      i++;
      pos=freeslotpos(freeslot24[i]);
      freeslot24[i] &= ~(1<<pos);
      return (void *) (slottab24+i*32+pos);
    }
    return kmalloc(size,NULL);
  }
  void * p =  kmalloc(size,NULL);  
  return p;
}  
  
void slotfree(void* obj){
  if ( ((size_t)obj >= (size_t) &slottab8[0]) &&
       ((size_t)obj < (size_t) &slottab8[ALLOC8]) ){
    int pos= ((size_t)obj -((size_t) &slottab8[0]))/sizeof(six_int);
    freeslot8[pos/32] |= (1 << (pos%32));
    return;
  }
  if ( ((size_t)obj>=(size_t) &slottab16[0] ) &&
       ((size_t)obj<(size_t) &slottab16[ALLOC16] ) ){
    int pos= ((size_t)obj -((size_t) &slottab16[0]))/sizeof(four_int);
    freeslot16[pos/32] |= (1 << (pos%32));
    return;
  }
  if ( ((size_t)obj >= (size_t) &slottab24[0]) &&
       ((size_t)obj < (size_t) &slottab24[ALLOC24]) ){
    int pos= ((size_t)obj -((size_t) &slottab24[0]))/sizeof(six_int);
    freeslot24[pos/32] |= (1 << (pos%32));
    return;
  }
  kfree(obj);
}
unsigned hamdist(unsigned val){
  size_t res=0;
  if (!val) return res;
  for (int i=0;i<32;++i){
    res += ((val >>i) & 1);
  }
  return res;
}

size_t slotfreemem(){
  size_t res=0;
  for (int i=0;i<ALLOC8/32;++i){
    res += 16*hamdist(freeslot8[i]);
  }
  for (int i=0;i<ALLOC16/32;++i){
    res += 16*hamdist(freeslot16[i]);
  }
  for (int i=0;i<ALLOC24/32;++i){
    res += 24*hamdist(freeslot24[i]);
  }
  return res;
}
#else // ALLOCSMALL
size_t slotfreemem(){
  return 0;
}
#endif // ALLOCSMALL

void *malloc(size_t sz) {
#ifdef GINT_MALLOC
#ifdef ALLOCSMALL
  return slotalloc(sz);
#else
  return kmalloc(sz, NULL);
#endif
#else
  void * ptr= sys_malloc(sz); // __malloc(size);
  if ( ((size_t) ptr&stack_mask) > stackptr)
    interrupted=ctrl_c=1;
  return ptr;
#endif
}

void *realloc(void *ptr, size_t sz) {
#ifdef GINT_MALLOC
#ifdef ALLOCSMALL
  if (sz==0){
    free(ptr);
    return;
  }
    if ( ((size_t)ptr >= (size_t) &slottab8[0]) &&
     ((size_t)ptr < (size_t) &slottab8[ALLOC8]) ){
      if (sz<=8) return ptr;
      void * newptr=slotalloc(sz);
      slotfree(ptr);
      if (!newptr) return 0;
      memcpy(newptr, ptr, allocmin(8,sz));
      return newptr;
    }
    if ( ((size_t)ptr >= (size_t) &slottab16[0]) &&
     ((size_t)ptr < (size_t) &slottab16[ALLOC16]) ){
      if (sz<=16) return ptr;
      void * newptr=slotalloc(sz);
      slotfree(ptr);
      if (!newptr) return 0;
      memcpy(newptr, ptr, allocmin(16,sz));
      return newptr;
    }
    if ( ((size_t)ptr >= (size_t) &slottab24[0]) &&
     ((size_t)ptr < (size_t) &slottab24[ALLOC24]) ){
      if (sz<=24) return ptr;
      void * newptr=slotalloc(sz);
      slotfree(ptr);
      if (!newptr) return 0;
      memcpy(newptr, ptr, allocmin(24,sz));
      return newptr;
    }
#endif
  return krealloc(ptr, sz);
#else
  ptr=sys_realloc(ptr, sz);    // return __realloc(ptr, newsize);
  if ( ((size_t) ptr&stack_mask) > stackptr)
    interrupted=ctrl_c=1;
  return ptr;
#endif
}

void free(void *ptr) {
#ifdef GINT_MALLOC
#ifdef ALLOCSMALL
  slotfree(ptr);
#else
  kfree(ptr);
#endif
#else
  sys_free(ptr);
#endif
}