Adding menuetlibc back to its place in /programs/develop/libraries

This version of menuetlibc was taken from revision 4743, right before I made any changes

git-svn-id: svn://kolibrios.org@4973 a494cfbc-eb01-0410-851d-a64ba20cac60

programs/develop/libraries/menuetlibc/include/sigc++/adaptor.h

@@ -0,0 +1,43 @@
+// -*- c++ -*-
+/* 
+ * Copyright 1999 Karl Nelson <kenelson@ece.ucdavis.edu>
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#ifndef _SIGC_ADAPTOR_H_
+#define _SIGC_ADAPTOR_H_
+#include <sigc++/slot.h>
+
+#ifdef SIGC_CXX_NAMESPACES
+namespace SigC
+{
+#endif
+
+struct LIBSIGC_API AdaptorNode : public SlotNode
+  {
+   Callback_ data_;
+  };
+
+struct LIBSIGC_API AdaptorSlot_
+  {
+   static void copy_callback(SlotData* sdata,AdaptorNode* node);
+  };
+
+#ifdef SIGC_CXX_NAMESPACES
+} // namespace
+#endif
+
+#endif
+

programs/develop/libraries/menuetlibc/include/sigc++/class_slot.h

@@ -0,0 +1,318 @@
+// -*- c++ -*-
+/* This is a generated file, do not edit.  Generated from ../sigc++/macros/class_slot.h.m4 */
+
+#ifndef SIGCXX_CLASS_SLOT_H
+#define SIGCXX_CLASS_SLOT_H
+
+/*
+  SigC::slot_class() (class)
+  -----------------------
+  slot_class() can be applied to a class method to form a Slot with a
+  profile equivelent to the method.  At the same time an instance
+  of that class must be specified.  This is an unsafe interface.
+
+  This does NOT require that the class be derived from SigC::Object.
+  However, the object should be static with regards to the signal system.
+  (allocated within the global scope.)  If it is not and a connected
+  slot is call it will result in a seg fault.  If the object must
+  be destroyed before the connected slots, all connections must
+  be disconnected by hand.
+
+  Sample usage:
+
+    struct A
+      {
+       void foo(int,int);
+      } a;
+
+    Slot2<void,int,int> s=slot_class(a,&A::foo);
+
+*/
+
+
+#include <sigc++/object_slot.h>
+
+#ifdef SIGC_CXX_NAMESPACES
+namespace SigC
+{
+#endif
+
+
+/****************************************************************
+***** Class Slot 0
+****************************************************************/
+template <class R,class Obj>
+struct ClassSlot0_:public ObjectSlot0_<R,Obj>
+  {
+   typedef ObjectSlot0_<R,Obj> Base;
+   typedef typename Base::InFunc InFunc;
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+template <class R,class Obj>
+Slot0<R>
+  slot_class(Obj &obj,R (Obj::*func)())
+  {return ClassSlot0_<R,Obj>::create(&obj,func);
+  }
+
+template <class R,class Obj>
+Slot0<R>
+  slot_class(Obj *obj,R (Obj::*func)())
+  {return ClassSlot0_<R,Obj>::create(obj,func);
+  }
+
+
+/****************************************************************
+***** Class Slot 1
+****************************************************************/
+template <class R,class P1,class Obj>
+struct ClassSlot1_:public ObjectSlot1_<R,P1,Obj>
+  {
+   typedef ObjectSlot1_<R,P1,Obj> Base;
+   typedef typename Base::InFunc InFunc;
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+template <class R,class P1,class Obj>
+Slot1<R,P1>
+  slot_class(Obj &obj,R (Obj::*func)(P1))
+  {return ClassSlot1_<R,P1,Obj>::create(&obj,func);
+  }
+
+template <class R,class P1,class Obj>
+Slot1<R,P1>
+  slot_class(Obj *obj,R (Obj::*func)(P1))
+  {return ClassSlot1_<R,P1,Obj>::create(obj,func);
+  }
+
+
+/****************************************************************
+***** Class Slot 2
+****************************************************************/
+template <class R,class P1,class P2,class Obj>
+struct ClassSlot2_:public ObjectSlot2_<R,P1,P2,Obj>
+  {
+   typedef ObjectSlot2_<R,P1,P2,Obj> Base;
+   typedef typename Base::InFunc InFunc;
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+template <class R,class P1,class P2,class Obj>
+Slot2<R,P1,P2>
+  slot_class(Obj &obj,R (Obj::*func)(P1,P2))
+  {return ClassSlot2_<R,P1,P2,Obj>::create(&obj,func);
+  }
+
+template <class R,class P1,class P2,class Obj>
+Slot2<R,P1,P2>
+  slot_class(Obj *obj,R (Obj::*func)(P1,P2))
+  {return ClassSlot2_<R,P1,P2,Obj>::create(obj,func);
+  }
+
+
+/****************************************************************
+***** Class Slot 3
+****************************************************************/
+template <class R,class P1,class P2,class P3,class Obj>
+struct ClassSlot3_:public ObjectSlot3_<R,P1,P2,P3,Obj>
+  {
+   typedef ObjectSlot3_<R,P1,P2,P3,Obj> Base;
+   typedef typename Base::InFunc InFunc;
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+template <class R,class P1,class P2,class P3,class Obj>
+Slot3<R,P1,P2,P3>
+  slot_class(Obj &obj,R (Obj::*func)(P1,P2,P3))
+  {return ClassSlot3_<R,P1,P2,P3,Obj>::create(&obj,func);
+  }
+
+template <class R,class P1,class P2,class P3,class Obj>
+Slot3<R,P1,P2,P3>
+  slot_class(Obj *obj,R (Obj::*func)(P1,P2,P3))
+  {return ClassSlot3_<R,P1,P2,P3,Obj>::create(obj,func);
+  }
+
+
+/****************************************************************
+***** Class Slot 4
+****************************************************************/
+template <class R,class P1,class P2,class P3,class P4,class Obj>
+struct ClassSlot4_:public ObjectSlot4_<R,P1,P2,P3,P4,Obj>
+  {
+   typedef ObjectSlot4_<R,P1,P2,P3,P4,Obj> Base;
+   typedef typename Base::InFunc InFunc;
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+template <class R,class P1,class P2,class P3,class P4,class Obj>
+Slot4<R,P1,P2,P3,P4>
+  slot_class(Obj &obj,R (Obj::*func)(P1,P2,P3,P4))
+  {return ClassSlot4_<R,P1,P2,P3,P4,Obj>::create(&obj,func);
+  }
+
+template <class R,class P1,class P2,class P3,class P4,class Obj>
+Slot4<R,P1,P2,P3,P4>
+  slot_class(Obj *obj,R (Obj::*func)(P1,P2,P3,P4))
+  {return ClassSlot4_<R,P1,P2,P3,P4,Obj>::create(obj,func);
+  }
+
+
+/****************************************************************
+***** Class Slot 5
+****************************************************************/
+template <class R,class P1,class P2,class P3,class P4,class P5,class Obj>
+struct ClassSlot5_:public ObjectSlot5_<R,P1,P2,P3,P4,P5,Obj>
+  {
+   typedef ObjectSlot5_<R,P1,P2,P3,P4,P5,Obj> Base;
+   typedef typename Base::InFunc InFunc;
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+template <class R,class P1,class P2,class P3,class P4,class P5,class Obj>
+Slot5<R,P1,P2,P3,P4,P5>
+  slot_class(Obj &obj,R (Obj::*func)(P1,P2,P3,P4,P5))
+  {return ClassSlot5_<R,P1,P2,P3,P4,P5,Obj>::create(&obj,func);
+  }
+
+template <class R,class P1,class P2,class P3,class P4,class P5,class Obj>
+Slot5<R,P1,P2,P3,P4,P5>
+  slot_class(Obj *obj,R (Obj::*func)(P1,P2,P3,P4,P5))
+  {return ClassSlot5_<R,P1,P2,P3,P4,P5,Obj>::create(obj,func);
+  }
+
+
+/****************************************************************
+***** Class Slot 6
+****************************************************************/
+template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class Obj>
+struct ClassSlot6_:public ObjectSlot6_<R,P1,P2,P3,P4,P5,P6,Obj>
+  {
+   typedef ObjectSlot6_<R,P1,P2,P3,P4,P5,P6,Obj> Base;
+   typedef typename Base::InFunc InFunc;
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class Obj>
+Slot6<R,P1,P2,P3,P4,P5,P6>
+  slot_class(Obj &obj,R (Obj::*func)(P1,P2,P3,P4,P5,P6))
+  {return ClassSlot6_<R,P1,P2,P3,P4,P5,P6,Obj>::create(&obj,func);
+  }
+
+template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class Obj>
+Slot6<R,P1,P2,P3,P4,P5,P6>
+  slot_class(Obj *obj,R (Obj::*func)(P1,P2,P3,P4,P5,P6))
+  {return ClassSlot6_<R,P1,P2,P3,P4,P5,P6,Obj>::create(obj,func);
+  }
+
+
+/****************************************************************
+***** Class Slot 7
+****************************************************************/
+template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7,class Obj>
+struct ClassSlot7_:public ObjectSlot7_<R,P1,P2,P3,P4,P5,P6,P7,Obj>
+  {
+   typedef ObjectSlot7_<R,P1,P2,P3,P4,P5,P6,P7,Obj> Base;
+   typedef typename Base::InFunc InFunc;
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7,class Obj>
+Slot7<R,P1,P2,P3,P4,P5,P6,P7>
+  slot_class(Obj &obj,R (Obj::*func)(P1,P2,P3,P4,P5,P6,P7))
+  {return ClassSlot7_<R,P1,P2,P3,P4,P5,P6,P7,Obj>::create(&obj,func);
+  }
+
+template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7,class Obj>
+Slot7<R,P1,P2,P3,P4,P5,P6,P7>
+  slot_class(Obj *obj,R (Obj::*func)(P1,P2,P3,P4,P5,P6,P7))
+  {return ClassSlot7_<R,P1,P2,P3,P4,P5,P6,P7,Obj>::create(obj,func);
+  }
+
+
+
+#ifdef SIGC_CXX_NAMESPACES
+} // namespace
+#endif
+
+#endif

programs/develop/libraries/menuetlibc/include/sigc++/convert.h

@@ -0,0 +1,671 @@
+// -*- c++ -*-
+/* This is a generated file, do not edit.  Generated from ../sigc++/macros/convert.h.m4 */
+
+#ifndef SIGCXX_CONVERT_H
+#define SIGCXX_CONVERT_H
+
+/*
+  SigC::convert
+  -------------
+  convert() alters a Slot by assigning a conversion function 
+  which can completely alter the parameter types of a slot. 
+
+  Only convert functions for changing with same number of
+  arguments is compiled by default.  See examples/custom_convert.h.m4 
+  for details on how to build non standard ones.
+
+  Sample usage:
+    int my_string_to_char(Callback1<int,const char*> *d,const string &s)
+    int f(const char*);
+    string s=hello;
+
+
+    Slot1<int,const string &>  s2=convert(slot(f),my_string_to_char);
+    s2(s);  
+
+*/
+#include <sigc++/adaptor.h>
+
+#ifdef SIGC_CXX_NAMESPACES
+namespace SigC
+{
+#endif
+
+
+
+/****************************************************************
+***** Adaptor Convert Slot 1
+****************************************************************/
+template <class R1,class P1,
+          class R2,class Q1>
+struct AdaptorConvertSlot1_1: public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R1 RType;
+#else
+   typedef typename Trait<R1>::type RType;
+#endif
+   typedef Slot1<R1,P1> SlotType;
+   typedef Slot1<R2,Q1> InSlotType;
+   typedef typename InSlotType::Callback Callback;
+   typedef RType (*Func)  (Callback*,P1);
+   typedef R1    (*InFunc)(Callback*,P1);
+   typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
+
+   static RType callback(void* d,P1 p1)
+     {
+      CallData* data=(CallData*)d;
+      return (data->func)(data->obj,p1);
+     }
+
+   static SlotData* create(SlotData *s,InFunc func)
+     {
+      SlotData* tmp=(SlotData*)s;
+      AdaptorNode *node=new AdaptorNode();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      data.obj=(Callback*)&(node->data_);
+      return tmp;
+     }
+  };
+
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class P1,
+          class R2,class Q1>
+struct AdaptorConvertSlot1_1
+         <void,P1,
+          R2,Q1>
+  : public AdaptorSlot_
+  {
+   typedef void RType;
+   typedef Slot1<void,P1> SlotType;
+   typedef Slot1<R2,Q1> InSlotType;
+   typedef typename InSlotType::Callback Callback;
+   typedef RType (*Func)  (Callback*,P1);
+   typedef void    (*InFunc)(Callback*,P1);
+   typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
+
+   static RType callback(void* d,P1 p1)
+     {
+      CallData* data=(CallData*)d;
+       (data->func)(data->obj,p1);
+     }
+
+   static SlotData* create(SlotData *s,InFunc func)
+     {
+      SlotData* tmp=(SlotData*)s;
+      AdaptorNode *node=new AdaptorNode();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      data.obj=(Callback*)&(node->data_);
+      return tmp;
+     }
+  };
+
+
+#endif
+#endif
+
+template <class R1,class P1,
+          class R2,class Q1>
+Slot1<R1,P1>
+  convert(const Slot1<R2,Q1> &s,
+          R1 (*func)(Callback1<R2,Q1>*,P1))
+  {return AdaptorConvertSlot1_1<R1,P1,
+           R2,Q1>::create(s.obj(),func);
+  }
+
+
+/****************************************************************
+***** Adaptor Convert Slot 2
+****************************************************************/
+template <class R1,class P1,class P2,
+          class R2,class Q1,class Q2>
+struct AdaptorConvertSlot2_2: public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R1 RType;
+#else
+   typedef typename Trait<R1>::type RType;
+#endif
+   typedef Slot2<R1,P1,P2> SlotType;
+   typedef Slot2<R2,Q1,Q2> InSlotType;
+   typedef typename InSlotType::Callback Callback;
+   typedef RType (*Func)  (Callback*,P1,P2);
+   typedef R1    (*InFunc)(Callback*,P1,P2);
+   typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2)
+     {
+      CallData* data=(CallData*)d;
+      return (data->func)(data->obj,p1,p2);
+     }
+
+   static SlotData* create(SlotData *s,InFunc func)
+     {
+      SlotData* tmp=(SlotData*)s;
+      AdaptorNode *node=new AdaptorNode();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      data.obj=(Callback*)&(node->data_);
+      return tmp;
+     }
+  };
+
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class P1,class P2,
+          class R2,class Q1,class Q2>
+struct AdaptorConvertSlot2_2
+         <void,P1,P2,
+          R2,Q1,Q2>
+  : public AdaptorSlot_
+  {
+   typedef void RType;
+   typedef Slot2<void,P1,P2> SlotType;
+   typedef Slot2<R2,Q1,Q2> InSlotType;
+   typedef typename InSlotType::Callback Callback;
+   typedef RType (*Func)  (Callback*,P1,P2);
+   typedef void    (*InFunc)(Callback*,P1,P2);
+   typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2)
+     {
+      CallData* data=(CallData*)d;
+       (data->func)(data->obj,p1,p2);
+     }
+
+   static SlotData* create(SlotData *s,InFunc func)
+     {
+      SlotData* tmp=(SlotData*)s;
+      AdaptorNode *node=new AdaptorNode();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      data.obj=(Callback*)&(node->data_);
+      return tmp;
+     }
+  };
+
+
+#endif
+#endif
+
+template <class R1,class P1,class P2,
+          class R2,class Q1,class Q2>
+Slot2<R1,P1,P2>
+  convert(const Slot2<R2,Q1,Q2> &s,
+          R1 (*func)(Callback2<R2,Q1,Q2>*,P1,P2))
+  {return AdaptorConvertSlot2_2<R1,P1,P2,
+           R2,Q1,Q2>::create(s.obj(),func);
+  }
+
+
+/****************************************************************
+***** Adaptor Convert Slot 3
+****************************************************************/
+template <class R1,class P1,class P2,class P3,
+          class R2,class Q1,class Q2,class Q3>
+struct AdaptorConvertSlot3_3: public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R1 RType;
+#else
+   typedef typename Trait<R1>::type RType;
+#endif
+   typedef Slot3<R1,P1,P2,P3> SlotType;
+   typedef Slot3<R2,Q1,Q2,Q3> InSlotType;
+   typedef typename InSlotType::Callback Callback;
+   typedef RType (*Func)  (Callback*,P1,P2,P3);
+   typedef R1    (*InFunc)(Callback*,P1,P2,P3);
+   typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3)
+     {
+      CallData* data=(CallData*)d;
+      return (data->func)(data->obj,p1,p2,p3);
+     }
+
+   static SlotData* create(SlotData *s,InFunc func)
+     {
+      SlotData* tmp=(SlotData*)s;
+      AdaptorNode *node=new AdaptorNode();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      data.obj=(Callback*)&(node->data_);
+      return tmp;
+     }
+  };
+
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class P1,class P2,class P3,
+          class R2,class Q1,class Q2,class Q3>
+struct AdaptorConvertSlot3_3
+         <void,P1,P2,P3,
+          R2,Q1,Q2,Q3>
+  : public AdaptorSlot_
+  {
+   typedef void RType;
+   typedef Slot3<void,P1,P2,P3> SlotType;
+   typedef Slot3<R2,Q1,Q2,Q3> InSlotType;
+   typedef typename InSlotType::Callback Callback;
+   typedef RType (*Func)  (Callback*,P1,P2,P3);
+   typedef void    (*InFunc)(Callback*,P1,P2,P3);
+   typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3)
+     {
+      CallData* data=(CallData*)d;
+       (data->func)(data->obj,p1,p2,p3);
+     }
+
+   static SlotData* create(SlotData *s,InFunc func)
+     {
+      SlotData* tmp=(SlotData*)s;
+      AdaptorNode *node=new AdaptorNode();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      data.obj=(Callback*)&(node->data_);
+      return tmp;
+     }
+  };
+
+
+#endif
+#endif
+
+template <class R1,class P1,class P2,class P3,
+          class R2,class Q1,class Q2,class Q3>
+Slot3<R1,P1,P2,P3>
+  convert(const Slot3<R2,Q1,Q2,Q3> &s,
+          R1 (*func)(Callback3<R2,Q1,Q2,Q3>*,P1,P2,P3))
+  {return AdaptorConvertSlot3_3<R1,P1,P2,P3,
+           R2,Q1,Q2,Q3>::create(s.obj(),func);
+  }
+
+
+/****************************************************************
+***** Adaptor Convert Slot 4
+****************************************************************/
+template <class R1,class P1,class P2,class P3,class P4,
+          class R2,class Q1,class Q2,class Q3,class Q4>
+struct AdaptorConvertSlot4_4: public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R1 RType;
+#else
+   typedef typename Trait<R1>::type RType;
+#endif
+   typedef Slot4<R1,P1,P2,P3,P4> SlotType;
+   typedef Slot4<R2,Q1,Q2,Q3,Q4> InSlotType;
+   typedef typename InSlotType::Callback Callback;
+   typedef RType (*Func)  (Callback*,P1,P2,P3,P4);
+   typedef R1    (*InFunc)(Callback*,P1,P2,P3,P4);
+   typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
+     {
+      CallData* data=(CallData*)d;
+      return (data->func)(data->obj,p1,p2,p3,p4);
+     }
+
+   static SlotData* create(SlotData *s,InFunc func)
+     {
+      SlotData* tmp=(SlotData*)s;
+      AdaptorNode *node=new AdaptorNode();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      data.obj=(Callback*)&(node->data_);
+      return tmp;
+     }
+  };
+
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class P1,class P2,class P3,class P4,
+          class R2,class Q1,class Q2,class Q3,class Q4>
+struct AdaptorConvertSlot4_4
+         <void,P1,P2,P3,P4,
+          R2,Q1,Q2,Q3,Q4>
+  : public AdaptorSlot_
+  {
+   typedef void RType;
+   typedef Slot4<void,P1,P2,P3,P4> SlotType;
+   typedef Slot4<R2,Q1,Q2,Q3,Q4> InSlotType;
+   typedef typename InSlotType::Callback Callback;
+   typedef RType (*Func)  (Callback*,P1,P2,P3,P4);
+   typedef void    (*InFunc)(Callback*,P1,P2,P3,P4);
+   typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
+     {
+      CallData* data=(CallData*)d;
+       (data->func)(data->obj,p1,p2,p3,p4);
+     }
+
+   static SlotData* create(SlotData *s,InFunc func)
+     {
+      SlotData* tmp=(SlotData*)s;
+      AdaptorNode *node=new AdaptorNode();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      data.obj=(Callback*)&(node->data_);
+      return tmp;
+     }
+  };
+
+
+#endif
+#endif
+
+template <class R1,class P1,class P2,class P3,class P4,
+          class R2,class Q1,class Q2,class Q3,class Q4>
+Slot4<R1,P1,P2,P3,P4>
+  convert(const Slot4<R2,Q1,Q2,Q3,Q4> &s,
+          R1 (*func)(Callback4<R2,Q1,Q2,Q3,Q4>*,P1,P2,P3,P4))
+  {return AdaptorConvertSlot4_4<R1,P1,P2,P3,P4,
+           R2,Q1,Q2,Q3,Q4>::create(s.obj(),func);
+  }
+
+
+/****************************************************************
+***** Adaptor Convert Slot 5
+****************************************************************/
+template <class R1,class P1,class P2,class P3,class P4,class P5,
+          class R2,class Q1,class Q2,class Q3,class Q4,class Q5>
+struct AdaptorConvertSlot5_5: public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R1 RType;
+#else
+   typedef typename Trait<R1>::type RType;
+#endif
+   typedef Slot5<R1,P1,P2,P3,P4,P5> SlotType;
+   typedef Slot5<R2,Q1,Q2,Q3,Q4,Q5> InSlotType;
+   typedef typename InSlotType::Callback Callback;
+   typedef RType (*Func)  (Callback*,P1,P2,P3,P4,P5);
+   typedef R1    (*InFunc)(Callback*,P1,P2,P3,P4,P5);
+   typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
+     {
+      CallData* data=(CallData*)d;
+      return (data->func)(data->obj,p1,p2,p3,p4,p5);
+     }
+
+   static SlotData* create(SlotData *s,InFunc func)
+     {
+      SlotData* tmp=(SlotData*)s;
+      AdaptorNode *node=new AdaptorNode();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      data.obj=(Callback*)&(node->data_);
+      return tmp;
+     }
+  };
+
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class P1,class P2,class P3,class P4,class P5,
+          class R2,class Q1,class Q2,class Q3,class Q4,class Q5>
+struct AdaptorConvertSlot5_5
+         <void,P1,P2,P3,P4,P5,
+          R2,Q1,Q2,Q3,Q4,Q5>
+  : public AdaptorSlot_
+  {
+   typedef void RType;
+   typedef Slot5<void,P1,P2,P3,P4,P5> SlotType;
+   typedef Slot5<R2,Q1,Q2,Q3,Q4,Q5> InSlotType;
+   typedef typename InSlotType::Callback Callback;
+   typedef RType (*Func)  (Callback*,P1,P2,P3,P4,P5);
+   typedef void    (*InFunc)(Callback*,P1,P2,P3,P4,P5);
+   typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
+     {
+      CallData* data=(CallData*)d;
+       (data->func)(data->obj,p1,p2,p3,p4,p5);
+     }
+
+   static SlotData* create(SlotData *s,InFunc func)
+     {
+      SlotData* tmp=(SlotData*)s;
+      AdaptorNode *node=new AdaptorNode();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      data.obj=(Callback*)&(node->data_);
+      return tmp;
+     }
+  };
+
+
+#endif
+#endif
+
+template <class R1,class P1,class P2,class P3,class P4,class P5,
+          class R2,class Q1,class Q2,class Q3,class Q4,class Q5>
+Slot5<R1,P1,P2,P3,P4,P5>
+  convert(const Slot5<R2,Q1,Q2,Q3,Q4,Q5> &s,
+          R1 (*func)(Callback5<R2,Q1,Q2,Q3,Q4,Q5>*,P1,P2,P3,P4,P5))
+  {return AdaptorConvertSlot5_5<R1,P1,P2,P3,P4,P5,
+           R2,Q1,Q2,Q3,Q4,Q5>::create(s.obj(),func);
+  }
+
+
+/****************************************************************
+***** Adaptor Convert Slot 6
+****************************************************************/
+template <class R1,class P1,class P2,class P3,class P4,class P5,class P6,
+          class R2,class Q1,class Q2,class Q3,class Q4,class Q5,class Q6>
+struct AdaptorConvertSlot6_6: public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R1 RType;
+#else
+   typedef typename Trait<R1>::type RType;
+#endif
+   typedef Slot6<R1,P1,P2,P3,P4,P5,P6> SlotType;
+   typedef Slot6<R2,Q1,Q2,Q3,Q4,Q5,Q6> InSlotType;
+   typedef typename InSlotType::Callback Callback;
+   typedef RType (*Func)  (Callback*,P1,P2,P3,P4,P5,P6);
+   typedef R1    (*InFunc)(Callback*,P1,P2,P3,P4,P5,P6);
+   typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
+     {
+      CallData* data=(CallData*)d;
+      return (data->func)(data->obj,p1,p2,p3,p4,p5,p6);
+     }
+
+   static SlotData* create(SlotData *s,InFunc func)
+     {
+      SlotData* tmp=(SlotData*)s;
+      AdaptorNode *node=new AdaptorNode();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      data.obj=(Callback*)&(node->data_);
+      return tmp;
+     }
+  };
+
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class P1,class P2,class P3,class P4,class P5,class P6,
+          class R2,class Q1,class Q2,class Q3,class Q4,class Q5,class Q6>
+struct AdaptorConvertSlot6_6
+         <void,P1,P2,P3,P4,P5,P6,
+          R2,Q1,Q2,Q3,Q4,Q5,Q6>
+  : public AdaptorSlot_
+  {
+   typedef void RType;
+   typedef Slot6<void,P1,P2,P3,P4,P5,P6> SlotType;
+   typedef Slot6<R2,Q1,Q2,Q3,Q4,Q5,Q6> InSlotType;
+   typedef typename InSlotType::Callback Callback;
+   typedef RType (*Func)  (Callback*,P1,P2,P3,P4,P5,P6);
+   typedef void    (*InFunc)(Callback*,P1,P2,P3,P4,P5,P6);
+   typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
+     {
+      CallData* data=(CallData*)d;
+       (data->func)(data->obj,p1,p2,p3,p4,p5,p6);
+     }
+
+   static SlotData* create(SlotData *s,InFunc func)
+     {
+      SlotData* tmp=(SlotData*)s;
+      AdaptorNode *node=new AdaptorNode();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      data.obj=(Callback*)&(node->data_);
+      return tmp;
+     }
+  };
+
+
+#endif
+#endif
+
+template <class R1,class P1,class P2,class P3,class P4,class P5,class P6,
+          class R2,class Q1,class Q2,class Q3,class Q4,class Q5,class Q6>
+Slot6<R1,P1,P2,P3,P4,P5,P6>
+  convert(const Slot6<R2,Q1,Q2,Q3,Q4,Q5,Q6> &s,
+          R1 (*func)(Callback6<R2,Q1,Q2,Q3,Q4,Q5,Q6>*,P1,P2,P3,P4,P5,P6))
+  {return AdaptorConvertSlot6_6<R1,P1,P2,P3,P4,P5,P6,
+           R2,Q1,Q2,Q3,Q4,Q5,Q6>::create(s.obj(),func);
+  }
+
+
+/****************************************************************
+***** Adaptor Convert Slot 7
+****************************************************************/
+template <class R1,class P1,class P2,class P3,class P4,class P5,class P6,class P7,
+          class R2,class Q1,class Q2,class Q3,class Q4,class Q5,class Q6,class Q7>
+struct AdaptorConvertSlot7_7: public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R1 RType;
+#else
+   typedef typename Trait<R1>::type RType;
+#endif
+   typedef Slot7<R1,P1,P2,P3,P4,P5,P6,P7> SlotType;
+   typedef Slot7<R2,Q1,Q2,Q3,Q4,Q5,Q6,Q7> InSlotType;
+   typedef typename InSlotType::Callback Callback;
+   typedef RType (*Func)  (Callback*,P1,P2,P3,P4,P5,P6,P7);
+   typedef R1    (*InFunc)(Callback*,P1,P2,P3,P4,P5,P6,P7);
+   typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
+     {
+      CallData* data=(CallData*)d;
+      return (data->func)(data->obj,p1,p2,p3,p4,p5,p6,p7);
+     }
+
+   static SlotData* create(SlotData *s,InFunc func)
+     {
+      SlotData* tmp=(SlotData*)s;
+      AdaptorNode *node=new AdaptorNode();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      data.obj=(Callback*)&(node->data_);
+      return tmp;
+     }
+  };
+
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class P1,class P2,class P3,class P4,class P5,class P6,class P7,
+          class R2,class Q1,class Q2,class Q3,class Q4,class Q5,class Q6,class Q7>
+struct AdaptorConvertSlot7_7
+         <void,P1,P2,P3,P4,P5,P6,P7,
+          R2,Q1,Q2,Q3,Q4,Q5,Q6,Q7>
+  : public AdaptorSlot_
+  {
+   typedef void RType;
+   typedef Slot7<void,P1,P2,P3,P4,P5,P6,P7> SlotType;
+   typedef Slot7<R2,Q1,Q2,Q3,Q4,Q5,Q6,Q7> InSlotType;
+   typedef typename InSlotType::Callback Callback;
+   typedef RType (*Func)  (Callback*,P1,P2,P3,P4,P5,P6,P7);
+   typedef void    (*InFunc)(Callback*,P1,P2,P3,P4,P5,P6,P7);
+   typedef CallDataObj3<typename SlotType::Func,Callback,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
+     {
+      CallData* data=(CallData*)d;
+       (data->func)(data->obj,p1,p2,p3,p4,p5,p6,p7);
+     }
+
+   static SlotData* create(SlotData *s,InFunc func)
+     {
+      SlotData* tmp=(SlotData*)s;
+      AdaptorNode *node=new AdaptorNode();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      data.obj=(Callback*)&(node->data_);
+      return tmp;
+     }
+  };
+
+
+#endif
+#endif
+
+template <class R1,class P1,class P2,class P3,class P4,class P5,class P6,class P7,
+          class R2,class Q1,class Q2,class Q3,class Q4,class Q5,class Q6,class Q7>
+Slot7<R1,P1,P2,P3,P4,P5,P6,P7>
+  convert(const Slot7<R2,Q1,Q2,Q3,Q4,Q5,Q6,Q7> &s,
+          R1 (*func)(Callback7<R2,Q1,Q2,Q3,Q4,Q5,Q6,Q7>*,P1,P2,P3,P4,P5,P6,P7))
+  {return AdaptorConvertSlot7_7<R1,P1,P2,P3,P4,P5,P6,P7,
+           R2,Q1,Q2,Q3,Q4,Q5,Q6,Q7>::create(s.obj(),func);
+  }
+
+
+
+#ifdef SIGC_CXX_NAMESPACES
+} // namespace
+#endif
+
+#endif

programs/develop/libraries/menuetlibc/include/sigc++/func_slot.h

@@ -0,0 +1,606 @@
+// -*- c++ -*-
+/* This is a generated file, do not edit.  Generated from ../sigc++/macros/func_slot.h.m4 */
+
+#ifndef SIGCXX_FUNC_SLOT_H
+#define SIGCXX_FUNC_SLOT_H
+#include <sigc++/slot.h>
+
+/*
+  SigC::slot() (function)
+  -----------------------
+  slot() can be applied to a function to form a Slot with a 
+  profile equivelent to the function.  To avoid warns be
+  sure to pass the address of the function.
+
+  Sample usage:
+
+    void foo(int,int);
+
+    Slot2<void,int,int> s=slot(&foo);
+
+*/
+
+#ifdef SIGC_CXX_NAMESPACES
+namespace SigC
+{
+#endif
+
+// From which we build specific Slots and a set of
+// functions for creating a slot of this type
+
+
+
+/****************************************************************
+***** Function Slot 0
+****************************************************************/
+template <class R>
+struct FuncSlot0_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R RType;
+#else
+   typedef typename Trait<R>::type RType;
+#endif
+   typedef R     (*InFunc)();
+   typedef RType (*Func)();
+   typedef Slot0<R> SlotType;
+
+   typedef CallDataFunc<typename SlotType::Func,Func> CallData;
+
+   static RType callback(void* data)
+     {
+      return (((CallData*)data)->func)();
+     }
+
+   static SlotData* create(InFunc func)
+     {
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <>
+struct FuncSlot0_<void>
+  {
+   typedef void RType;
+   typedef void     (*InFunc)();
+   typedef RType (*Func)();
+   typedef Slot0<void> SlotType;
+
+   typedef CallDataFunc<SlotType::Func,Func> CallData;
+
+   static RType callback(void* data)
+     {
+       (((CallData*)data)->func)();
+     }
+
+   static SlotData* create(InFunc func)
+     {
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+template <class R>
+inline Slot0<R>
+  slot(R (*func)())
+  {
+   return FuncSlot0_<R>::create(func);
+  }
+
+
+/****************************************************************
+***** Function Slot 1
+****************************************************************/
+template <class R,class P1>
+struct FuncSlot1_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R RType;
+#else
+   typedef typename Trait<R>::type RType;
+#endif
+   typedef R     (*InFunc)(P1);
+   typedef RType (*Func)(P1);
+   typedef Slot1<R,P1> SlotType;
+
+   typedef CallDataFunc<typename SlotType::Func,Func> CallData;
+
+   static RType callback(void* data,P1 p1)
+     {
+      return (((CallData*)data)->func)(p1);
+     }
+
+   static SlotData* create(InFunc func)
+     {
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class P1>
+struct FuncSlot1_<void,P1>
+  {
+   typedef void RType;
+   typedef void     (*InFunc)(P1);
+   typedef RType (*Func)(P1);
+   typedef Slot1<void,P1> SlotType;
+
+   typedef CallDataFunc<typename SlotType::Func,Func> CallData;
+
+   static RType callback(void* data,P1 p1)
+     {
+       (((CallData*)data)->func)(p1);
+     }
+
+   static SlotData* create(InFunc func)
+     {
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+template <class R,class P1>
+inline Slot1<R,P1>
+  slot(R (*func)(P1))
+  {
+   return FuncSlot1_<R,P1>::create(func);
+  }
+
+
+/****************************************************************
+***** Function Slot 2
+****************************************************************/
+template <class R,class P1,class P2>
+struct FuncSlot2_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R RType;
+#else
+   typedef typename Trait<R>::type RType;
+#endif
+   typedef R     (*InFunc)(P1,P2);
+   typedef RType (*Func)(P1,P2);
+   typedef Slot2<R,P1,P2> SlotType;
+
+   typedef CallDataFunc<typename SlotType::Func,Func> CallData;
+
+   static RType callback(void* data,P1 p1,P2 p2)
+     {
+      return (((CallData*)data)->func)(p1,p2);
+     }
+
+   static SlotData* create(InFunc func)
+     {
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class P1,class P2>
+struct FuncSlot2_<void,P1,P2>
+  {
+   typedef void RType;
+   typedef void     (*InFunc)(P1,P2);
+   typedef RType (*Func)(P1,P2);
+   typedef Slot2<void,P1,P2> SlotType;
+
+   typedef CallDataFunc<typename SlotType::Func,Func> CallData;
+
+   static RType callback(void* data,P1 p1,P2 p2)
+     {
+       (((CallData*)data)->func)(p1,p2);
+     }
+
+   static SlotData* create(InFunc func)
+     {
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+template <class R,class P1,class P2>
+inline Slot2<R,P1,P2>
+  slot(R (*func)(P1,P2))
+  {
+   return FuncSlot2_<R,P1,P2>::create(func);
+  }
+
+
+/****************************************************************
+***** Function Slot 3
+****************************************************************/
+template <class R,class P1,class P2,class P3>
+struct FuncSlot3_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R RType;
+#else
+   typedef typename Trait<R>::type RType;
+#endif
+   typedef R     (*InFunc)(P1,P2,P3);
+   typedef RType (*Func)(P1,P2,P3);
+   typedef Slot3<R,P1,P2,P3> SlotType;
+
+   typedef CallDataFunc<typename SlotType::Func,Func> CallData;
+
+   static RType callback(void* data,P1 p1,P2 p2,P3 p3)
+     {
+      return (((CallData*)data)->func)(p1,p2,p3);
+     }
+
+   static SlotData* create(InFunc func)
+     {
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class P1,class P2,class P3>
+struct FuncSlot3_<void,P1,P2,P3>
+  {
+   typedef void RType;
+   typedef void     (*InFunc)(P1,P2,P3);
+   typedef RType (*Func)(P1,P2,P3);
+   typedef Slot3<void,P1,P2,P3> SlotType;
+
+   typedef CallDataFunc<typename SlotType::Func,Func> CallData;
+
+   static RType callback(void* data,P1 p1,P2 p2,P3 p3)
+     {
+       (((CallData*)data)->func)(p1,p2,p3);
+     }
+
+   static SlotData* create(InFunc func)
+     {
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+template <class R,class P1,class P2,class P3>
+inline Slot3<R,P1,P2,P3>
+  slot(R (*func)(P1,P2,P3))
+  {
+   return FuncSlot3_<R,P1,P2,P3>::create(func);
+  }
+
+
+/****************************************************************
+***** Function Slot 4
+****************************************************************/
+template <class R,class P1,class P2,class P3,class P4>
+struct FuncSlot4_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R RType;
+#else
+   typedef typename Trait<R>::type RType;
+#endif
+   typedef R     (*InFunc)(P1,P2,P3,P4);
+   typedef RType (*Func)(P1,P2,P3,P4);
+   typedef Slot4<R,P1,P2,P3,P4> SlotType;
+
+   typedef CallDataFunc<typename SlotType::Func,Func> CallData;
+
+   static RType callback(void* data,P1 p1,P2 p2,P3 p3,P4 p4)
+     {
+      return (((CallData*)data)->func)(p1,p2,p3,p4);
+     }
+
+   static SlotData* create(InFunc func)
+     {
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class P1,class P2,class P3,class P4>
+struct FuncSlot4_<void,P1,P2,P3,P4>
+  {
+   typedef void RType;
+   typedef void     (*InFunc)(P1,P2,P3,P4);
+   typedef RType (*Func)(P1,P2,P3,P4);
+   typedef Slot4<void,P1,P2,P3,P4> SlotType;
+
+   typedef CallDataFunc<typename SlotType::Func,Func> CallData;
+
+   static RType callback(void* data,P1 p1,P2 p2,P3 p3,P4 p4)
+     {
+       (((CallData*)data)->func)(p1,p2,p3,p4);
+     }
+
+   static SlotData* create(InFunc func)
+     {
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+template <class R,class P1,class P2,class P3,class P4>
+inline Slot4<R,P1,P2,P3,P4>
+  slot(R (*func)(P1,P2,P3,P4))
+  {
+   return FuncSlot4_<R,P1,P2,P3,P4>::create(func);
+  }
+
+
+/****************************************************************
+***** Function Slot 5
+****************************************************************/
+template <class R,class P1,class P2,class P3,class P4,class P5>
+struct FuncSlot5_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R RType;
+#else
+   typedef typename Trait<R>::type RType;
+#endif
+   typedef R     (*InFunc)(P1,P2,P3,P4,P5);
+   typedef RType (*Func)(P1,P2,P3,P4,P5);
+   typedef Slot5<R,P1,P2,P3,P4,P5> SlotType;
+
+   typedef CallDataFunc<typename SlotType::Func,Func> CallData;
+
+   static RType callback(void* data,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
+     {
+      return (((CallData*)data)->func)(p1,p2,p3,p4,p5);
+     }
+
+   static SlotData* create(InFunc func)
+     {
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class P1,class P2,class P3,class P4,class P5>
+struct FuncSlot5_<void,P1,P2,P3,P4,P5>
+  {
+   typedef void RType;
+   typedef void     (*InFunc)(P1,P2,P3,P4,P5);
+   typedef RType (*Func)(P1,P2,P3,P4,P5);
+   typedef Slot5<void,P1,P2,P3,P4,P5> SlotType;
+
+   typedef CallDataFunc<typename SlotType::Func,Func> CallData;
+
+   static RType callback(void* data,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
+     {
+       (((CallData*)data)->func)(p1,p2,p3,p4,p5);
+     }
+
+   static SlotData* create(InFunc func)
+     {
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+template <class R,class P1,class P2,class P3,class P4,class P5>
+inline Slot5<R,P1,P2,P3,P4,P5>
+  slot(R (*func)(P1,P2,P3,P4,P5))
+  {
+   return FuncSlot5_<R,P1,P2,P3,P4,P5>::create(func);
+  }
+
+
+/****************************************************************
+***** Function Slot 6
+****************************************************************/
+template <class R,class P1,class P2,class P3,class P4,class P5,class P6>
+struct FuncSlot6_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R RType;
+#else
+   typedef typename Trait<R>::type RType;
+#endif
+   typedef R     (*InFunc)(P1,P2,P3,P4,P5,P6);
+   typedef RType (*Func)(P1,P2,P3,P4,P5,P6);
+   typedef Slot6<R,P1,P2,P3,P4,P5,P6> SlotType;
+
+   typedef CallDataFunc<typename SlotType::Func,Func> CallData;
+
+   static RType callback(void* data,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
+     {
+      return (((CallData*)data)->func)(p1,p2,p3,p4,p5,p6);
+     }
+
+   static SlotData* create(InFunc func)
+     {
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class P1,class P2,class P3,class P4,class P5,class P6>
+struct FuncSlot6_<void,P1,P2,P3,P4,P5,P6>
+  {
+   typedef void RType;
+   typedef void     (*InFunc)(P1,P2,P3,P4,P5,P6);
+   typedef RType (*Func)(P1,P2,P3,P4,P5,P6);
+   typedef Slot6<void,P1,P2,P3,P4,P5,P6> SlotType;
+
+   typedef CallDataFunc<typename SlotType::Func,Func> CallData;
+
+   static RType callback(void* data,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
+     {
+       (((CallData*)data)->func)(p1,p2,p3,p4,p5,p6);
+     }
+
+   static SlotData* create(InFunc func)
+     {
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+template <class R,class P1,class P2,class P3,class P4,class P5,class P6>
+inline Slot6<R,P1,P2,P3,P4,P5,P6>
+  slot(R (*func)(P1,P2,P3,P4,P5,P6))
+  {
+   return FuncSlot6_<R,P1,P2,P3,P4,P5,P6>::create(func);
+  }
+
+
+/****************************************************************
+***** Function Slot 7
+****************************************************************/
+template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7>
+struct FuncSlot7_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R RType;
+#else
+   typedef typename Trait<R>::type RType;
+#endif
+   typedef R     (*InFunc)(P1,P2,P3,P4,P5,P6,P7);
+   typedef RType (*Func)(P1,P2,P3,P4,P5,P6,P7);
+   typedef Slot7<R,P1,P2,P3,P4,P5,P6,P7> SlotType;
+
+   typedef CallDataFunc<typename SlotType::Func,Func> CallData;
+
+   static RType callback(void* data,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
+     {
+      return (((CallData*)data)->func)(p1,p2,p3,p4,p5,p6,p7);
+     }
+
+   static SlotData* create(InFunc func)
+     {
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class P1,class P2,class P3,class P4,class P5,class P6,class P7>
+struct FuncSlot7_<void,P1,P2,P3,P4,P5,P6,P7>
+  {
+   typedef void RType;
+   typedef void     (*InFunc)(P1,P2,P3,P4,P5,P6,P7);
+   typedef RType (*Func)(P1,P2,P3,P4,P5,P6,P7);
+   typedef Slot7<void,P1,P2,P3,P4,P5,P6,P7> SlotType;
+
+   typedef CallDataFunc<typename SlotType::Func,Func> CallData;
+
+   static RType callback(void* data,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
+     {
+       (((CallData*)data)->func)(p1,p2,p3,p4,p5,p6,p7);
+     }
+
+   static SlotData* create(InFunc func)
+     {
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.func=(Func)func;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7>
+inline Slot7<R,P1,P2,P3,P4,P5,P6,P7>
+  slot(R (*func)(P1,P2,P3,P4,P5,P6,P7))
+  {
+   return FuncSlot7_<R,P1,P2,P3,P4,P5,P6,P7>::create(func);
+  }
+
+
+
+#ifdef SIGC_CXX_NAMESPACES
+} // namespace
+#endif
+
+#endif // SIGCXX_FUNC_SLOT_H

programs/develop/libraries/menuetlibc/include/sigc++/generator.h

@@ -0,0 +1,159 @@
+#ifndef SIGCXX_GENERATOR_H
+#define SIGCXX_GENERATOR_H
+#include <sigc++config.h>
+#include <new>
+
+#ifdef SIGC_CXX_NAMESPACES
+namespace SigC
+{
+#endif 
+
+
+// 0
+template <class T> 
+  T* gen()
+  {return manage(new T());}
+
+// 1
+template <class T,class P1> 
+  T* gen(const P1& p1)
+  {return manage(new T(p1));}
+
+template <class T,class P1> 
+  T* gen(P1& p1)
+  {return manage(new T(p1));}
+
+// 2
+template <class T,class P1,class P2> 
+  T* gen(const P1& p1,const P2& p2)
+  {return manage(new T(p1,p2));}
+
+template <class T,class P1,class P2> 
+  T* gen(P1& p1,const P2& p2)
+  {return manage(new T(p1,p2));}
+
+template <class T,class P1,class P2> 
+  T* gen(const P1& p1,P2& p2)
+  {return manage(new T(p1,p2));}
+
+template <class T,class P1,class P2> 
+  T* gen(P1& p1,P2& p2)
+  {return manage(new T(p1,p2));}
+
+// 3
+template <class T,class P1,class P2,class P3> 
+  T* gen(const P1& p1,const P2& p2,const P3& p3)
+  {return manage(new T(p1,p2,p3));}
+
+template <class T,class P1,class P2,class P3> 
+  T* gen(P1& p1,const P2& p2,const P3& p3)
+  {return manage(new T(p1,p2,p3));}
+
+template <class T,class P1,class P2,class P3> 
+  T* gen(const P1& p1,P2& p2,const P3& p3)
+  {return manage(new T(p1,p2,p3));}
+
+template <class T,class P1,class P2,class P3> 
+  T* gen(const P1& p1,const P2& p2,P3& p3)
+  {return manage(new T(p1,p2,p3));}
+
+template <class T,class P1,class P2,class P3> 
+  T* gen(const P1& p1,P2& p2,P3& p3)
+  {return manage(new T(p1,p2,p3));}
+
+template <class T,class P1,class P2,class P3> 
+  T* gen(P1& p1,const P2& p2,P3& p3)
+  {return manage(new T(p1,p2,p3));}
+
+template <class T,class P1,class P2,class P3> 
+  T* gen(P1& p1,P2& p2,const P3& p3)
+  {return manage(new T(p1,p2,p3));}
+
+template <class T,class P1,class P2,class P3> 
+  T* gen(P1& p1,P2& p2,P3& p3)
+  {return manage(new T(p1,p2,p3));}
+
+// 4
+template <class T,class P1,class P2,class P3,class P4> 
+  T* gen(const P1& p1,const P2& p2,const P3& p3,const P4& p4)
+  {return manage(new T(p1,p2,p3,p4));}
+
+template <class T,class P1,class P2,class P3,class P4> 
+  T* gen(P1& p1,const P2& p2,const P3& p3,const P4& p4)
+  {return manage(new T(p1,p2,p3,p4));}
+
+template <class T,class P1,class P2,class P3,class P4> 
+  T* gen(const P1& p1,P2& p2,const P3& p3,const P4& p4)
+  {return manage(new T(p1,p2,p3,p4));}
+
+template <class T,class P1,class P2,class P3,class P4> 
+  T* gen(const P1& p1,const P2& p2,P3& p3,const P4& p4)
+  {return manage(new T(p1,p2,p3,p4));}
+
+template <class T,class P1,class P2,class P3,class P4> 
+  T* gen(const P1& p1,const P2& p2,const P3& p3,P4& p4)
+  {return manage(new T(p1,p2,p3,p4));}
+
+template <class T,class P1,class P2,class P3,class P4> 
+  T* gen(const P1& p1,P2& p2,P3& p3,P4& p4)
+  {return manage(new T(p1,p2,p3,p4));}
+
+template <class T,class P1,class P2,class P3,class P4> 
+  T* gen(P1& p1,const P2& p2,P3& p3,P4& p4)
+  {return manage(new T(p1,p2,p3,p4));}
+
+template <class T,class P1,class P2,class P3,class P4> 
+  T* gen(P1& p1,P2& p2,const P3& p3,P4& p4)
+  {return manage(new T(p1,p2,p3,p4));}
+
+template <class T,class P1,class P2,class P3,class P4> 
+  T* gen(P1& p1,P2& p2,P3& p3,const P4& p4)
+  {return manage(new T(p1,p2,p3,p4));}
+
+template <class T,class P1,class P2,class P3,class P4> 
+  T* gen(const P1& p1,const P2& p2,P3& p3,P4& p4)
+  {return manage(new T(p1,p2,p3,p4));}
+
+template <class T,class P1,class P2,class P3,class P4> 
+  T* gen(const P1& p1,P2& p2,const P3& p3,P4& p4)
+  {return manage(new T(p1,p2,p3,p4));}
+
+template <class T,class P1,class P2,class P3,class P4> 
+  T* gen(const P1& p1,P2& p2,P3& p3,const P4& p4)
+  {return manage(new T(p1,p2,p3,p4));}
+
+template <class T,class P1,class P2,class P3,class P4> 
+  T* gen(P1& p1,const P2& p2,const P3& p3,P4& p4)
+  {return manage(new T(p1,p2,p3,p4));}
+
+template <class T,class P1,class P2,class P3,class P4> 
+  T* gen(P1& p1,const P2& p2,P3& p3,const P4& p4)
+  {return manage(new T(p1,p2,p3,p4));}
+
+template <class T,class P1,class P2,class P3,class P4> 
+  T* gen(P1& p1,P2& p2,const P3& p3,const P4& p4)
+  {return manage(new T(p1,p2,p3,p4));}
+
+template <class T,class P1,class P2,class P3,class P4> 
+  T* gen(P1& p1,P2& p2,P3& p3,P4& p4)
+  {return manage(new T(p1,p2,p3,p4));}
+
+//From here one we will just generate warnings
+template <class T,class P1,class P2,class P3,class P4,class P5> 
+  T* gen(P1& p1,P2& p2,P3& p3,P4& p4,P5& p5)
+  {return manage(new T(p1,p2,p3,p4,p5));}
+
+template <class T,class P1,class P2,class P3,class P4,class P5,class P6> 
+  T* gen(P1& p1,P2& p2,P3& p3,P4& p4,P5& p5,P6& p6)
+  {return manage(new T(p1,p2,p3,p4,p5,p6));}
+
+template <class T,class P1,class P2,class P3,class P4,class P5,class P6,class P7> 
+  T* gen(P1& p1,P2& p2,P3& p3,P4& p4,P5& p5,P6& p6,P7& p7)
+  {return manage(new T(p1,p2,p3,p4,p5,p6,p7));}
+
+#ifdef SIGC_CXX_NAMESPACES
+} // namespace sigc
+#endif
+
+#endif
+

programs/develop/libraries/menuetlibc/include/sigc++/handle.h

@@ -0,0 +1,113 @@
+#ifndef SIGCXX_HANDLE_H
+#define SIGCXX_HANDLE_H
+#include <sigc++config.h>
+
+#ifdef SIGC_CXX_NAMESPACES
+namespace SigC
+{
+#endif
+
+// Signiture for Handles
+template <class Obj,class Scope_>
+  class Handle
+  {
+   protected:
+     Scope_ scope_;
+   public:
+     // access
+     Obj* obj()
+       {
+        return static_cast<Obj*>(scope_.cache());
+       }
+     Obj* obj() const
+       {
+        return static_cast<Obj*>(scope_.cache());
+       }
+
+     bool connected() const
+       {return  (scope_.object()!=0);}
+     operator Obj*() 
+       {return  (obj());}
+     operator Obj*() const
+       {return  (obj());}
+
+     Obj& operator*() const
+       {return *(obj());}
+     Obj* operator->() const
+       {return  (obj());}
+
+     Scope_& scope()
+       {return scope_;}
+     const Scope_& scope() const
+       {return scope_;}
+
+     void disconnect()
+       {scope_.disconnect(0);}
+
+     // copy
+     Handle& operator =(Obj* obj)
+       {scope_.set(obj,obj,true); return *this;}
+     Handle& operator =(Obj& obj)
+       {scope_.set(&obj,&obj,false); return *this;}
+#ifndef SIGC_CXX_TEMPLATE_CCTOR
+     Handle& operator =(const Handle& handle)
+       {
+        Obj *o=handle.obj();
+        scope_.set(o,o,false);
+        return *this;
+       }
+#endif
+     template <class Obj2,class Scope2>
+       Handle& operator = (const Handle<Obj2,Scope2>& handle)
+       {
+        Obj *o=handle.obj();
+        scope_.set(o,o,false);
+        return *this;
+       }
+
+     // construct
+     Handle():scope_()           {}
+     Handle(Obj *obj):scope_()   {scope_.set(obj,obj,true);}
+     Handle(Obj &obj):scope_()   {scope_.set(&obj,&obj,false);}
+#ifndef SIGC_CXX_TEMPLATE_CCTOR
+     Handle(const Handle& handle)
+       :scope_() 
+       {
+        Obj *o=handle.obj();
+        scope_.set(o,o,false);
+       }
+#endif
+     template <class Obj2,class Scope2>
+     Handle(const Handle<Obj2,Scope2>& handle)
+       :scope_()
+       {
+        Obj *o=handle.obj();
+        scope_.set(o,o,false);
+       }
+  };
+
+#define HANDLE_CTORS(X,T,P)                  \
+public:                                       \
+  X(T *t):Handle<T,P>(t) {}                    \
+  X(T &t):Handle<T,P>(t) {}                     \
+  template <class T2,class P2>                   \
+    X(const Handle<T2,P2> &h):Handle<T,P>(h) {}   \
+  X& operator =(T *t)                              \
+    {return Handle<T,P>::operator=(t);}             \
+  X& operator =(T &t)                                \
+    {return Handle<T,P>::operator=(t);}               \
+  template <class T2,class P2>                         \
+  X& operator =(const Handle<T2,P2> &t)                 \
+    {return Handle<T,P>::operator=(t);}
+
+//template <class T>
+//  class Ref:public Handle<T,Scopes::RefCount>
+//    {
+//     HANDLE_CTORS(Ref,T,Scopes::RefCount)
+//    };
+
+#ifdef SIGC_CXX_NAMESPACES
+} // namespace
+#endif
+
+#endif

programs/develop/libraries/menuetlibc/include/sigc++/handle_system.h

@@ -0,0 +1,4 @@
+
+#include <sigc++/object.h>
+#include <sigc++/scope.h>
+#include <sigc++/handle.h>

programs/develop/libraries/menuetlibc/include/sigc++/marshal.h

@@ -0,0 +1,205 @@
+#ifndef SIGCXX_MARSHALLER_H
+#define SIGCXX_MARSHALLER_H
+#include <sigc++config.h>
+
+#ifndef SIGC_CXX_PARTIAL_SPEC
+#include <sigc++/slot.h>
+#endif
+
+#ifdef SIGC_PTHREADS
+#include <sigc++/thread.h>
+#endif
+
+#ifdef SIGC_CXX_NAMESPACES
+namespace SigC
+{
+#endif 
+
+/* 
+
+All classes used to marshal return values should have the following
+
+  class SomeMarshal
+    {
+     // both typedefs must be defined.
+     typedef Type1 InType;
+     typedef Type2 OutType;
+
+     public:
+       // Return final return code.
+       OutType value();  
+
+       // Captures return codes and returns TRUE to stop emittion.
+       bool marshal(const InType&);
+
+       SomeMarshal();
+   };
+
+It is not necessary for the InType to match the OutType.
+This is to allow for things like list capturing.
+
+*/
+
+/*******************************************************************
+***** Marshal 
+*******************************************************************/
+
+// A struct that holds an flag for determining 
+// if the return value is to be ignored.  
+class LIBSIGC_API RetCode
+  {
+   public:
+     static int check_ignore();
+     static void ignore();
+  };
+
+// Basic Marshal class.  
+template <typename R>
+class Marshal
+  {
+   public:
+     typedef R OutType;
+#ifdef SIGC_CXX_PARTIAL_SPEC
+     typedef R InType;
+   protected:
+     typedef OutType OutType_;
+#else
+     typedef Trait<R>::type InType;
+   protected:
+     typedef InType OutType_;
+#endif
+     OutType_ value_;
+   public:
+     OutType_& value() {return value_;}
+
+     static OutType_ default_value() 
+#ifdef SIGC_CXX_INT_CTOR
+       {return OutType_();}
+#else
+       {OutType_ r; new (&r) OutType_(); return r;}
+#endif
+
+     // This captures return values.  Return TRUE to stop emittion process.
+     bool marshal(const InType& newval)
+       {
+        if (!RetCode::check_ignore()) value_=newval;
+        return 0;  // continue emittion process
+       };
+     Marshal()
+#ifdef SIGC_CXX_INT_CTOR
+       :value_()
+       {RetCode::check_ignore();}
+#else
+       {
+        RetCode::check_ignore();
+        new (&value_) OutType_();
+       }
+#endif
+  };
+
+#ifdef SIGC_CXX_SPECIALIZE_REFERENCES
+// Basic Marshal class.
+template <typename R>
+class Marshal<R&>
+  {
+    public:
+     typedef R& OutType;
+     typedef R& InType;
+     R* value_;
+     OutType value() {return value_;}
+     static OutType default_value() {return Default;}
+     static R Default;
+
+     // This captures return values.  Return TRUE to stop emittion process.
+     bool marshal(InType newval)
+       {
+        if (!RetCode::check_ignore()) value_=&newval;
+        return 0;  // continue emittion process
+       };
+     Marshal()
+       :value_(&Default)
+       {RetCode::check_ignore();}
+     ~Marshal()
+       {}
+  };
+
+template <typename T> T Marshal<T&>::Default;
+#endif
+
+#ifdef SIGC_CXX_PARTIAL_SPEC
+// dummy marshaller for void type.
+template <>
+class Marshal<void>
+  {
+   public:
+   Marshal() 
+     {}
+   ~Marshal()
+     {}
+  };
+#endif
+
+
+// starts with a fixed value
+template <class R,R initial>
+class FixedMarshal
+  {
+    public:
+     typedef R OutType;
+     typedef R InType;
+     R value_;
+     OutType& value() {return value_;}
+     static OutType default_value() { return initial; }
+
+     bool marshal(const InType& newval)
+       {
+        if (!RetCode::check_ignore()) value_=newval;
+        return 0;  // continue emittion process
+       };
+
+     FixedMarshal()
+       :value_(initial) 
+       {RetCode::check_ignore();}
+     ~FixedMarshal()
+       {}
+  };
+
+template <class R>
+struct FastMarshal
+  {
+     typedef R OutType;
+     typedef R InType;
+
+     R value_;
+     OutType& value() {return value_;}
+     static OutType default_value() 
+#ifdef SIGC_CXX_INT_CTOR
+       {return R();}
+#else
+       {R r; new (&r) R(); return r;}
+#endif
+
+     bool marshal(const InType& newval)
+       {
+        value_=newval;
+        return 0;  // continue emittion process
+       };
+
+     FastMarshal()
+#ifdef SIGC_CXX_INT_CTOR
+       :value_()
+       {}
+#else
+       {new (&value_) R();}
+#endif
+     ~FastMarshal()
+       {}
+  };
+
+
+
+#ifdef SIGC_CXX_NAMESPACES
+} // namespace sigc
+#endif
+
+#endif

programs/develop/libraries/menuetlibc/include/sigc++/object.h

@@ -0,0 +1,153 @@
+// -*- c++ -*-
+/* 
+ * Copyright 1999 Karl Nelson <kenelson@ece.ucdavis.edu>
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#ifndef SIGCXX_OBJECT_H
+#define SIGCXX_OBJECT_H
+#include <sigc++config.h>
+#include <sigc++/scope.h>
+
+
+#ifdef SIGC_CXX_NAMESPACES
+namespace SigC
+{
+#endif
+
+extern int sigc_micro_version;
+extern int sigc_minor_version;
+extern int sigc_major_version;
+
+class Invalid_;
+class LIBSIGC_API ObjectReferenced
+  {
+   friend class Reference;
+   friend class Scope;
+   friend class Invalid_;
+
+#ifdef SIGC_CXX_FRIEND_TEMPLATES
+   template <class T>
+     friend T* manage(T*);
+#endif
+
+   protected:
+     // count of current references
+     unsigned int obj_count_    :24;
+
+     // indicates object generated through an interface that marks dynamic
+     unsigned int obj_dynamic_  :1;
+
+     // indicates the pointed to scope is the owner
+     unsigned int obj_owned_    :1;
+
+     // indicates object not will delete when count reachs zero
+     unsigned int obj_floating_ :1;
+
+     // indicates the owned scope is surrendering ownership
+     unsigned int obj_transfer_ :1;
+
+     // indicates the object is doing a list clean up 
+     unsigned int obj_invalid_  :1;
+
+     // indicates the object been destroyed 
+     unsigned int obj_destroyed_ :1;
+
+     // indicates there is a weak reference
+     unsigned int obj_weak_ :1;
+
+
+   /*************************************************************/
+#ifdef SIGC_CXX_FRIEND_TEMPLATES
+   protected:
+#else
+   public:
+#endif
+     // For the controller and scope
+     virtual void set_dynamic(); 
+     inline void set_sink() {obj_floating_=0;}
+
+   protected:
+
+     inline void register_ref(Reference *)
+       {  
+        if (obj_transfer_) 
+         {
+          obj_transfer_=0;
+          obj_owned_=0;
+         }
+       }
+  
+   public:
+     virtual void reference();
+     virtual void unreference();
+
+     inline bool is_dynamic()  {return obj_dynamic_;}
+     inline bool is_floating() {return obj_floating_;}
+
+     ObjectReferenced();
+     virtual ~ObjectReferenced();
+  };
+
+
+class LIBSIGC_API ObjectScoped :public ObjectReferenced
+  {
+   friend class Scope;
+   typedef ScopeList List_;
+
+   private:
+     mutable List_ list_;
+
+   // interface for scopes
+     void register_scope(Scope *scope,const Scope *parent=0);
+     void unregister_scope(Scope *scope);
+
+   protected:
+     // This sets a very weak reference which is removed at next invalid
+     void set_weak();
+
+   public:
+     void register_data(ScopeNode* data);
+
+     // inform connections that object wishs to delete
+     void invalid(bool destroy=0);
+
+     ObjectScoped();
+     virtual ~ObjectScoped();
+  };
+
+
+// There can only be one Scope_Object per any object
+class LIBSIGC_API Object: public virtual ObjectScoped 
+  {
+   public:
+     Object() {}
+     virtual ~Object();
+  };
+
+// mark this a managable object
+template <class T>
+inline T* manage(T* t)
+  { 
+   if (t) t->set_dynamic();
+   return t;
+  }
+
+
+#ifdef SIGC_CXX_NAMESPACES
+} // namespace
+#endif
+
+#endif

programs/develop/libraries/menuetlibc/include/sigc++/object_slot.h

@@ -0,0 +1,818 @@
+// -*- c++ -*-
+/* This is a generated file, do not edit.  Generated from ../sigc++/macros/object_slot.h.m4 */
+
+#ifndef SIGCXX_OBJECT_SLOT_H
+#define SIGCXX_OBJECT_SLOT_H
+
+/*
+  SigC::slot() (obj)
+  -----------------------
+  slot() can be applied to a object method to form a Slot with a 
+  profile equivelent to the method.  At the same time an instance
+  of that object must be specified.  The object must be derived
+  from SigC::Object.
+
+  Sample usage:
+
+    struct A: public SigC::Object
+      {
+       void foo(int,int);
+      } a;
+
+    Slot2<void,int,int> s=slot(a,&A::foo);
+
+*/
+
+
+#include <sigc++/slot.h>
+#include <sigc++/scope.h>
+
+#ifdef SIGC_CXX_NAMESPACES
+namespace SigC
+{
+#endif
+
+
+
+/****************************************************************
+***** Object Slot 0
+****************************************************************/
+template <class R,class Obj>
+struct ObjectSlot0_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R RType;
+#else
+   typedef typename Trait<R>::type RType;
+#endif
+   typedef R     (Obj::*InFunc)();
+   typedef RType (Obj::*Func)();
+   typedef Slot0<R> SlotType;
+   typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
+
+   static RType callback(void* d)
+     {
+      CallData* data=(CallData*)d;
+      return ((data->obj)->*(data->func))();
+     }
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      obj->register_data(tmp->receiver());
+      return tmp;
+     }
+  };
+
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class Obj>
+struct ObjectSlot0_<void,Obj>
+  {
+   typedef void RType;
+   typedef void     (Obj::*InFunc)();
+   typedef RType (Obj::*Func)();
+   typedef Slot0<void> SlotType;
+   typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
+
+   static RType callback(void* d)
+     {
+      CallData* data=(CallData*)d;
+       ((data->obj)->*(data->func))();
+     }
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      obj->register_data(tmp->receiver());
+      return tmp;
+     }
+  };
+
+
+#endif
+#endif
+
+template <class R,class O,class O2>
+inline Slot0<R>
+  slot(O* &obj,R (O2::*func)())
+  {
+    return ObjectSlot0_<R,O2>
+             ::create(obj,func);
+  }
+
+template <class R,class O,class O2>
+inline Slot0<R>
+  slot(O* const &obj,R (O2::*func)())
+  {
+    return ObjectSlot0_<R,O2>
+             ::create(obj,func);
+  }
+
+template <class R,class O,class O2>
+inline Slot0<R>
+  slot(O &obj,R (O2::*func)())
+  {
+    return ObjectSlot0_<R,O2>
+             ::create(&obj,func);
+  }
+
+
+
+/****************************************************************
+***** Object Slot 1
+****************************************************************/
+template <class R,class P1,class Obj>
+struct ObjectSlot1_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R RType;
+#else
+   typedef typename Trait<R>::type RType;
+#endif
+   typedef R     (Obj::*InFunc)(P1);
+   typedef RType (Obj::*Func)(P1);
+   typedef Slot1<R,P1> SlotType;
+   typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
+
+   static RType callback(void* d,P1 p1)
+     {
+      CallData* data=(CallData*)d;
+      return ((data->obj)->*(data->func))(p1);
+     }
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      obj->register_data(tmp->receiver());
+      return tmp;
+     }
+  };
+
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class P1,class Obj>
+struct ObjectSlot1_<void,P1,Obj>
+  {
+   typedef void RType;
+   typedef void     (Obj::*InFunc)(P1);
+   typedef RType (Obj::*Func)(P1);
+   typedef Slot1<void,P1> SlotType;
+   typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
+
+   static RType callback(void* d,P1 p1)
+     {
+      CallData* data=(CallData*)d;
+       ((data->obj)->*(data->func))(p1);
+     }
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      obj->register_data(tmp->receiver());
+      return tmp;
+     }
+  };
+
+
+#endif
+#endif
+
+template <class R,class P1,class O,class O2>
+inline Slot1<R,P1>
+  slot(O* &obj,R (O2::*func)(P1))
+  {
+    return ObjectSlot1_<R,P1,O2>
+             ::create(obj,func);
+  }
+
+template <class R,class P1,class O,class O2>
+inline Slot1<R,P1>
+  slot(O* const &obj,R (O2::*func)(P1))
+  {
+    return ObjectSlot1_<R,P1,O2>
+             ::create(obj,func);
+  }
+
+template <class R,class P1,class O,class O2>
+inline Slot1<R,P1>
+  slot(O &obj,R (O2::*func)(P1))
+  {
+    return ObjectSlot1_<R,P1,O2>
+             ::create(&obj,func);
+  }
+
+
+
+/****************************************************************
+***** Object Slot 2
+****************************************************************/
+template <class R,class P1,class P2,class Obj>
+struct ObjectSlot2_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R RType;
+#else
+   typedef typename Trait<R>::type RType;
+#endif
+   typedef R     (Obj::*InFunc)(P1,P2);
+   typedef RType (Obj::*Func)(P1,P2);
+   typedef Slot2<R,P1,P2> SlotType;
+   typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2)
+     {
+      CallData* data=(CallData*)d;
+      return ((data->obj)->*(data->func))(p1,p2);
+     }
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      obj->register_data(tmp->receiver());
+      return tmp;
+     }
+  };
+
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class P1,class P2,class Obj>
+struct ObjectSlot2_<void,P1,P2,Obj>
+  {
+   typedef void RType;
+   typedef void     (Obj::*InFunc)(P1,P2);
+   typedef RType (Obj::*Func)(P1,P2);
+   typedef Slot2<void,P1,P2> SlotType;
+   typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2)
+     {
+      CallData* data=(CallData*)d;
+       ((data->obj)->*(data->func))(p1,p2);
+     }
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      obj->register_data(tmp->receiver());
+      return tmp;
+     }
+  };
+
+
+#endif
+#endif
+
+template <class R,class P1,class P2,class O,class O2>
+inline Slot2<R,P1,P2>
+  slot(O* &obj,R (O2::*func)(P1,P2))
+  {
+    return ObjectSlot2_<R,P1,P2,O2>
+             ::create(obj,func);
+  }
+
+template <class R,class P1,class P2,class O,class O2>
+inline Slot2<R,P1,P2>
+  slot(O* const &obj,R (O2::*func)(P1,P2))
+  {
+    return ObjectSlot2_<R,P1,P2,O2>
+             ::create(obj,func);
+  }
+
+template <class R,class P1,class P2,class O,class O2>
+inline Slot2<R,P1,P2>
+  slot(O &obj,R (O2::*func)(P1,P2))
+  {
+    return ObjectSlot2_<R,P1,P2,O2>
+             ::create(&obj,func);
+  }
+
+
+
+/****************************************************************
+***** Object Slot 3
+****************************************************************/
+template <class R,class P1,class P2,class P3,class Obj>
+struct ObjectSlot3_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R RType;
+#else
+   typedef typename Trait<R>::type RType;
+#endif
+   typedef R     (Obj::*InFunc)(P1,P2,P3);
+   typedef RType (Obj::*Func)(P1,P2,P3);
+   typedef Slot3<R,P1,P2,P3> SlotType;
+   typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3)
+     {
+      CallData* data=(CallData*)d;
+      return ((data->obj)->*(data->func))(p1,p2,p3);
+     }
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      obj->register_data(tmp->receiver());
+      return tmp;
+     }
+  };
+
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class P1,class P2,class P3,class Obj>
+struct ObjectSlot3_<void,P1,P2,P3,Obj>
+  {
+   typedef void RType;
+   typedef void     (Obj::*InFunc)(P1,P2,P3);
+   typedef RType (Obj::*Func)(P1,P2,P3);
+   typedef Slot3<void,P1,P2,P3> SlotType;
+   typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3)
+     {
+      CallData* data=(CallData*)d;
+       ((data->obj)->*(data->func))(p1,p2,p3);
+     }
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      obj->register_data(tmp->receiver());
+      return tmp;
+     }
+  };
+
+
+#endif
+#endif
+
+template <class R,class P1,class P2,class P3,class O,class O2>
+inline Slot3<R,P1,P2,P3>
+  slot(O* &obj,R (O2::*func)(P1,P2,P3))
+  {
+    return ObjectSlot3_<R,P1,P2,P3,O2>
+             ::create(obj,func);
+  }
+
+template <class R,class P1,class P2,class P3,class O,class O2>
+inline Slot3<R,P1,P2,P3>
+  slot(O* const &obj,R (O2::*func)(P1,P2,P3))
+  {
+    return ObjectSlot3_<R,P1,P2,P3,O2>
+             ::create(obj,func);
+  }
+
+template <class R,class P1,class P2,class P3,class O,class O2>
+inline Slot3<R,P1,P2,P3>
+  slot(O &obj,R (O2::*func)(P1,P2,P3))
+  {
+    return ObjectSlot3_<R,P1,P2,P3,O2>
+             ::create(&obj,func);
+  }
+
+
+
+/****************************************************************
+***** Object Slot 4
+****************************************************************/
+template <class R,class P1,class P2,class P3,class P4,class Obj>
+struct ObjectSlot4_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R RType;
+#else
+   typedef typename Trait<R>::type RType;
+#endif
+   typedef R     (Obj::*InFunc)(P1,P2,P3,P4);
+   typedef RType (Obj::*Func)(P1,P2,P3,P4);
+   typedef Slot4<R,P1,P2,P3,P4> SlotType;
+   typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
+     {
+      CallData* data=(CallData*)d;
+      return ((data->obj)->*(data->func))(p1,p2,p3,p4);
+     }
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      obj->register_data(tmp->receiver());
+      return tmp;
+     }
+  };
+
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class P1,class P2,class P3,class P4,class Obj>
+struct ObjectSlot4_<void,P1,P2,P3,P4,Obj>
+  {
+   typedef void RType;
+   typedef void     (Obj::*InFunc)(P1,P2,P3,P4);
+   typedef RType (Obj::*Func)(P1,P2,P3,P4);
+   typedef Slot4<void,P1,P2,P3,P4> SlotType;
+   typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
+     {
+      CallData* data=(CallData*)d;
+       ((data->obj)->*(data->func))(p1,p2,p3,p4);
+     }
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      obj->register_data(tmp->receiver());
+      return tmp;
+     }
+  };
+
+
+#endif
+#endif
+
+template <class R,class P1,class P2,class P3,class P4,class O,class O2>
+inline Slot4<R,P1,P2,P3,P4>
+  slot(O* &obj,R (O2::*func)(P1,P2,P3,P4))
+  {
+    return ObjectSlot4_<R,P1,P2,P3,P4,O2>
+             ::create(obj,func);
+  }
+
+template <class R,class P1,class P2,class P3,class P4,class O,class O2>
+inline Slot4<R,P1,P2,P3,P4>
+  slot(O* const &obj,R (O2::*func)(P1,P2,P3,P4))
+  {
+    return ObjectSlot4_<R,P1,P2,P3,P4,O2>
+             ::create(obj,func);
+  }
+
+template <class R,class P1,class P2,class P3,class P4,class O,class O2>
+inline Slot4<R,P1,P2,P3,P4>
+  slot(O &obj,R (O2::*func)(P1,P2,P3,P4))
+  {
+    return ObjectSlot4_<R,P1,P2,P3,P4,O2>
+             ::create(&obj,func);
+  }
+
+
+
+/****************************************************************
+***** Object Slot 5
+****************************************************************/
+template <class R,class P1,class P2,class P3,class P4,class P5,class Obj>
+struct ObjectSlot5_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R RType;
+#else
+   typedef typename Trait<R>::type RType;
+#endif
+   typedef R     (Obj::*InFunc)(P1,P2,P3,P4,P5);
+   typedef RType (Obj::*Func)(P1,P2,P3,P4,P5);
+   typedef Slot5<R,P1,P2,P3,P4,P5> SlotType;
+   typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
+     {
+      CallData* data=(CallData*)d;
+      return ((data->obj)->*(data->func))(p1,p2,p3,p4,p5);
+     }
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      obj->register_data(tmp->receiver());
+      return tmp;
+     }
+  };
+
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class P1,class P2,class P3,class P4,class P5,class Obj>
+struct ObjectSlot5_<void,P1,P2,P3,P4,P5,Obj>
+  {
+   typedef void RType;
+   typedef void     (Obj::*InFunc)(P1,P2,P3,P4,P5);
+   typedef RType (Obj::*Func)(P1,P2,P3,P4,P5);
+   typedef Slot5<void,P1,P2,P3,P4,P5> SlotType;
+   typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
+     {
+      CallData* data=(CallData*)d;
+       ((data->obj)->*(data->func))(p1,p2,p3,p4,p5);
+     }
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      obj->register_data(tmp->receiver());
+      return tmp;
+     }
+  };
+
+
+#endif
+#endif
+
+template <class R,class P1,class P2,class P3,class P4,class P5,class O,class O2>
+inline Slot5<R,P1,P2,P3,P4,P5>
+  slot(O* &obj,R (O2::*func)(P1,P2,P3,P4,P5))
+  {
+    return ObjectSlot5_<R,P1,P2,P3,P4,P5,O2>
+             ::create(obj,func);
+  }
+
+template <class R,class P1,class P2,class P3,class P4,class P5,class O,class O2>
+inline Slot5<R,P1,P2,P3,P4,P5>
+  slot(O* const &obj,R (O2::*func)(P1,P2,P3,P4,P5))
+  {
+    return ObjectSlot5_<R,P1,P2,P3,P4,P5,O2>
+             ::create(obj,func);
+  }
+
+template <class R,class P1,class P2,class P3,class P4,class P5,class O,class O2>
+inline Slot5<R,P1,P2,P3,P4,P5>
+  slot(O &obj,R (O2::*func)(P1,P2,P3,P4,P5))
+  {
+    return ObjectSlot5_<R,P1,P2,P3,P4,P5,O2>
+             ::create(&obj,func);
+  }
+
+
+
+/****************************************************************
+***** Object Slot 6
+****************************************************************/
+template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class Obj>
+struct ObjectSlot6_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R RType;
+#else
+   typedef typename Trait<R>::type RType;
+#endif
+   typedef R     (Obj::*InFunc)(P1,P2,P3,P4,P5,P6);
+   typedef RType (Obj::*Func)(P1,P2,P3,P4,P5,P6);
+   typedef Slot6<R,P1,P2,P3,P4,P5,P6> SlotType;
+   typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
+     {
+      CallData* data=(CallData*)d;
+      return ((data->obj)->*(data->func))(p1,p2,p3,p4,p5,p6);
+     }
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      obj->register_data(tmp->receiver());
+      return tmp;
+     }
+  };
+
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class P1,class P2,class P3,class P4,class P5,class P6,class Obj>
+struct ObjectSlot6_<void,P1,P2,P3,P4,P5,P6,Obj>
+  {
+   typedef void RType;
+   typedef void     (Obj::*InFunc)(P1,P2,P3,P4,P5,P6);
+   typedef RType (Obj::*Func)(P1,P2,P3,P4,P5,P6);
+   typedef Slot6<void,P1,P2,P3,P4,P5,P6> SlotType;
+   typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
+     {
+      CallData* data=(CallData*)d;
+       ((data->obj)->*(data->func))(p1,p2,p3,p4,p5,p6);
+     }
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      obj->register_data(tmp->receiver());
+      return tmp;
+     }
+  };
+
+
+#endif
+#endif
+
+template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class O,class O2>
+inline Slot6<R,P1,P2,P3,P4,P5,P6>
+  slot(O* &obj,R (O2::*func)(P1,P2,P3,P4,P5,P6))
+  {
+    return ObjectSlot6_<R,P1,P2,P3,P4,P5,P6,O2>
+             ::create(obj,func);
+  }
+
+template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class O,class O2>
+inline Slot6<R,P1,P2,P3,P4,P5,P6>
+  slot(O* const &obj,R (O2::*func)(P1,P2,P3,P4,P5,P6))
+  {
+    return ObjectSlot6_<R,P1,P2,P3,P4,P5,P6,O2>
+             ::create(obj,func);
+  }
+
+template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class O,class O2>
+inline Slot6<R,P1,P2,P3,P4,P5,P6>
+  slot(O &obj,R (O2::*func)(P1,P2,P3,P4,P5,P6))
+  {
+    return ObjectSlot6_<R,P1,P2,P3,P4,P5,P6,O2>
+             ::create(&obj,func);
+  }
+
+
+
+/****************************************************************
+***** Object Slot 7
+****************************************************************/
+template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7,class Obj>
+struct ObjectSlot7_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R RType;
+#else
+   typedef typename Trait<R>::type RType;
+#endif
+   typedef R     (Obj::*InFunc)(P1,P2,P3,P4,P5,P6,P7);
+   typedef RType (Obj::*Func)(P1,P2,P3,P4,P5,P6,P7);
+   typedef Slot7<R,P1,P2,P3,P4,P5,P6,P7> SlotType;
+   typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
+     {
+      CallData* data=(CallData*)d;
+      return ((data->obj)->*(data->func))(p1,p2,p3,p4,p5,p6,p7);
+     }
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      obj->register_data(tmp->receiver());
+      return tmp;
+     }
+  };
+
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class P1,class P2,class P3,class P4,class P5,class P6,class P7,class Obj>
+struct ObjectSlot7_<void,P1,P2,P3,P4,P5,P6,P7,Obj>
+  {
+   typedef void RType;
+   typedef void     (Obj::*InFunc)(P1,P2,P3,P4,P5,P6,P7);
+   typedef RType (Obj::*Func)(P1,P2,P3,P4,P5,P6,P7);
+   typedef Slot7<void,P1,P2,P3,P4,P5,P6,P7> SlotType;
+   typedef CallDataObj3<typename SlotType::Func,Obj,Func> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
+     {
+      CallData* data=(CallData*)d;
+       ((data->obj)->*(data->func))(p1,p2,p3,p4,p5,p6,p7);
+     }
+
+   static SlotData* create(Obj* obj,InFunc func)
+     {
+      if (!obj) return 0;
+      SlotData* tmp=manage(new SlotData());
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=obj;
+      data.func=(Func)func;
+      obj->register_data(tmp->receiver());
+      return tmp;
+     }
+  };
+
+
+#endif
+#endif
+
+template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7,class O,class O2>
+inline Slot7<R,P1,P2,P3,P4,P5,P6,P7>
+  slot(O* &obj,R (O2::*func)(P1,P2,P3,P4,P5,P6,P7))
+  {
+    return ObjectSlot7_<R,P1,P2,P3,P4,P5,P6,P7,O2>
+             ::create(obj,func);
+  }
+
+template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7,class O,class O2>
+inline Slot7<R,P1,P2,P3,P4,P5,P6,P7>
+  slot(O* const &obj,R (O2::*func)(P1,P2,P3,P4,P5,P6,P7))
+  {
+    return ObjectSlot7_<R,P1,P2,P3,P4,P5,P6,P7,O2>
+             ::create(obj,func);
+  }
+
+template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7,class O,class O2>
+inline Slot7<R,P1,P2,P3,P4,P5,P6,P7>
+  slot(O &obj,R (O2::*func)(P1,P2,P3,P4,P5,P6,P7))
+  {
+    return ObjectSlot7_<R,P1,P2,P3,P4,P5,P6,P7,O2>
+             ::create(&obj,func);
+  }
+
+
+
+
+#ifdef SIGC_CXX_NAMESPACES
+} // namespace
+#endif
+
+#endif

programs/develop/libraries/menuetlibc/include/sigc++/retbind.h

@@ -0,0 +1,848 @@
+// -*- c++ -*-
+/* This is a generated file, do not edit.  Generated from ../sigc++/macros/retbind.h.m4 */
+/* This was also shamelessly copied, hacked, munched, and carefully 
+ * tweaked from KNelson's original bind.h.m4
+ * CJN 3.22.00
+ */
+
+#ifndef SIGCXX_RETBIND_H
+#define SIGCXX_RETBIND_H
+
+/*
+  SigC::retbind
+  -------------
+  retbind() alters a Slot by fixing the return value to certain values
+
+  Return value fixing ignores any slot return value.  The slot is
+  destroyed in the process and a new one is created, so references
+  holding onto the slot will no longer be valid.
+
+  Typecasting may be necessary to match arguments between the
+  slot and the binding return value.  Types must be an exact match.
+  To insure the proper type, the type can be explicitly specified
+  on template instantation.
+
+  Simple Sample usage:
+
+    void f(int,int);
+    Slot2<void,int,int> s1=slot(f);
+
+    Slot1<int,int,int>  s2=retbind(s1,1);  // s1 is invalid
+    cout << "s2: " << s2(2,1) << endl;
+
+  Type specified usage:
+    
+    struct A {};
+    struct B :public A {};
+    B* b;
+    Slot1<void> s1;
+
+    Slot0<A*> s2=retbind<A*>(s1,b);  // B* must be told to match A*
+     
+*/
+
+#include <sigc++/adaptor.h>
+#include <sigc++/scope.h>
+
+#ifdef SIGC_CXX_NAMESPACES
+namespace SigC
+{
+#endif
+
+
+
+
+/****************************************************************
+***** Adaptor RetBind Slot 0 arguments
+****************************************************************/
+template <class Ret,class R>
+struct AdaptorRetBindSlot0: public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef Ret RType;
+#else
+   typedef typename Trait<Ret>::type RType;
+#endif
+   typedef Slot0<Ret> SlotType;
+   typedef Slot0<R> InSlotType;
+
+   struct Node:public AdaptorNode
+     {
+	   Ret ret_;
+     };
+
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))();
+      return node->ret_;
+     }
+   static SlotData* create(SlotData *s,Ret ret)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      node->ret_ = ret;
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class Ret>
+struct AdaptorRetBindSlot0
+   <Ret,void> : public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef Ret RType;
+#else
+   typedef typename Trait<Ret>::type RType;
+#endif
+   typedef Slot0<Ret> SlotType;
+   typedef Slot0<void> InSlotType;
+
+   struct Node:public AdaptorNode
+     {
+	   Ret ret_;
+     };
+
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))();
+      return node->ret_;
+     }
+   static SlotData* create(SlotData *s,Ret ret)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      node->ret_ = ret;
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+template <class Ret,
+    class R>
+Slot0<Ret>
+  retbind(const Slot0<R> &s,
+       Ret ret)
+  {return AdaptorRetBindSlot0<Ret,R>::create(s.data(),ret);
+  }
+
+
+/****************************************************************
+***** Adaptor RetBind Slot 1 arguments
+****************************************************************/
+template <class Ret,class R,
+   class P1>
+struct AdaptorRetBindSlot1: public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef Ret RType;
+#else
+   typedef typename Trait<Ret>::type RType;
+#endif
+   typedef Slot1<Ret,P1> SlotType;
+   typedef Slot1<R,P1> InSlotType;
+
+   struct Node:public AdaptorNode
+     {
+	   Ret ret_;
+     };
+
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))(p1);
+      return node->ret_;
+     }
+   static SlotData* create(SlotData *s,Ret ret)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      node->ret_ = ret;
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class Ret,class P1>
+struct AdaptorRetBindSlot1
+   <Ret,void,
+   P1> : public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef Ret RType;
+#else
+   typedef typename Trait<Ret>::type RType;
+#endif
+   typedef Slot1<Ret,P1> SlotType;
+   typedef Slot1<void,P1> InSlotType;
+
+   struct Node:public AdaptorNode
+     {
+	   Ret ret_;
+     };
+
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))(p1);
+      return node->ret_;
+     }
+   static SlotData* create(SlotData *s,Ret ret)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      node->ret_ = ret;
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+template <class Ret,
+    class R,
+    class P1>
+Slot1<Ret,P1>
+  retbind(const Slot1<R,P1> &s,
+       Ret ret)
+  {return AdaptorRetBindSlot1<Ret,R,
+           P1>::create(s.data(),ret);
+  }
+
+
+/****************************************************************
+***** Adaptor RetBind Slot 2 arguments
+****************************************************************/
+template <class Ret,class R,
+   class P1,class P2>
+struct AdaptorRetBindSlot2: public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef Ret RType;
+#else
+   typedef typename Trait<Ret>::type RType;
+#endif
+   typedef Slot2<Ret,P1,P2> SlotType;
+   typedef Slot2<R,P1,P2> InSlotType;
+
+   struct Node:public AdaptorNode
+     {
+	   Ret ret_;
+     };
+
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))(p1,p2);
+      return node->ret_;
+     }
+   static SlotData* create(SlotData *s,Ret ret)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      node->ret_ = ret;
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class Ret,class P1,class P2>
+struct AdaptorRetBindSlot2
+   <Ret,void,
+   P1,P2> : public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef Ret RType;
+#else
+   typedef typename Trait<Ret>::type RType;
+#endif
+   typedef Slot2<Ret,P1,P2> SlotType;
+   typedef Slot2<void,P1,P2> InSlotType;
+
+   struct Node:public AdaptorNode
+     {
+	   Ret ret_;
+     };
+
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))(p1,p2);
+      return node->ret_;
+     }
+   static SlotData* create(SlotData *s,Ret ret)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      node->ret_ = ret;
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+template <class Ret,
+    class R,
+    class P1,class P2>
+Slot2<Ret,P1,P2>
+  retbind(const Slot2<R,P1,P2> &s,
+       Ret ret)
+  {return AdaptorRetBindSlot2<Ret,R,
+           P1,P2>::create(s.data(),ret);
+  }
+
+
+/****************************************************************
+***** Adaptor RetBind Slot 3 arguments
+****************************************************************/
+template <class Ret,class R,
+   class P1,class P2,class P3>
+struct AdaptorRetBindSlot3: public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef Ret RType;
+#else
+   typedef typename Trait<Ret>::type RType;
+#endif
+   typedef Slot3<Ret,P1,P2,P3> SlotType;
+   typedef Slot3<R,P1,P2,P3> InSlotType;
+
+   struct Node:public AdaptorNode
+     {
+	   Ret ret_;
+     };
+
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3);
+      return node->ret_;
+     }
+   static SlotData* create(SlotData *s,Ret ret)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      node->ret_ = ret;
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class Ret,class P1,class P2,class P3>
+struct AdaptorRetBindSlot3
+   <Ret,void,
+   P1,P2,P3> : public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef Ret RType;
+#else
+   typedef typename Trait<Ret>::type RType;
+#endif
+   typedef Slot3<Ret,P1,P2,P3> SlotType;
+   typedef Slot3<void,P1,P2,P3> InSlotType;
+
+   struct Node:public AdaptorNode
+     {
+	   Ret ret_;
+     };
+
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3);
+      return node->ret_;
+     }
+   static SlotData* create(SlotData *s,Ret ret)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      node->ret_ = ret;
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+template <class Ret,
+    class R,
+    class P1,class P2,class P3>
+Slot3<Ret,P1,P2,P3>
+  retbind(const Slot3<R,P1,P2,P3> &s,
+       Ret ret)
+  {return AdaptorRetBindSlot3<Ret,R,
+           P1,P2,P3>::create(s.data(),ret);
+  }
+
+
+/****************************************************************
+***** Adaptor RetBind Slot 4 arguments
+****************************************************************/
+template <class Ret,class R,
+   class P1,class P2,class P3,class P4>
+struct AdaptorRetBindSlot4: public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef Ret RType;
+#else
+   typedef typename Trait<Ret>::type RType;
+#endif
+   typedef Slot4<Ret,P1,P2,P3,P4> SlotType;
+   typedef Slot4<R,P1,P2,P3,P4> InSlotType;
+
+   struct Node:public AdaptorNode
+     {
+	   Ret ret_;
+     };
+
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4);
+      return node->ret_;
+     }
+   static SlotData* create(SlotData *s,Ret ret)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      node->ret_ = ret;
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class Ret,class P1,class P2,class P3,class P4>
+struct AdaptorRetBindSlot4
+   <Ret,void,
+   P1,P2,P3,P4> : public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef Ret RType;
+#else
+   typedef typename Trait<Ret>::type RType;
+#endif
+   typedef Slot4<Ret,P1,P2,P3,P4> SlotType;
+   typedef Slot4<void,P1,P2,P3,P4> InSlotType;
+
+   struct Node:public AdaptorNode
+     {
+	   Ret ret_;
+     };
+
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4);
+      return node->ret_;
+     }
+   static SlotData* create(SlotData *s,Ret ret)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      node->ret_ = ret;
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+template <class Ret,
+    class R,
+    class P1,class P2,class P3,class P4>
+Slot4<Ret,P1,P2,P3,P4>
+  retbind(const Slot4<R,P1,P2,P3,P4> &s,
+       Ret ret)
+  {return AdaptorRetBindSlot4<Ret,R,
+           P1,P2,P3,P4>::create(s.data(),ret);
+  }
+
+
+/****************************************************************
+***** Adaptor RetBind Slot 5 arguments
+****************************************************************/
+template <class Ret,class R,
+   class P1,class P2,class P3,class P4,class P5>
+struct AdaptorRetBindSlot5: public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef Ret RType;
+#else
+   typedef typename Trait<Ret>::type RType;
+#endif
+   typedef Slot5<Ret,P1,P2,P3,P4,P5> SlotType;
+   typedef Slot5<R,P1,P2,P3,P4,P5> InSlotType;
+
+   struct Node:public AdaptorNode
+     {
+	   Ret ret_;
+     };
+
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5);
+      return node->ret_;
+     }
+   static SlotData* create(SlotData *s,Ret ret)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      node->ret_ = ret;
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class Ret,class P1,class P2,class P3,class P4,class P5>
+struct AdaptorRetBindSlot5
+   <Ret,void,
+   P1,P2,P3,P4,P5> : public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef Ret RType;
+#else
+   typedef typename Trait<Ret>::type RType;
+#endif
+   typedef Slot5<Ret,P1,P2,P3,P4,P5> SlotType;
+   typedef Slot5<void,P1,P2,P3,P4,P5> InSlotType;
+
+   struct Node:public AdaptorNode
+     {
+	   Ret ret_;
+     };
+
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5);
+      return node->ret_;
+     }
+   static SlotData* create(SlotData *s,Ret ret)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      node->ret_ = ret;
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+template <class Ret,
+    class R,
+    class P1,class P2,class P3,class P4,class P5>
+Slot5<Ret,P1,P2,P3,P4,P5>
+  retbind(const Slot5<R,P1,P2,P3,P4,P5> &s,
+       Ret ret)
+  {return AdaptorRetBindSlot5<Ret,R,
+           P1,P2,P3,P4,P5>::create(s.data(),ret);
+  }
+
+
+/****************************************************************
+***** Adaptor RetBind Slot 6 arguments
+****************************************************************/
+template <class Ret,class R,
+   class P1,class P2,class P3,class P4,class P5,class P6>
+struct AdaptorRetBindSlot6: public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef Ret RType;
+#else
+   typedef typename Trait<Ret>::type RType;
+#endif
+   typedef Slot6<Ret,P1,P2,P3,P4,P5,P6> SlotType;
+   typedef Slot6<R,P1,P2,P3,P4,P5,P6> InSlotType;
+
+   struct Node:public AdaptorNode
+     {
+	   Ret ret_;
+     };
+
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6);
+      return node->ret_;
+     }
+   static SlotData* create(SlotData *s,Ret ret)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      node->ret_ = ret;
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class Ret,class P1,class P2,class P3,class P4,class P5,class P6>
+struct AdaptorRetBindSlot6
+   <Ret,void,
+   P1,P2,P3,P4,P5,P6> : public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef Ret RType;
+#else
+   typedef typename Trait<Ret>::type RType;
+#endif
+   typedef Slot6<Ret,P1,P2,P3,P4,P5,P6> SlotType;
+   typedef Slot6<void,P1,P2,P3,P4,P5,P6> InSlotType;
+
+   struct Node:public AdaptorNode
+     {
+	   Ret ret_;
+     };
+
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6);
+      return node->ret_;
+     }
+   static SlotData* create(SlotData *s,Ret ret)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      node->ret_ = ret;
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+template <class Ret,
+    class R,
+    class P1,class P2,class P3,class P4,class P5,class P6>
+Slot6<Ret,P1,P2,P3,P4,P5,P6>
+  retbind(const Slot6<R,P1,P2,P3,P4,P5,P6> &s,
+       Ret ret)
+  {return AdaptorRetBindSlot6<Ret,R,
+           P1,P2,P3,P4,P5,P6>::create(s.data(),ret);
+  }
+
+
+/****************************************************************
+***** Adaptor RetBind Slot 7 arguments
+****************************************************************/
+template <class Ret,class R,
+   class P1,class P2,class P3,class P4,class P5,class P6,class P7>
+struct AdaptorRetBindSlot7: public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef Ret RType;
+#else
+   typedef typename Trait<Ret>::type RType;
+#endif
+   typedef Slot7<Ret,P1,P2,P3,P4,P5,P6,P7> SlotType;
+   typedef Slot7<R,P1,P2,P3,P4,P5,P6,P7> InSlotType;
+
+   struct Node:public AdaptorNode
+     {
+	   Ret ret_;
+     };
+
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6,p7);
+      return node->ret_;
+     }
+   static SlotData* create(SlotData *s,Ret ret)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      node->ret_ = ret;
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <class Ret,class P1,class P2,class P3,class P4,class P5,class P6,class P7>
+struct AdaptorRetBindSlot7
+   <Ret,void,
+   P1,P2,P3,P4,P5,P6,P7> : public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef Ret RType;
+#else
+   typedef typename Trait<Ret>::type RType;
+#endif
+   typedef Slot7<Ret,P1,P2,P3,P4,P5,P6,P7> SlotType;
+   typedef Slot7<void,P1,P2,P3,P4,P5,P6,P7> InSlotType;
+
+   struct Node:public AdaptorNode
+     {
+	   Ret ret_;
+     };
+
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6,p7);
+      return node->ret_;
+     }
+   static SlotData* create(SlotData *s,Ret ret)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      node->ret_ = ret;
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+template <class Ret,
+    class R,
+    class P1,class P2,class P3,class P4,class P5,class P6,class P7>
+Slot7<Ret,P1,P2,P3,P4,P5,P6,P7>
+  retbind(const Slot7<R,P1,P2,P3,P4,P5,P6,P7> &s,
+       Ret ret)
+  {return AdaptorRetBindSlot7<Ret,R,
+           P1,P2,P3,P4,P5,P6,P7>::create(s.data(),ret);
+  }
+
+
+
+#ifdef SIGC_CXX_NAMESPACES
+} // namespace
+#endif
+
+#endif

programs/develop/libraries/menuetlibc/include/sigc++/rettype.h

@@ -0,0 +1,715 @@
+// -*- c++ -*-
+/* This is a generated file, do not edit.  Generated from ../sigc++/macros/rettype.h.m4 */
+
+#ifndef SIGCXX_RETTYPE_H
+#define SIGCXX_RETTYPE_H
+
+/*
+  SigC::rettype
+  -------------
+  rettype() alters a Slot by changing the return type.
+
+  Only allowed conversions or conversions to void can properly
+  be implemented.  The type must always be specified as a
+  template parameter. 
+
+  Simple Sample usage:
+
+    int f(int);
+
+    Slot1<void,int>   s1=rettype<void>(slot(&f)); 
+    Slot1<float,int>  s2=rettype<float>(slot(&f)); 
+
+*/
+
+#include <sigc++/adaptor.h>
+
+#ifdef SIGC_CXX_NAMESPACES
+namespace SigC
+{
+#endif
+
+
+
+
+
+
+
+
+
+
+
+/****************************************************************
+***** Adaptor Rettype Slot 0
+****************************************************************/
+template <class R1,
+   class R2>
+struct AdaptorRettypeSlot0_
+  : public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R1 RType;
+#else
+   typedef typename Trait<R1>::type RType;
+#endif
+   typedef Slot0<R1> SlotType;
+   typedef Slot0<R2> InSlotType;
+   typedef AdaptorNode Node;
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      return RType(((typename InSlotType::Callback&)(node->data_))());
+     }
+   static SlotData* create(SlotData *s)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <
+   class R2>
+struct AdaptorRettypeSlot0_
+<void,
+   R2>
+  : public AdaptorSlot_
+  {
+   typedef void RType;
+   typedef Slot0<void> SlotType;
+   typedef Slot0<R2> InSlotType;
+   typedef AdaptorNode Node;
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))();
+     }
+   static SlotData* create(SlotData *s)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+
+template <class R1,class R2>
+Slot0<R1>
+  rettype(const Slot0<R2> &s)
+  {return AdaptorRettypeSlot0_<R1,R2>::create(s.obj());
+  }
+
+/****************************************************************
+***** Adaptor Rettype Slot 1
+****************************************************************/
+template <class R1,
+   class P1,
+   class R2>
+struct AdaptorRettypeSlot1_
+  : public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R1 RType;
+#else
+   typedef typename Trait<R1>::type RType;
+#endif
+   typedef Slot1<R1,P1> SlotType;
+   typedef Slot1<R2,P1> InSlotType;
+   typedef AdaptorNode Node;
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      return RType(((typename InSlotType::Callback&)(node->data_))(p1));
+     }
+   static SlotData* create(SlotData *s)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <
+   class P1,
+   class R2>
+struct AdaptorRettypeSlot1_
+<void,
+   P1,
+   R2>
+  : public AdaptorSlot_
+  {
+   typedef void RType;
+   typedef Slot1<void,P1> SlotType;
+   typedef Slot1<R2,P1> InSlotType;
+   typedef AdaptorNode Node;
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))(p1);
+     }
+   static SlotData* create(SlotData *s)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+
+template <class R1,class R2,class P1>
+Slot1<R1,P1>
+  rettype(const Slot1<R2,P1> &s)
+  {return AdaptorRettypeSlot1_<R1,
+           P1,R2>::create(s.obj());
+  }
+
+/****************************************************************
+***** Adaptor Rettype Slot 2
+****************************************************************/
+template <class R1,
+   class P1,class P2,
+   class R2>
+struct AdaptorRettypeSlot2_
+  : public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R1 RType;
+#else
+   typedef typename Trait<R1>::type RType;
+#endif
+   typedef Slot2<R1,P1,P2> SlotType;
+   typedef Slot2<R2,P1,P2> InSlotType;
+   typedef AdaptorNode Node;
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2));
+     }
+   static SlotData* create(SlotData *s)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <
+   class P1,class P2,
+   class R2>
+struct AdaptorRettypeSlot2_
+<void,
+   P1,P2,
+   R2>
+  : public AdaptorSlot_
+  {
+   typedef void RType;
+   typedef Slot2<void,P1,P2> SlotType;
+   typedef Slot2<R2,P1,P2> InSlotType;
+   typedef AdaptorNode Node;
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))(p1,p2);
+     }
+   static SlotData* create(SlotData *s)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+
+template <class R1,class R2,class P1,class P2>
+Slot2<R1,P1,P2>
+  rettype(const Slot2<R2,P1,P2> &s)
+  {return AdaptorRettypeSlot2_<R1,
+           P1,P2,R2>::create(s.obj());
+  }
+
+/****************************************************************
+***** Adaptor Rettype Slot 3
+****************************************************************/
+template <class R1,
+   class P1,class P2,class P3,
+   class R2>
+struct AdaptorRettypeSlot3_
+  : public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R1 RType;
+#else
+   typedef typename Trait<R1>::type RType;
+#endif
+   typedef Slot3<R1,P1,P2,P3> SlotType;
+   typedef Slot3<R2,P1,P2,P3> InSlotType;
+   typedef AdaptorNode Node;
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2,p3));
+     }
+   static SlotData* create(SlotData *s)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <
+   class P1,class P2,class P3,
+   class R2>
+struct AdaptorRettypeSlot3_
+<void,
+   P1,P2,P3,
+   R2>
+  : public AdaptorSlot_
+  {
+   typedef void RType;
+   typedef Slot3<void,P1,P2,P3> SlotType;
+   typedef Slot3<R2,P1,P2,P3> InSlotType;
+   typedef AdaptorNode Node;
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3);
+     }
+   static SlotData* create(SlotData *s)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+
+template <class R1,class R2,class P1,class P2,class P3>
+Slot3<R1,P1,P2,P3>
+  rettype(const Slot3<R2,P1,P2,P3> &s)
+  {return AdaptorRettypeSlot3_<R1,
+           P1,P2,P3,R2>::create(s.obj());
+  }
+
+/****************************************************************
+***** Adaptor Rettype Slot 4
+****************************************************************/
+template <class R1,
+   class P1,class P2,class P3,class P4,
+   class R2>
+struct AdaptorRettypeSlot4_
+  : public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R1 RType;
+#else
+   typedef typename Trait<R1>::type RType;
+#endif
+   typedef Slot4<R1,P1,P2,P3,P4> SlotType;
+   typedef Slot4<R2,P1,P2,P3,P4> InSlotType;
+   typedef AdaptorNode Node;
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4));
+     }
+   static SlotData* create(SlotData *s)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <
+   class P1,class P2,class P3,class P4,
+   class R2>
+struct AdaptorRettypeSlot4_
+<void,
+   P1,P2,P3,P4,
+   R2>
+  : public AdaptorSlot_
+  {
+   typedef void RType;
+   typedef Slot4<void,P1,P2,P3,P4> SlotType;
+   typedef Slot4<R2,P1,P2,P3,P4> InSlotType;
+   typedef AdaptorNode Node;
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4);
+     }
+   static SlotData* create(SlotData *s)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+
+template <class R1,class R2,class P1,class P2,class P3,class P4>
+Slot4<R1,P1,P2,P3,P4>
+  rettype(const Slot4<R2,P1,P2,P3,P4> &s)
+  {return AdaptorRettypeSlot4_<R1,
+           P1,P2,P3,P4,R2>::create(s.obj());
+  }
+
+/****************************************************************
+***** Adaptor Rettype Slot 5
+****************************************************************/
+template <class R1,
+   class P1,class P2,class P3,class P4,class P5,
+   class R2>
+struct AdaptorRettypeSlot5_
+  : public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R1 RType;
+#else
+   typedef typename Trait<R1>::type RType;
+#endif
+   typedef Slot5<R1,P1,P2,P3,P4,P5> SlotType;
+   typedef Slot5<R2,P1,P2,P3,P4,P5> InSlotType;
+   typedef AdaptorNode Node;
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5));
+     }
+   static SlotData* create(SlotData *s)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <
+   class P1,class P2,class P3,class P4,class P5,
+   class R2>
+struct AdaptorRettypeSlot5_
+<void,
+   P1,P2,P3,P4,P5,
+   R2>
+  : public AdaptorSlot_
+  {
+   typedef void RType;
+   typedef Slot5<void,P1,P2,P3,P4,P5> SlotType;
+   typedef Slot5<R2,P1,P2,P3,P4,P5> InSlotType;
+   typedef AdaptorNode Node;
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5);
+     }
+   static SlotData* create(SlotData *s)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+
+template <class R1,class R2,class P1,class P2,class P3,class P4,class P5>
+Slot5<R1,P1,P2,P3,P4,P5>
+  rettype(const Slot5<R2,P1,P2,P3,P4,P5> &s)
+  {return AdaptorRettypeSlot5_<R1,
+           P1,P2,P3,P4,P5,R2>::create(s.obj());
+  }
+
+/****************************************************************
+***** Adaptor Rettype Slot 6
+****************************************************************/
+template <class R1,
+   class P1,class P2,class P3,class P4,class P5,class P6,
+   class R2>
+struct AdaptorRettypeSlot6_
+  : public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R1 RType;
+#else
+   typedef typename Trait<R1>::type RType;
+#endif
+   typedef Slot6<R1,P1,P2,P3,P4,P5,P6> SlotType;
+   typedef Slot6<R2,P1,P2,P3,P4,P5,P6> InSlotType;
+   typedef AdaptorNode Node;
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6));
+     }
+   static SlotData* create(SlotData *s)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <
+   class P1,class P2,class P3,class P4,class P5,class P6,
+   class R2>
+struct AdaptorRettypeSlot6_
+<void,
+   P1,P2,P3,P4,P5,P6,
+   R2>
+  : public AdaptorSlot_
+  {
+   typedef void RType;
+   typedef Slot6<void,P1,P2,P3,P4,P5,P6> SlotType;
+   typedef Slot6<R2,P1,P2,P3,P4,P5,P6> InSlotType;
+   typedef AdaptorNode Node;
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6);
+     }
+   static SlotData* create(SlotData *s)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+
+template <class R1,class R2,class P1,class P2,class P3,class P4,class P5,class P6>
+Slot6<R1,P1,P2,P3,P4,P5,P6>
+  rettype(const Slot6<R2,P1,P2,P3,P4,P5,P6> &s)
+  {return AdaptorRettypeSlot6_<R1,
+           P1,P2,P3,P4,P5,P6,R2>::create(s.obj());
+  }
+
+/****************************************************************
+***** Adaptor Rettype Slot 7
+****************************************************************/
+template <class R1,
+   class P1,class P2,class P3,class P4,class P5,class P6,class P7,
+   class R2>
+struct AdaptorRettypeSlot7_
+  : public AdaptorSlot_
+  {
+#ifdef SIGC_CXX_PARTIAL_SPEC
+   typedef R1 RType;
+#else
+   typedef typename Trait<R1>::type RType;
+#endif
+   typedef Slot7<R1,P1,P2,P3,P4,P5,P6,P7> SlotType;
+   typedef Slot7<R2,P1,P2,P3,P4,P5,P6,P7> InSlotType;
+   typedef AdaptorNode Node;
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6,p7));
+     }
+   static SlotData* create(SlotData *s)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+
+#ifndef SIGC_CXX_VOID_RETURN
+#ifdef SIGC_CXX_PARTIAL_SPEC
+template <
+   class P1,class P2,class P3,class P4,class P5,class P6,class P7,
+   class R2>
+struct AdaptorRettypeSlot7_
+<void,
+   P1,P2,P3,P4,P5,P6,P7,
+   R2>
+  : public AdaptorSlot_
+  {
+   typedef void RType;
+   typedef Slot7<void,P1,P2,P3,P4,P5,P6,P7> SlotType;
+   typedef Slot7<R2,P1,P2,P3,P4,P5,P6,P7> InSlotType;
+   typedef AdaptorNode Node;
+   typedef CallDataObj2<typename SlotType::Func,Node> CallData;
+
+   static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
+     {
+      CallData* data=(CallData*)d;
+      Node* node=data->obj;
+      ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6,p7);
+     }
+   static SlotData* create(SlotData *s)
+     {
+      SlotData* tmp=(SlotData*)s;
+      Node *node=new Node();
+      copy_callback(tmp,node);
+      CallData &data=reinterpret_cast<CallData&>(tmp->data_);
+      data.callback=&callback;
+      data.obj=node;
+      return tmp;
+     }
+  };
+
+#endif
+#endif
+
+
+template <class R1,class R2,class P1,class P2,class P3,class P4,class P5,class P6,class P7>
+Slot7<R1,P1,P2,P3,P4,P5,P6,P7>
+  rettype(const Slot7<R2,P1,P2,P3,P4,P5,P6,P7> &s)
+  {return AdaptorRettypeSlot7_<R1,
+           P1,P2,P3,P4,P5,P6,P7,R2>::create(s.obj());
+  }
+
+
+#ifdef SIGC_CXX_NAMESPACES
+} // namespace
+#endif
+
+#endif

programs/develop/libraries/menuetlibc/include/sigc++/scope.h

@@ -0,0 +1,292 @@
+// -*- c++ -*-
+/* 
+ * Copyright 1999 Karl Nelson <kenelson@ece.ucdavis.edu>
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#ifndef SIGCXX_SCOPE_H
+#define SIGCXX_SCOPE_H
+#include <sigc++config.h>
+
+#ifdef SIGC_CXX_NAMESPACES
+namespace SigC
+{
+#endif 
+
+
+struct LIBSIGC_API ScopeNode 
+  {
+   mutable ScopeNode *prev_;
+   mutable ScopeNode *next_;
+
+   // removes self from list
+   void remove_self();
+
+   // Called to inform the item that it is erased
+   virtual void erase();
+
+   // inform scopes that invalid requested.
+   virtual void disconnect(bool destroy=0);
+
+   ScopeNode()
+#ifdef LIBSIGC_WIN32
+   {prev_=next_=this;}
+#else
+   :prev_(this),next_(this) {}
+#endif
+
+   virtual ~ScopeNode();
+
+   private:
+     ScopeNode& operator=(const ScopeNode&);
+     ScopeNode(const ScopeNode&);
+  };
+
+struct LIBSIGC_API DataNode: public ScopeNode
+  {
+   virtual void erase();
+   virtual ~DataNode();
+  };
+
+/*******************************************************************
+***** Basis Scope
+*******************************************************************/
+class ObjectScoped;
+class ObjectReferenced;
+class Object;
+class Scope;
+
+class LIBSIGC_API Reference
+  {
+   protected:
+     mutable ObjectReferenced* obj_;
+     mutable void* cache_;
+
+   public:
+     void set_sink();
+
+     void init(ObjectReferenced* obj);
+     void set(ObjectReferenced* obj,void* cache=0,bool ptr=false);
+
+     Reference& operator=(ObjectReferenced *obj) { set(obj); return *this; }
+     Reference& operator=(ObjectReferenced &obj) { set(&obj); return *this; }
+     Reference& operator=(const Reference& ref)  { set(ref.obj_); return *this; };
+
+     ObjectReferenced* object() const {return obj_;}
+     void* cache() const {return cache_;}
+
+     Reference():obj_(0) {}
+     Reference(ObjectReferenced &obj)
+       {init(&obj);}
+     Reference(const Reference& ref)
+       {init(ref.obj_);}
+     ~Reference();
+  };
+     
+class LIBSIGC_API Scope:public ScopeNode
+  {
+   friend class ObjectScoped;
+
+     Scope& operator=(const Scope& scope);
+     Scope(const Scope& scope);
+
+   protected:
+     void set(ObjectScoped* obj,void* cache,bool ptr);
+     mutable ObjectScoped* obj_;
+     mutable void* cache_;
+
+     virtual void on_connect()=0;
+     virtual void erase();
+
+     void register_scope(ObjectScoped *);
+     void register_scope(const Scope *parent=0);
+     void unregister_scope();
+
+   public:
+
+     void reference();
+     void unreference();
+     void set_sink();
+
+     ObjectScoped* object() const {return (ObjectScoped*)(obj_);}
+     void* cache() const {return cache_;}
+
+     // Inform object it should invalidate its list.
+     void invalid();
+
+     Scope():obj_(0),cache_(0) {}
+     virtual ~Scope();
+  };
+
+
+/****************************************************** 
+**** Common Scopes
+*******************************************************
+  Available Scopes:
+    Uncounted  - non-reference
+    Limit      - Limits the lifetime of object to this scope
+                 Sinks object.
+    Extend     - Extends the lifetime of the object to this scope
+                 Sinks object.
+    LimitOwned - Conditionally limits the lifetime of object
+                 Sinks object.
+    FuncRef    - Extends the lifetime, without sink
+                 (intended for functions)
+    Reference  - Extends the lifetime, with sink
+    
+    AutoPtr    - Shorthand for auto_ptr like scope.
+    RefCount   - Shorthand for ref_ptr like scope.
+        
+******************************************************/
+struct Scopes
+{
+
+class LIBSIGC_API Uncounted:public Scope
+  {
+     Uncounted& operator=(const Uncounted&);
+     Uncounted(const Uncounted&);
+   public:
+     virtual void disconnect(bool level=0);
+     Uncounted():Scope() {}
+     virtual ~Uncounted();
+  };
+
+class LIBSIGC_API Extend:public Scope
+  {
+  public:
+     Extend& operator=(const Extend&);
+     Extend(const Extend&);
+   protected:
+     virtual void on_connect();
+     virtual void erase();
+   public:
+     virtual void disconnect(bool level=0);
+     void set(ObjectScoped* obj,void* cache,bool ptr);
+     Extend():Scope() {}
+     virtual ~Extend();
+  };
+
+class LIBSIGC_API Limit:public Scope
+  {
+     Limit& operator=(const Limit&);
+     Limit(const Limit&);
+   protected:
+     virtual void on_connect();
+     virtual void erase();
+   public:
+     virtual void disconnect(bool level=0);
+     void set(ObjectScoped* obj,void* cache,bool ptr);
+     Limit():Scope() {}
+     virtual ~Limit();
+  };
+
+typedef Extend RefCount;
+typedef Reference Lock;
+};
+
+/*************************************************************
+***** Lists 
+*************************************************************/
+// Stub for building polylists
+
+
+// Iterator skeleton
+struct LIBSIGC_API ScopeIterator_
+  {
+   typedef ScopeNode NodeType;
+   private:
+     NodeType *node_;
+   public:
+
+   inline NodeType* node()             {return node_;}
+   inline const NodeType* node() const {return node_;}
+
+   inline NodeType& operator*()
+     {return *node_;
+     }
+   inline const NodeType& operator*() const
+     {return *node_;
+     }
+   
+   inline bool operator==(const ScopeIterator_& i) const 
+     {return node_==i.node_;
+     }
+   inline bool operator!=(const ScopeIterator_& i) const
+     {return node_!=i.node_;
+     }
+
+   inline ScopeIterator_& operator++()
+     {
+      if (node_) 
+        node_=(NodeType*)node_->next_;
+      return *this;
+     }
+
+   ScopeIterator_ operator++(int)
+     {
+      ScopeIterator_ tmp=*this;
+      ++*this;
+      return tmp;
+     }
+
+   ScopeIterator_& operator= (const ScopeIterator_& i)
+     {
+      node_=i.node_;
+      return *this;
+     }
+
+   ScopeIterator_(const ScopeIterator_ &n):node_(n.node_) {}
+   ScopeIterator_(NodeType *n):node_(n) {}
+   ScopeIterator_():node_(0) {}
+  };
+
+class LIBSIGC_API ScopeList
+  {
+   public:
+   typedef ScopeNode NodeType; 
+   typedef ScopeIterator_ Iterator;
+
+   ScopeNode node_;   
+
+   inline Iterator begin()             {return Iterator(node_.next_);}
+   inline Iterator end()               {return Iterator(&node_);}
+
+   // insert item directly on list
+   Iterator insert_direct(Iterator pos,NodeType *n);
+
+   Iterator erase(Iterator pos);
+   void erase(Iterator start,Iterator stop)
+     { while (start!=stop) start=erase(start); }
+   void swap_elements(Iterator p1,Iterator p2);
+
+   void clear()
+     { erase(begin(),end()); }
+
+   bool empty() const {return node_.next_==&node_;} 
+   
+   ScopeList():node_() {}
+   ~ScopeList() { clear(); }
+
+   private:
+     ScopeList(const ScopeList&);
+  };
+
+
+
+#ifdef SIGC_CXX_NAMESPACES
+} // namespace sigc
+#endif
+
+#endif

programs/develop/libraries/menuetlibc/include/sigc++/sigc++config.h

@@ -0,0 +1,15 @@
+#ifndef _SIGC_CONFIG_H_
+#define _SIGC_CONFIG_H_
+
+#define SIGC_MAJOR_VERSION 0
+#define SIGC_MINOR_VERSION 8
+#define SIGC_MICRO_VERSION 2
+
+#define SIGC_CXX_PARTIAL_SPEC 1 /**/
+#define SIGC_CXX_MEMBER_FUNC_TEMPLATES 1 /**/
+#define SIGC_CXX_MEMBER_CLASS_TEMPLATES 1 /**/
+#define SIGC_CXX_MUTABLE 1 /**/
+#define SIGC_CXX_TEMPLATE_CCTOR 1
+#define LIBSIGC_API
+    
+#endif

programs/develop/libraries/menuetlibc/include/sigc++/signal_system.h

@@ -0,0 +1,36 @@
+/*************************************************************************
+***** A Signal Framework for C++
+**************************************************************************
+ 
+  Copyright 1998-1999 Karl Nelson <kenelson@ece.ucdavis.edu>
+                                                         
+  Based off of ideas from Gtk-- signal system by Tero Pulkkinen.
+ 
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Library General Public
+  License as published by the Free Software Foundation; either
+  version 2 of the License, or (at your option) any later version.
+ 
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Library General Public License for more details.
+ 
+  You should have received a copy of the GNU Library General Public
+  License along with this library; if not, write to the Free
+  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*************************************************************************/
+
+#ifndef SIGCXX_SIGNAL_SYSTEM_H
+#define SIGCXX_SIGNAL_SYSTEM_H
+
+#include <sigc++/slot.h>
+#include <sigc++/object_slot.h>
+#include <sigc++/func_slot.h>
+#include <sigc++/basic_signal.h>
+#if 0
+#include <sigc++/signals.h>
+#endif
+ 
+#endif

programs/develop/libraries/menuetlibc/include/sigc++/thread.h

@@ -0,0 +1,242 @@
+// -*- c++ -*-
+/* 
+ * Copyright 1999 Karl Nelson <kenelson@ece.ucdavis.edu>
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#ifndef SIGCXX_THREAD_H
+#define SIGCXX_THREAD_H
+#include <sigc++config.h>
+
+#ifdef SIGC_PTHREADS
+
+#ifdef SIGC_THREAD_IMPL
+#include <pthread.h>
+#else
+#include <time.h>
+#endif
+
+#ifdef SIGC_CXX_NAMESPACES
+namespace SigC
+{
+namespace Threads
+{
+#else
+#define Threads 
+#endif
+
+#ifdef SIGC_THREAD_IMPL
+#ifdef SIGC_PTHREAD_DCE
+struct CondAttr { pthread_condattr_t impl_;};
+struct MutexAttr { pthread_mutexattr_t impl_;};
+struct ThreadAttr { pthread_attr_t impl_;};
+#else
+struct CondAttr { pthread_condattr_t* impl_;};
+struct MutexAttr { pthread_mutexattr_t* impl_;};
+struct ThreadAttr { pthread_attr_t* impl_;};
+#endif
+typedef pthread_mutex_t MutexImpl;
+typedef pthread_cond_t CondImpl;
+typedef pthread_key_t KeyImpl;
+typedef pthread_t ThreadImpl;
+#else
+class CondAttr {unsigned char dummy[SIGC_PTHREAD_COND_ATTR];};
+class CondImpl {unsigned char dummy[SIGC_PTHREAD_COND_IMPL];};
+class MutexAttr {unsigned char dummy[SIGC_PTHREAD_MUTEX_ATTR];};
+class MutexImpl {unsigned char dummy[SIGC_PTHREAD_MUTEX_IMPL];};
+class ThreadAttr {unsigned char dummy[SIGC_PTHREAD_THREAD_ATTR];};
+class ThreadImpl {unsigned char dummy[SIGC_PTHREAD_THREAD_IMPL];};
+class KeyImpl {unsigned char dummy[SIGC_PTHREAD_KEY_IMPL];};
+#endif
+
+// Mutual Exclusion
+class Mutex
+  {
+   typedef MutexImpl Impl;
+   private:
+     Impl mutex_;
+     int destroy();
+
+   public:
+     static MutexAttr Default;
+#ifdef SIGC_THREAD_IMPL
+     operator Impl* ()  {return (Impl*)(&mutex_);}
+#endif
+
+     Mutex(const MutexAttr attr=Default); 
+
+     // (needs work) 
+     ~Mutex();
+
+     int lock();
+     int trylock();
+     int unlock();
+  };
+
+// A lazy way to unlock at end of scope
+struct MLock
+  {
+   Mutex &mutex_;
+   MLock(Mutex& mutex):mutex_(mutex) {mutex_.lock();}
+   ~MLock()                          {mutex_.unlock();}
+  };
+
+// Condition Variable
+struct Condition
+  {
+   typedef CondImpl Impl;
+   private:
+     Impl cond_;
+
+     int destroy();
+   public:
+     static CondAttr Default;
+#ifdef SIGC_THREAD_IMPL
+     operator Impl* ()  {return (Impl*)(&cond_);}
+#endif
+
+     Condition(const CondAttr &attr=Default);
+     ~Condition();
+
+     // restarts exactly one thread hung on condition
+     int signal();
+
+     // restarts all threads waiting on condition
+     int broadcast();
+
+     // unlocks a mutex while waiting on a condition, then reaquires lock.
+     int wait(Mutex &m);
+
+     // unlocks a mutex while waiting on a condition, then reaquires lock
+     // with a fixed maximum duration.
+     int wait(Mutex &m,struct timespec* spec);
+
+  };
+
+// Integer Semaphore
+struct Semaphore
+  {
+   int value_;
+   Condition sig_;
+   Mutex access_;
+
+   void up();
+   void down();
+   
+   Semaphore(int value=1);
+   ~Semaphore();
+  };
+
+struct Private_
+  {
+    KeyImpl key_;
+    void* get();
+    void set(void *value);
+    void create(void (*dtor)(void*));
+    void destroy();
+  };
+
+// Private is a thread split static.  
+template <class T>
+class Private : private Private_
+  {
+    private:
+      static void dtor(void* v)
+        {
+          T* obj=(T*)v;
+          delete obj;
+        }
+
+    public:
+
+      T& operator =(const T& t)
+        {return (((T&)*this)=t);}
+
+      operator T& ()
+        {
+          T *value=(T*)get();
+          if (!value)
+            set((void*)(value=new T()));  
+          return *(value);
+        }
+
+      Private()  { create(&dtor); }
+      ~Private() { destroy(); }
+  };
+
+// int needs to initialized
+template <>
+class Private<int> : private Private_
+  {
+    private:
+      static void dtor(void* v)
+        {
+          int* obj=(int*)v;
+          delete obj;
+        }
+
+      public:
+        int& operator =(const int& t)
+          {return (((int&)*this)=t);}
+
+        operator int& ()
+          {
+           int *value=(int*)get();
+           if (!value)
+             set((void*)(value=new int(0)));  
+           return *(value); 
+          }
+
+        Private() { create(&dtor); }
+        ~Private() { destroy(); }
+  };
+
+struct Thread
+  {
+   protected:
+     typedef ThreadImpl Impl;
+     Impl thread_;
+     void*     arg_;
+     ThreadAttr attr_;
+
+     static void* call_main_(void* obj);
+
+   public:
+#ifdef SIGC_THREAD_IMPL
+     operator Impl* () {return &thread_;}
+#endif
+
+     virtual void* main(void*)=0;
+     int detach();
+
+     static ThreadAttr Default;
+
+     // arg is for passing extra data to main, but never pass a
+     // local variable or address of local variable.  Arg must
+     // be available throughout life of program.
+     int start(void* arg=0);
+     
+     Thread(const ThreadAttr &attr=Default);
+     virtual ~Thread();
+  };
+
+
+#ifdef SIGC_CXX_NAMESPACES
+} /* namespace Threads */
+} /* namespace SigC */
+#endif 
+
+#endif /* SIGC_PTHREADS */
+#endif /* SIGCXX_THREAD_H */

programs/develop/libraries/menuetlibc/include/sigc++/type.h

@@ -0,0 +1,63 @@
+// -*- c++ -*-
+/* 
+ * Copyright 1999 Karl Nelson <kenelson@ece.ucdavis.edu>
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#ifndef SIGCXX_TYPE_H
+#define SIGCXX_TYPE_H
+
+#include <sigc++config.h>
+
+#ifdef SIGC_CXX_NAMESPACES
+namespace SigC
+{
+#endif
+
+/* some classes for making parameter passing easier */
+
+#ifdef SIGC_CXX_SPECIALIZE_REFERENCES
+template <typename T>
+struct Trait
+  {
+   typedef const T& ref;
+   typedef T        type;
+  };
+
+template <typename T>
+struct Trait<T&>
+  {
+   typedef T& ref;
+   typedef T& type;
+  };
+#else
+template <typename T>
+struct Trait
+  {
+   typedef T ref;  // VC++ does not support reference typedef
+   typedef T type;
+  };
+#endif
+
+template <>
+struct Trait<void>:public Trait<int>
+  {};
+
+
+#ifdef SIGC_CXX_NAMESPACES
+}
+#endif
+
+#endif