From de80e1f2d4154b57bbdc4a7fcc537a17f103055e Mon Sep 17 00:00:00 2001
From: Jonathan Wilkes <jon.w.wilkes@gmail.com>
Date: Fri, 3 Jun 2016 22:07:31 -0400
Subject: [PATCH] port 391c07b6d1552395683cbb50a16ea708792797a6 from Pd-l2ork:
 updated iemguts to the latest version

---
 externals/iem/iemguts/src/autoabstraction.c   |  25 +-
 externals/iem/iemguts/src/canvasargs.c        |  31 ++-
 externals/iem/iemguts/src/canvasconnections.c |  49 ++--
 externals/iem/iemguts/src/canvasdelete.c      |  47 ++--
 externals/iem/iemguts/src/canvasdollarzero.c  |  26 +-
 externals/iem/iemguts/src/canvaserror.c       |  10 +-
 externals/iem/iemguts/src/canvasindex.c       |   9 +-
 externals/iem/iemguts/src/canvasname.c        |  50 ++--
 .../iem/iemguts/src/canvasobjectposition.c    |  11 +-
 externals/iem/iemguts/src/canvasposition.c    |   9 +-
 externals/iem/iemguts/src/canvasselect.c      |  42 ++--
 externals/iem/iemguts/src/classtest.c         |  11 +-
 .../iem/iemguts/src/closebang.c.disabled      |  73 ++++++
 externals/iem/iemguts/src/findbrokenobjects.c | 230 ++++++++++++++++++
 externals/iem/iemguts/src/iemguts-objlist.h   |  17 +-
 externals/iem/iemguts/src/iemguts.h           |  86 +++++++
 externals/iem/iemguts/src/initbang.c.disabled |  74 ++++++
 externals/iem/iemguts/src/oreceive.c          |  19 +-
 externals/iem/iemguts/src/propertybang.c      |   7 +-
 externals/iem/iemguts/src/receivecanvas.c     |  85 +++++--
 externals/iem/iemguts/src/savebangs.c         |  11 +-
 externals/iem/iemguts/src/sendcanvas.c        |   9 +-
 externals/iem/iemguts/src/try.c               |   9 +-
 23 files changed, 758 insertions(+), 182 deletions(-)
 create mode 100644 externals/iem/iemguts/src/closebang.c.disabled
 create mode 100644 externals/iem/iemguts/src/findbrokenobjects.c
 create mode 100644 externals/iem/iemguts/src/iemguts.h
 create mode 100644 externals/iem/iemguts/src/initbang.c.disabled

diff --git a/externals/iem/iemguts/src/autoabstraction.c b/externals/iem/iemguts/src/autoabstraction.c
index 9eec17d0f..047f3b218 100644
--- a/externals/iem/iemguts/src/autoabstraction.c
+++ b/externals/iem/iemguts/src/autoabstraction.c
@@ -1,7 +1,11 @@
-/* Copyright (c) 2008 IOhannes m zmölnig @ IEM
+/* Copyright (c) 2008 IOhannes m zmÃķlnig @ IEM
  * For information on usage and redistribution, and for a DISCLAIMER OF ALL
  * WARRANTIES, see the file, "LICENSE.txt," that comes with Pd.  
- */
+ ******************************************************
+ *
+ * license: GNU General Public License v.2 (or later)
+ *
+ ******************************************************/
 
 /*
  * this code adds an external "loader" to Miller S. Puckette's "pure data",
@@ -23,7 +27,7 @@
 # define MSW
 #endif
 
-#include "m_pd.h"
+#include "iemguts.h"
 
 
 typedef struct _autoabstraction
@@ -34,15 +38,12 @@ static t_class *autoabstraction_class;
 
 static int s_state=0;
 
-static char *version = "$Revision: 0.1 $";
-
 /* this is the name of the filename that get's loaded as a default template for new abstractions */
 static char*s_templatefilename="autoabstraction.template";
 /* if the loading above fails, we resort to a simple default abstraction that automatically opens up */
 /* LATER: make the font-size the same as the one used by Pd */
 static char*s_templatestring="#N canvas 0 0 450 300 10; #X vis 1;";
 
-
 #if (PD_MINOR_VERSION >= 40)
 # define AUTOABSTRACTION_ENABLED 1
 #endif
@@ -103,14 +104,14 @@ static int autoabstraction_loader(t_canvas *canvas, char *classname)
   int fd=0;
   char dirbuf[MAXPDSTRING], *nameptr;
 
-  if((fd=canvas_open(canvas, classname, ".pd", dirbuf, &nameptr, MAXPDSTRING, 0)) >= 0 ||
-     (fd=canvas_open(canvas, classname, ".pat", dirbuf, &nameptr, MAXPDSTRING, 0)) >= 0)
+  if((fd=canvas_open(canvas, classname, ".pd", dirbuf, &nameptr, MAXPDSTRING, 0)) >= 0)
     {
       /* oops, there's already an abstraction of the given <classname> */
       close(fd);
       return(0);
     }
 
+  /* none! we create one, so Pd can later find it... */
   autoabstraction_createpatch(canvas, classname);
 
   /* we always fail, because we want Pd to do the real opening of abstractions */
@@ -160,15 +161,13 @@ static void*autoabstraction_new(t_symbol *s, int argc, t_atom *argv)
 void autoabstraction_setup(void)
 {
   /* relies on t.grill's loader functionality, fully added in 0.40 */
-  post("automatic abstraction creator %s",version);  
-  post("\twritten by IOhannes m zmoelnig, IEM <zmoelnig@iem.at>");
-  post("\tcompiled on "__DATE__" at "__TIME__ " ");
-  post("\tcompiled against Pd version %d.%d.%d.%s", PD_MAJOR_VERSION, PD_MINOR_VERSION, PD_BUGFIX_VERSION, PD_TEST_VERSION);
+  iemguts_boilerplate("automatic abstraction creator", 0);
 #ifdef AUTOABSTRACTION_ENABLED
   autoabstraction_initialize();
   sys_register_loader(autoabstraction_loader);
+#warning FIXME loader-0.47 mode!
 #else
-  error("to function, this needs to be compiled against Pd 0.40 or higher,\n");
+  error("autoabstraction needs to be compiled against Pd 0.40 or higher,\n");
   error("\tor a version that has sys_register_loader()");
 #endif
 
diff --git a/externals/iem/iemguts/src/canvasargs.c b/externals/iem/iemguts/src/canvasargs.c
index a3c733f99..13c322359 100644
--- a/externals/iem/iemguts/src/canvasargs.c
+++ b/externals/iem/iemguts/src/canvasargs.c
@@ -2,15 +2,15 @@
  *
  * canvasargs - implementation file
  *
- * copyleft (c) IOhannes m zm-bölnig-A
+ * copyleft (c) IOhannes m zmÃķlnig
  *
- *   2007:forum::f-bür::umläute:2007-A
+ *   2007:forum::fÞr::umlÃĪute:2007
  *
  *   institute of electronic music and acoustics (iem)
  *
  ******************************************************
  *
- * license: GNU General Public License v.2
+ * license: GNU General Public License v.2 (or later)
  *
  ******************************************************/
 
@@ -31,7 +31,7 @@
  * nice, eh?
  */
 
-#include "m_pd.h"
+#include "iemguts.h"
 #include "g_canvas.h"
 
 
@@ -49,16 +49,17 @@ typedef struct _canvasargs
 
 static void canvasargs_list(t_canvasargs *x, t_symbol*s, int argc, t_atom*argv)
 {
-  t_canvas*c=x->x_canvas;
   t_binbuf*b=0;
   t_atom name[1];
 
-  if(!x->x_canvas) return;
+  if(!x || !x->x_canvas) return;
   b=x->x_canvas->gl_obj.te_binbuf;
 
   if(!b)return;
 
+  /* if this method is called with a non-special selector, we *rename* the object */
   if(s==0 || s==gensym("") || s==&s_list || s==&s_bang || s==&s_float || s==&s_symbol || s==&s_) {
+    /* keep the given name */
     t_atom*ap=binbuf_getvec(b);
     s=atom_getsymbol(ap);
   }
@@ -73,21 +74,28 @@ static void canvasargs_bang(t_canvasargs *x)
 {
   int argc=0;
   t_atom*argv=0;
-  t_binbuf*b;
+  t_binbuf*b=0;
 
   if(!x->x_canvas) return;
   b=x->x_canvas->gl_obj.te_binbuf;
 
-  if(!b)return;
+  if(b) {
+    argc=binbuf_getnatom(b)-1;
+    argv=binbuf_getvec(b)+1;
+  } else {
+    canvas_setcurrent(x->x_canvas);
+    canvas_getargs(&argc, &argv);
+    canvas_unsetcurrent(x->x_canvas);
+  }
 
-  argc=binbuf_getnatom(b);
-  argv=binbuf_getvec(b);
-  outlet_list(x->x_obj.ob_outlet, &s_list, argc-1, argv+1);
+  if(argv)
+    outlet_list(x->x_obj.ob_outlet, &s_list, argc, argv);
 }
 
 
 static void canvasargs_free(t_canvasargs *x)
 {
+  x->x_canvas = 0;
 }
 
 static void *canvasargs_new(t_floatarg f)
@@ -112,6 +120,7 @@ static void *canvasargs_new(t_floatarg f)
 
 void canvasargs_setup(void)
 {
+  iemguts_boilerplate("[canvasargs]", 0);
   canvasargs_class = class_new(gensym("canvasargs"), (t_newmethod)canvasargs_new,
                                (t_method)canvasargs_free, sizeof(t_canvasargs), 0, A_DEFFLOAT, 0);
   class_addlist(canvasargs_class, (t_method)canvasargs_list);
diff --git a/externals/iem/iemguts/src/canvasconnections.c b/externals/iem/iemguts/src/canvasconnections.c
index 2d29e794b..ac98548f5 100644
--- a/externals/iem/iemguts/src/canvasconnections.c
+++ b/externals/iem/iemguts/src/canvasconnections.c
@@ -3,15 +3,15 @@
  *
  * canvasconnections - implementation file
  *
- * copyleft (c) IOhannes m zmölnig
+ * copyleft (c) IOhannes m zmÃķlnig
  *
- *   2008:forum::für::umläute:2008
+ *   2008:forum::fÞr::umlÃĪute:2008
  *
  *   institute of electronic music and acoustics (iem)
  *
  ******************************************************
  *
- * license: GNU General Public License v.2
+ * license: GNU General Public License v.2 (or later)
  *
  ******************************************************/
 
@@ -23,7 +23,7 @@
  * e.g. [canvasconnections 1] will query the parent of the containing canvas
  */
 
-#include "m_pd.h"
+#include "iemguts.h"
 #include "g_canvas.h"
 #include "m_imp.h"
 #include <string.h>
@@ -52,13 +52,13 @@ typedef struct _intvec
 
 static t_intvec*intvec_new(int initial_size)
 {
-  t_intvec*res=(t_intvec*)getbytes(sizeof(t_intvec));
+  t_intvec*res=getbytes(sizeof(*res));
   if(initial_size<1)
     initial_size=32;
   
   res->num_elements=0;
   res->size=initial_size;
-  res->elements=(int*)getbytes(res->size*sizeof(int));
+  res->elements=getbytes(res->size*sizeof(*res->elements));
 
   return res;
 }
@@ -68,13 +68,13 @@ static void intvec_free(t_intvec*vec)
 {
   if(NULL==vec)return;
   if(vec->elements)
-    freebytes(vec->elements, sizeof(int)*vec->size);
+    freebytes(vec->elements, vec->size * sizeof(*vec->elements));
   vec->elements=NULL;
 
   vec->size=0;
   vec->num_elements=0;
 
-  freebytes(vec, sizeof(t_intvec));
+  freebytes(vec, sizeof(*vec));
 }
 
 
@@ -114,7 +114,6 @@ static int query_inletconnections(t_canvasconnections *x, t_intvec***outobj, t_i
   t_intvec**invecs=NULL;
   t_intvec**inwhich=NULL;
   int ninlets=0;
-  int nin=0;
  
   t_gobj*y;
 
@@ -130,8 +129,8 @@ static int query_inletconnections(t_canvasconnections *x, t_intvec***outobj, t_i
      * to find out, whether they are connected to us!
      */
 
-  invecs=getbytes(sizeof(t_intvec*)*ninlets);
-  inwhich=getbytes(sizeof(t_intvec*)*ninlets);
+  invecs =getbytes(ninlets*sizeof(*invecs));
+  inwhich=getbytes(ninlets*sizeof(*inwhich));
   for(i=0; i<ninlets; i++){
     invecs[i]=intvec_new(0);
     inwhich[i]=intvec_new(0);
@@ -189,7 +188,7 @@ static void canvasconnections_queryinlets(t_canvasconnections *x)
   for(i=0; i<ninlets; i++){
     int size=invecs[i]->num_elements;
     if(size>0) {
-      t_atom*ap=getbytes(sizeof(t_atom)*(size+1));
+      t_atom*ap=getbytes((size+1)*sizeof(*ap));
       int j=0;
       t_symbol*s=gensym("inlet");
 
@@ -198,23 +197,22 @@ static void canvasconnections_queryinlets(t_canvasconnections *x)
         SETFLOAT(ap+j+1, ((t_float)invecs[i]->elements[j]));
       
       outlet_anything(x->x_out, s, size+1, ap);
-      freebytes(ap, sizeof(t_atom)*(size+1));
+      freebytes(ap, (size+1) * sizeof(*ap));
     }
     intvec_free(invecs[i]);
   }
-  if(invecs)freebytes(invecs, sizeof(t_intvec*)*ninlets);
+  if(invecs)freebytes(invecs, ninlets * sizeof(*invecs));
 }
 
 static void canvasconnections_inlet(t_canvasconnections *x, t_floatarg f)
 {
   int inlet=f;
-  t_atom at;
   t_intvec**invecs=0;
   int ninlets=query_inletconnections(x, &invecs, 0); 
 
   if(inlet >= 0 && inlet < ninlets) {
     int size=invecs[inlet]->num_elements;
-    t_atom*ap=getbytes(sizeof(t_atom)*(size+1));
+    t_atom*ap=getbytes((size+1)*sizeof(*ap));
     t_symbol*s=gensym("inlet");
     if(obj_issignalinlet(x->x_object,inlet)) {
       s=gensym("inlet~");
@@ -229,11 +227,11 @@ static void canvasconnections_inlet(t_canvasconnections *x, t_floatarg f)
     }
       
     outlet_anything(x->x_out, s, size+1, ap);
-    freebytes(ap, sizeof(t_atom)*(size+1));
+    freebytes(ap, (size+1) * sizeof(*ap));
 
     intvec_free(invecs[inlet]);
   }
-  if(invecs)freebytes(invecs, sizeof(t_intvec*)*ninlets);
+  if(invecs)freebytes(invecs, ninlets * sizeof(*invecs));
 }
 
 
@@ -285,8 +283,8 @@ static void canvasconnections_inconnect(t_canvasconnections *x, t_floatarg f)
       intvec_free(inwhich[i]);
     }
   }
-  if(invecs)freebytes(invecs, sizeof(t_intvec*)*ninlets);
-  if(inwhich)freebytes(inwhich, sizeof(t_intvec*)*ninlets);
+  if(invecs) freebytes(invecs , ninlets * sizeof(*invecs));
+  if(inwhich)freebytes(inwhich, ninlets * sizeof(*inwhich));
 }
 
 
@@ -325,7 +323,6 @@ static void canvasconnections_outconnect(t_canvasconnections *x, t_floatarg f)
     t_outconnect*conn=obj_starttraverseoutlet(x->x_object, &out, outlet);
     t_object*dest=0;
     t_inlet*in=0;
-    int count=0;
     int id=glist_getindex(x->x_parent, (t_gobj*)x->x_object);
 
     conn=obj_starttraverseoutlet(x->x_object, &out, outlet);
@@ -349,7 +346,6 @@ static void canvasconnections_outconnect(t_canvasconnections *x, t_floatarg f)
 static void canvasconnections_outlet(t_canvasconnections *x, t_floatarg f)
 {
   int outlet=f;
-  t_atom*at=NULL;
   int noutlets=0;
 
   if(0==x->x_object || 0==x->x_parent)
@@ -375,7 +371,7 @@ static void canvasconnections_outlet(t_canvasconnections *x, t_floatarg f)
       conn=obj_nexttraverseoutlet(conn, &dest, &in, &which);
       count++;
     }
-    abuf=(t_atom*)getbytes(sizeof(t_atom)*(count+1));
+    abuf=getbytes((count+1)*sizeof(*abuf));
     SETFLOAT(abuf, outlet);
 
     if(count>0) {
@@ -391,7 +387,7 @@ static void canvasconnections_outlet(t_canvasconnections *x, t_floatarg f)
       }
     }
     outlet_anything(x->x_out, s, count+1, abuf);
-    freebytes(abuf, sizeof(t_atom)*(count+1));
+    freebytes(abuf, (count+1) * sizeof(*abuf));
   }
 }
 
@@ -417,7 +413,7 @@ static void canvasconnections_queryoutlets(t_canvasconnections *x)
     }
     if(count>0) {
       int i=0;
-      t_atom*abuf=(t_atom*)getbytes(sizeof(t_atom)*(count+1));
+      t_atom*abuf=getbytes((count+1)*sizeof(*abuf));
       SETFLOAT(abuf, nout);
       conn=obj_starttraverseoutlet(x->x_object, &out, nout);
       while(conn) {
@@ -429,7 +425,7 @@ static void canvasconnections_queryoutlets(t_canvasconnections *x)
         i++;
       }
       outlet_anything(x->x_out, gensym("outlet"), count+1, abuf);
-      freebytes(abuf, sizeof(t_atom)*(count+1));
+      freebytes(abuf, (count+1) * sizeof(*abuf));
     }
   }
 }
@@ -476,6 +472,7 @@ static void *canvasconnections_new(t_floatarg f)
 
 void canvasconnections_setup(void)
 {
+  iemguts_boilerplate("[canvasconnections]", 0);
   canvasconnections_class = class_new(gensym("canvasconnections"), 
                                       (t_newmethod)canvasconnections_new, (t_method)canvasconnections_free, 
                                       sizeof(t_canvasconnections), 0, 
diff --git a/externals/iem/iemguts/src/canvasdelete.c b/externals/iem/iemguts/src/canvasdelete.c
index b4044330a..2ecc6ee5f 100644
--- a/externals/iem/iemguts/src/canvasdelete.c
+++ b/externals/iem/iemguts/src/canvasdelete.c
@@ -3,24 +3,24 @@
  *
  * canvasdelete - implementation file
  *
- * copyleft (c) IOhannes m zmölnig
+ * copyleft (c) IOhannes m zmÃķlnig
  *
- *   2007:forum::für::umläute:2007
+ *   2007:forum::fÞr::umlÃĪute:2007
  *
  *   institute of electronic music and acoustics (iem)
  *
  ******************************************************
  *
- * license: GNU General Public License v.2
+ * license: GNU General Public License v.2 (or later)
  *
  ******************************************************/
 
 
-/* 
+/*
  * this object deletes itself (or the specified parent canvas) when banged
  */
 
-#include "m_pd.h"
+#include "iemguts.h"
 
 #include "g_canvas.h"
 
@@ -43,22 +43,25 @@ static void canvasdelete_doit(t_canvasdelete *x)
   clock_free(x->x_clock);
   x->x_clock=NULL;
 
-  glist_delete(x->x_glist, x->x_gobj);
+  if(x->x_glist)
+    glist_delete(x->x_glist, x->x_gobj);
+  else {
+    t_atom ap[1];
+    SETFLOAT(ap, 1);
+    typedmess(x->x_gobj, gensym("menuclose"), 1, ap);
+  }
+
 
   canvas_resume_dsp(dspstate);
 }
 
 static void canvasdelete_bang(t_canvasdelete *x)
 {
-  int x1=0, y1=0, width=0, height=0;
-  t_atom alist[2];
-
   if(x->x_clock) {
     pd_error(x, "deletion already scheduled");
     return;
   }
-
-  if(NULL==x->x_glist || NULL==x->x_gobj)return;
+  if(NULL==x->x_gobj)return;
 
   x->x_clock=clock_new(x, (t_method)canvasdelete_doit);
   clock_delay(x->x_clock, 0);
@@ -71,7 +74,7 @@ static void *canvasdelete_new(t_floatarg f)
   t_canvas *canvas=(t_canvas*)glist_getcanvas(glist);
   t_gobj*obj=(t_gobj*)x;
   int depth=(int)f;
-  
+
   if(depth<0)depth=0;
 
   while(depth && canvas) {
@@ -80,9 +83,12 @@ static void *canvasdelete_new(t_floatarg f)
     depth--;
   }
 
-  x->x_glist = canvas;
-  x->x_gobj=obj;
-  
+  x->x_glist = x->x_gobj = NULL;
+  if (!depth) {
+    x->x_glist = canvas;
+    x->x_gobj=obj;
+  }
+
   x->x_clock=NULL;
 
   return (x);
@@ -97,8 +103,9 @@ static void canvasdelete_canvasmethods(void);
 
 void canvasdelete_setup(void)
 {
-  canvasdelete_class = class_new(gensym("canvasdelete"), 
-                                 (t_newmethod)canvasdelete_new, (t_method)canvasdelete_free, 
+  iemguts_boilerplate("[canvasdelete] - delete message for the canvas", 0);
+  canvasdelete_class = class_new(gensym("canvasdelete"),
+                                 (t_newmethod)canvasdelete_new, (t_method)canvasdelete_free,
                                  sizeof(t_canvasdelete), 0,
                                  A_DEFFLOAT, 0);
   class_addbang(canvasdelete_class, (t_method)canvasdelete_bang);
@@ -110,7 +117,7 @@ void canvasdelete_setup(void)
 /* 'delete' message for the canvas */
 static int canvas_delete_docb(t_glist*glist, int index) {
   /* this will crash Pd if the object to be deleted is on the stack
-   * workarounds: 
+   * workarounds:
    *   - use a clock (see above)
    *   - finally fix this in Pd
    */
@@ -142,6 +149,7 @@ static int canvas_delete_docb(t_glist*glist, int index) {
 static void canvas_delete_cb(t_canvas*x, t_symbol*s, int argc, t_atom*argv)
 {
   int dspstate= canvas_suspend_dsp();
+#warning FIXME map the indices to real objects before deleting them
   if(argc) {
     while(argc--){
       canvas_delete_docb(x, atom_getint(argv++));
@@ -154,9 +162,8 @@ static void canvas_delete_cb(t_canvas*x, t_symbol*s, int argc, t_atom*argv)
 static void canvasdelete_canvasmethods(void) {
   if(NULL==canvas_class)return;
   if(NULL==zgetfn(&canvas_class, gensym("delete"))) {
-    verbose(1, "adding 'delete' method to canvas");
+    verbose(0, "adding 'delete' method to canvas");
     class_addmethod(canvas_class, (t_method)canvas_delete_cb, gensym("delete"), A_GIMME, 0);
   }
-
 }
 
diff --git a/externals/iem/iemguts/src/canvasdollarzero.c b/externals/iem/iemguts/src/canvasdollarzero.c
index 6a43eb92b..5d9d7e42d 100644
--- a/externals/iem/iemguts/src/canvasdollarzero.c
+++ b/externals/iem/iemguts/src/canvasdollarzero.c
@@ -1,10 +1,25 @@
-/* For information on usage and redistribution, and for a DISCLAIMER OF ALL
-* WARRANTIES, see the file, "LICENSE.txt," in this distribution.
 
-based on iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */
+/******************************************************
+ *
+ * canvasdollarzero - implementation file
+ *
+ *
+ * copyleft (c) IOhannes m zmÃķlnig
+ *
+ *   2007:forum::fÞr::umlÃĪute:2007
+ *
+ *   institute of electronic music and acoustics (iem)
+ *
+ * based on iemlib2 
+ *   copyright (c) 2000-2006 Thomas Musil, IEM, KUG, Graz/Austria
+ *
+ ******************************************************
+ *
+ * license: GNU General Public License v.2 (or later)
+ *
+ ******************************************************/
 
-
-#include "m_pd.h"
+#include "iemguts.h"
 #include "g_canvas.h"
 
 
@@ -50,6 +65,7 @@ static void *canvasdollarzero_new(t_floatarg f)
 
 void canvasdollarzero_setup(void)
 {
+  iemguts_boilerplate("[canvasdollarzero]", 0);
   canvasdollarzero_class = class_new(gensym("canvasdollarzero"), 
                                      (t_newmethod)canvasdollarzero_new, 0, 
                                      sizeof(t_canvasdollarzero), 0, 
diff --git a/externals/iem/iemguts/src/canvaserror.c b/externals/iem/iemguts/src/canvaserror.c
index 29a8004cf..ace55d984 100644
--- a/externals/iem/iemguts/src/canvaserror.c
+++ b/externals/iem/iemguts/src/canvaserror.c
@@ -3,15 +3,15 @@
  *
  * canvaserror - implementation file
  *
- * copyleft (c) IOhannes m zm-bölnig-A
+ * copyleft (c) IOhannes m zmÃķlnig
  *
- *   2007:forum::f-bür::umläute:2007-A
+ *   2007:forum::fÞr::umlÃĪute:2007
  *
  *   institute of electronic music and acoustics (iem)
  *
  ******************************************************
  *
- * license: GNU General Public License v.2
+ * license: GNU General Public License v.2 (or later)
  *
  ******************************************************/
 
@@ -32,7 +32,7 @@
  * nice, eh?
  */
 
-#include "m_pd.h"
+#include "iemguts.h"
 #include "g_canvas.h"
 
 
@@ -77,6 +77,7 @@ static void canvaserror_any(t_canvaserror *x, t_symbol*s, int argc, t_atom*argv)
 
 static void canvaserror_free(t_canvaserror *x)
 {
+  x->x_canvas = 0;
 }
 
 static void *canvaserror_new(t_floatarg f)
@@ -100,6 +101,7 @@ static void *canvaserror_new(t_floatarg f)
 
 void canvaserror_setup(void)
 {
+  iemguts_boilerplate("[canvaserror]", 0);
   canvaserror_class = class_new(gensym("canvaserror"), (t_newmethod)canvaserror_new,
                                (t_method)canvaserror_free, sizeof(t_canvaserror), 0, A_DEFFLOAT, 0);
   class_addanything(canvaserror_class, (t_method)canvaserror_any);
diff --git a/externals/iem/iemguts/src/canvasindex.c b/externals/iem/iemguts/src/canvasindex.c
index 6633c1bab..9fa06689f 100644
--- a/externals/iem/iemguts/src/canvasindex.c
+++ b/externals/iem/iemguts/src/canvasindex.c
@@ -3,15 +3,15 @@
  *
  * canvasindex - implementation file
  *
- * copyleft (c) IOhannes m zmölnig
+ * copyleft (c) IOhannes m zmÃķlnig
  *
- *   2007:forum::für::umläute:2007
+ *   2007:forum::fÞr::umlÃĪute:2007
  *
  *   institute of electronic music and acoustics (iem)
  *
  ******************************************************
  *
- * license: GNU General Public License v.2
+ * license: GNU General Public License v.2 (or later)
  *
  ******************************************************/
 
@@ -27,7 +27,7 @@
  * abstraction that holds this object
  */
 
-#include "m_pd.h"
+#include "iemguts.h"
 #include "m_imp.h"
 #include "g_canvas.h"
 
@@ -150,6 +150,7 @@ static void *canvasindex_new(t_floatarg f)
 
 void canvasindex_setup(void)
 {
+  iemguts_boilerplate("[canvasindex]", 0);
   canvasindex_class = class_new(gensym("canvasindex"), 
                                 (t_newmethod)canvasindex_new, (t_method)canvasindex_free, 
                                 sizeof(t_canvasindex), 0, 
diff --git a/externals/iem/iemguts/src/canvasname.c b/externals/iem/iemguts/src/canvasname.c
index 9a469aa74..0f1356446 100644
--- a/externals/iem/iemguts/src/canvasname.c
+++ b/externals/iem/iemguts/src/canvasname.c
@@ -3,15 +3,15 @@
  *
  * canvasname - implementation file
  *
- * copyleft (c) IOhannes m zm-bölnig-A
+ * copyleft (c) IOhannes m zmÃķlnig
  *
- *   2007:forum::f-bür::umläute:2007-A
+ *   2007:forum::fÞr::umlÃĪute:2007
  *
  *   institute of electronic music and acoustics (iem)
  *
  ******************************************************
  *
- * license: GNU General Public License v.2
+ * license: GNU General Public License v.2 (or later)
  *
  ******************************************************/
 
@@ -32,7 +32,7 @@
  * nice, eh?
  */
 
-#include "m_pd.h"
+#include "iemguts.h"
 #include "g_canvas.h"
 
 
@@ -45,6 +45,9 @@ typedef struct _canvasname
   t_object  x_obj;
 
   t_canvas  *x_canvas;
+  t_outlet*x_nameout;
+  t_outlet*x_displaynameout;
+  t_inlet*x_displaynamein;
 } t_canvasname;
 
 
@@ -52,28 +55,31 @@ static void canvasname_bang(t_canvasname *x)
 {
   t_canvas*c=x->x_canvas;
   t_binbuf*b=0;
-  t_atom name[1];
 
-  if(!x->x_canvas) return;
-  b=x->x_canvas->gl_obj.te_binbuf;
+  if(!c) return;
+
+  if(c->gl_name)
+    outlet_symbol(x->x_displaynameout, c->gl_name);
+
+
+  b=c->gl_obj.te_binbuf;
+
   if(b) {
     /* get the binbufs atomlist */
     t_atom*ap=binbuf_getvec(b);
     t_symbol*s=atom_getsymbol(ap);
-    outlet_symbol(x->x_obj.ob_outlet, s);
-
-    return;
+    if(s)
+      outlet_symbol(x->x_nameout, s);
   } else {
-    //post("empty binbuf for %x", x->x_canvas);
+#if 0
+    post("empty binbuf for %x", x->x_canvas);
+#endif
   }
 }
 
 static void canvasname_symbol(t_canvasname *x, t_symbol*s)
 {
-  t_canvas*c=x->x_canvas;
   t_binbuf*b=0;
-  t_atom name[1];
-
   if(!x->x_canvas) return;
   b=x->x_canvas->gl_obj.te_binbuf;
 
@@ -85,9 +91,18 @@ static void canvasname_symbol(t_canvasname *x, t_symbol*s)
     return;
   }
 }
+static void canvasname_displayname(t_canvasname *x, t_symbol*s)
+{
+  t_canvas*c=x->x_canvas;
+  if(!c) return;
+  c->gl_name = s;
+}
 
 static void canvasname_free(t_canvasname *x)
 {
+  if(x->x_nameout  )outlet_free(x->x_nameout  );x->x_nameout=NULL  ;
+  if(x->x_displaynameout)outlet_free(x->x_displaynameout);x->x_displaynameout=NULL;
+  if(x->x_displaynamein )inlet_free (x->x_displaynamein );x->x_displaynamein=NULL;
 }
 
 static void *canvasname_new(t_floatarg f)
@@ -95,7 +110,6 @@ static void *canvasname_new(t_floatarg f)
   t_canvasname *x = (t_canvasname *)pd_new(canvasname_class);
   t_glist *glist=(t_glist *)canvas_getcurrent();
   t_canvas *canvas=(t_canvas*)glist_getcanvas(glist);
-
   int depth=(int)f;
   if(depth<0)depth=0;
 
@@ -106,15 +120,19 @@ static void *canvasname_new(t_floatarg f)
 
   x->x_canvas = canvas;
 
-  outlet_new(&x->x_obj, &s_symbol);
+  x->x_displaynamein=inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("symbol"), gensym("display"));
+  x->x_nameout=outlet_new(&x->x_obj, &s_symbol);
+  x->x_displaynameout=outlet_new(&x->x_obj, &s_symbol);
   
   return (x);
 }
 
 void canvasname_setup(void)
 {
+  iemguts_boilerplate("[canvasname]", 0);
   canvasname_class = class_new(gensym("canvasname"), (t_newmethod)canvasname_new,
                                (t_method)canvasname_free, sizeof(t_canvasname), 0, A_DEFFLOAT, 0);
   class_addsymbol(canvasname_class, (t_method)canvasname_symbol);
+  class_addmethod(canvasname_class, (t_method)canvasname_displayname, gensym("display"), A_SYMBOL, 0);
   class_addbang  (canvasname_class, (t_method)canvasname_bang);
 }
diff --git a/externals/iem/iemguts/src/canvasobjectposition.c b/externals/iem/iemguts/src/canvasobjectposition.c
index e51d89436..b7798a3e2 100644
--- a/externals/iem/iemguts/src/canvasobjectposition.c
+++ b/externals/iem/iemguts/src/canvasobjectposition.c
@@ -3,15 +3,15 @@
  *
  * canvasposition - implementation file
  *
- * copyleft (c) IOhannes m zmölnig
+ * copyleft (c) IOhannes m zmÃķlnig
  *
- *   2007:forum::für::umläute:2007
+ *   2007:forum::fÞr::umlÃĪute:2007
  *
  *   institute of electronic music and acoustics (iem)
  *
  ******************************************************
  *
- * license: GNU General Public License v.2
+ * license: GNU General Public License v.2 (or later)
  *
  ******************************************************/
 
@@ -27,7 +27,7 @@
  * abstraction within its canvas.
  */
 
-#include "m_pd.h"
+#include "iemguts.h"
 
 #include "g_canvas.h"
 #include "m_imp.h"
@@ -136,7 +136,7 @@ static void *canvasobjectposition_new(t_symbol*s, int argc, t_atom*argv)
 
     if(depth<0)depth=0;
 
-    post("depth=%d\tindex=%d", depth, index);
+    //post("depth=%d\tindex=%d", depth, index);
 
     while(depth && canvas) {
       canvas=canvas->gl_owner;
@@ -186,6 +186,7 @@ static void canvasobjectposition_object(t_canvasobjectposition *x, t_float f)
 
 void canvasobjectposition_setup(void)
 {
+  iemguts_boilerplate("[canvasobjectposition]", 0);
   canvasobjectposition_class = class_new(gensym("canvasobjectposition"), 
                                    (t_newmethod)canvasobjectposition_new, (t_method)canvasobjectposition_free, 
                                    sizeof(t_canvasobjectposition), 0,
diff --git a/externals/iem/iemguts/src/canvasposition.c b/externals/iem/iemguts/src/canvasposition.c
index d8685d8e4..b0821a03e 100644
--- a/externals/iem/iemguts/src/canvasposition.c
+++ b/externals/iem/iemguts/src/canvasposition.c
@@ -3,15 +3,15 @@
  *
  * canvasposition - implementation file
  *
- * copyleft (c) IOhannes m zmölnig
+ * copyleft (c) IOhannes m zmÃķlnig
  *
- *   2007:forum::für::umläute:2007
+ *   2007:forum::fÞr::umlÃĪute:2007
  *
  *   institute of electronic music and acoustics (iem)
  *
  ******************************************************
  *
- * license: GNU General Public License v.2
+ * license: GNU General Public License v.2 (or later)
  *
  ******************************************************/
 
@@ -27,7 +27,7 @@
  * abstraction within its canvas.
  */
 
-#include "m_pd.h"
+#include "iemguts.h"
 
 #include "g_canvas.h"
 #include "m_imp.h"
@@ -138,6 +138,7 @@ static void *canvasposition_new(t_floatarg f)
 
 void canvasposition_setup(void)
 {
+  iemguts_boilerplate("[canvasposition]", 0);
   canvasposition_class = class_new(gensym("canvasposition"), 
                                    (t_newmethod)canvasposition_new, (t_method)canvasposition_free, 
                                    sizeof(t_canvasposition), 0,
diff --git a/externals/iem/iemguts/src/canvasselect.c b/externals/iem/iemguts/src/canvasselect.c
index cc8bc2ab7..f68f4f56b 100644
--- a/externals/iem/iemguts/src/canvasselect.c
+++ b/externals/iem/iemguts/src/canvasselect.c
@@ -1,29 +1,32 @@
-
 /******************************************************
  *
  * canvasselect - implementation file
  *
- * copyleft (c) IOhannes m zmölnig
+ * copyleft (c) IOhannes m zmÃķlnig
  *
- *   2007:forum::für::umläute:2007
+ *   2007:forum::fÞr::umlÃĪute:2007
  *
  *   institute of electronic music and acoustics (iem)
  *
  ******************************************************
  *
- * license: GNU General Public License v.2
+ * license: GNU General Public License v.2 (or later)
  *
  ******************************************************/
 
 
-/* 
+/*
  * this object allows to select other objects on the canvas
  * it also allows to query the selection of the canvas
- * 
+ *
  * it also adds a "select" message to the canvas
+ *
+ * TODO:
+ *  - save selection to file
+ *  - patcherize selection
  */
 
-#include "m_pd.h"
+#include "iemguts.h"
 
 #include "g_canvas.h"
 
@@ -48,9 +51,8 @@ static void canvasselect_bang(t_canvasselect *x)
   if(NULL==glist) {
     return;
   }
-  t_atom selected_index;
   int nselected=0;
-  
+
   for(obj=glist->gl_list; obj; obj=obj->g_next, index++) {
     if(glist_isselected(glist, obj)) {
       // post("selected: %d", index);
@@ -60,16 +62,16 @@ static void canvasselect_bang(t_canvasselect *x)
   int n=0;
   index=0;
   t_atom *atombuf;
-  
-  atombuf = (t_atom *)getbytes(sizeof(t_atom)*nselected);
-  
+
+  atombuf = getbytes(nselected*sizeof(*atombuf));
+
   for(obj=glist->gl_list; obj; obj=obj->g_next, index++) {
     if(glist_isselected(glist, obj)) {
       SETFLOAT(&atombuf[n], index);
       n++;
     }
   }
-  
+
   outlet_list(x->x_obj.ob_outlet, &s_list, nselected, atombuf);
 }
 
@@ -104,7 +106,6 @@ static int canvasselect_doselect(t_glist*glist, int index)
 
 static void canvasselect_select(t_canvasselect*x, t_floatarg f)
 {
-  t_glist*glist=x->x_canvas;
   int i=f;
   if(canvasselect_doselect(x->x_canvas, i)<0) {
     pd_error(x, "invalid selection %d", i);
@@ -160,7 +161,6 @@ static int canvasselect_dodeselect(t_glist*glist, int index)
 
 static void canvasselect_deselect(t_canvasselect*x, t_floatarg f)
 {
-  t_glist*glist=x->x_canvas;
   int i=f;
   if(canvasselect_dodeselect(x->x_canvas, i)<0) {
     pd_error(x, "invalid deselection %d", i);
@@ -194,7 +194,7 @@ static void *canvasselect_new(t_floatarg f)
   t_glist *glist=(t_glist *)canvas_getcurrent();
   t_canvas *canvas=(t_canvas*)glist_getcanvas(glist);
   int depth=(int)f;
-  
+
   if(depth<0)depth=0;
 
   while(depth && canvas) {
@@ -203,14 +203,15 @@ static void *canvasselect_new(t_floatarg f)
   }
 
   x->x_canvas = canvas;
-  
+
+
   outlet_new(&x->x_obj, 0);
   return (x);
 }
 
 static void canvasselect_free(t_canvasselect*x)
 {
-
+  x->x_canvas = 0;
 }
 
 static void canvas_select_cb(t_canvas*x, t_float f)
@@ -245,8 +246,9 @@ static void register_methods(void)
 
 void canvasselect_setup(void)
 {
-  canvasselect_class = class_new(gensym("canvasselect"), 
-                                 (t_newmethod)canvasselect_new, (t_method)canvasselect_free, 
+  iemguts_boilerplate("[canvasselect] - (de)select messages for canvas", 0);
+  canvasselect_class = class_new(gensym("canvasselect"),
+                                 (t_newmethod)canvasselect_new, (t_method)canvasselect_free,
                                  sizeof(t_canvasselect), 0,
                                  A_DEFFLOAT, 0);
   class_addbang(canvasselect_class, (t_method)canvasselect_bang);
diff --git a/externals/iem/iemguts/src/classtest.c b/externals/iem/iemguts/src/classtest.c
index 76f1269da..bb4183efa 100644
--- a/externals/iem/iemguts/src/classtest.c
+++ b/externals/iem/iemguts/src/classtest.c
@@ -3,15 +3,15 @@
  *
  * classtest - implementation file
  *
- * copyleft (c) IOhannes m zmölnig
+ * copyleft (c) IOhannes m zmÃķlnig
  *
- *   2007:forum::für::umläute:2007
+ *   2007:forum::fÞr::umlÃĪute:2007
  *
  *   institute of electronic music and acoustics (iem)
  *
  ******************************************************
  *
- * license: GNU General Public License v.2
+ * license: GNU General Public License v.2 (or later)
  *
  ******************************************************/
 
@@ -23,7 +23,7 @@
  * e.g. [classtest 1] will send messages to the parent of the containing canvas
  */
 
-#include "m_pd.h"
+#include "iemguts.h"
 #include "g_canvas.h"
 
 int glist_getindex(t_glist *x, t_gobj *y);
@@ -59,7 +59,7 @@ static void classtest_free(t_classtest *x)
   outlet_free(x->x_out);
 }
 
-static void *classtest_new(t_floatarg f)
+static void *classtest_new(void)
 {
   t_classtest *x = (t_classtest *)pd_new(classtest_class);
 
@@ -69,6 +69,7 @@ static void *classtest_new(t_floatarg f)
 
 void classtest_setup(void)
 {
+  iemguts_boilerplate("[classtest]", 0);
   classtest_class = class_new(gensym("classtest"), (t_newmethod)classtest_new,
                                (t_method)classtest_free, sizeof(t_classtest), 0, 
                               0);
diff --git a/externals/iem/iemguts/src/closebang.c.disabled b/externals/iem/iemguts/src/closebang.c.disabled
new file mode 100644
index 000000000..eae9b1c13
--- /dev/null
+++ b/externals/iem/iemguts/src/closebang.c.disabled
@@ -0,0 +1,73 @@
+/******************************************************
+ *
+ * closebang - implementation file
+ *
+ * copyleft (c) IOhannes m zmÃķlnig
+ *
+ *   1901:forum::fÞr::umlÃĪute:2016
+ *
+ *   institute of electronic music and acoustics (iem)
+ *
+ ******************************************************
+ *
+ * license: GNU General Public License v.2 (or later)
+ *
+ ******************************************************/
+
+
+/*
+ * this object send out a bang when an abstraction was loaded
+ * (but before the parent abstraction continues to load)
+ * usage:
+ *   + it can be used to create abstractions with dynamic numbers of iolets
+ * nice, eh?
+ */
+
+
+#include "iemguts.h"
+
+/* need g_canvas.h for loadbang-actions */
+#include "g_canvas.h"
+
+#ifndef LB_CLOSE
+# warning compiling against a version of Pd without closebang support
+# define LB_CLOSE 2
+#endif
+
+
+/* ------------------------- closebang ---------------------------- */
+
+static t_class *closebang_class;
+
+typedef struct _closebang
+{
+  t_object  x_obj;
+} t_closebang;
+
+
+static void closebang_loadbang(t_closebang *x, t_float type) {
+  if(LB_CLOSE == (int)type)
+    outlet_bang(x->x_obj.ob_outlet);
+}
+
+static void *closebang_new(void)
+{
+  t_closebang *x = (t_closebang *)pd_new(closebang_class);
+  outlet_new(&x->x_obj, &s_bang);
+  return (x);
+}
+
+void closebang_setup(void)
+{
+  iemguts_boilerplate("[closebang]", 0);
+#if (PD_MINOR_VERSION < 47)
+  verbose(0, "[closebang] has been compiled against an incompatible version of Pd, proceeding anyway...");
+#endif
+  closebang_class = class_new(gensym("closebang"), (t_newmethod)closebang_new, 0,
+			     sizeof(t_closebang), CLASS_NOINLET, 0);
+
+  if(iemguts_check_atleast_pdversion(0,47,0))
+    class_addmethod(closebang_class, (t_method)closebang_loadbang, gensym("loadbang"), A_DEFFLOAT, 0);
+  else
+    error("[closebang] requires Pd>=0.47");
+}
diff --git a/externals/iem/iemguts/src/findbrokenobjects.c b/externals/iem/iemguts/src/findbrokenobjects.c
new file mode 100644
index 000000000..1bef9eeb6
--- /dev/null
+++ b/externals/iem/iemguts/src/findbrokenobjects.c
@@ -0,0 +1,230 @@
+
+/******************************************************
+ *
+ * findbrokenobjects - implementation file
+ *
+ * copyleft (c) IOhannes m zmÃķlnig
+ *
+ *   2007:forum::fÞr::umlÃĪute:2007
+ *
+ *   institute of electronic music and acoustics (iem)
+ *
+ ******************************************************
+ *
+ * license: GNU General Public License v.2 (or later)
+ *
+ ******************************************************/
+
+
+/*
+ * find broken objects (objects that could not be created)
+ * these objects are of class 'text_class'
+
+ objsrc = pd_checkobject(&src->g_pd);
+ if (objsrc && pd_class(&src->g_pd) == text_class && objsrc->te_type == T_OBJECT) {
+   // 'src' is a broken object
+ }
+
+TODO:
+ - output more data: canvas and object-ID
+ */
+
+#include "iemguts.h"
+#include "g_canvas.h"
+#include "m_imp.h"
+
+#include <string.h>
+
+int glist_getindex(t_glist *x, t_gobj *y);
+
+/* ------------------------- findbrokenobjects ---------------------------- */
+
+static t_class *findbrokenobjects_class;
+
+typedef struct _findbrokenobjects
+{
+  t_object  x_obj;
+  t_outlet *x_out;
+  t_canvas *x_parent;   // the canvas we are acting on
+
+  int       x_verbose;
+} t_findbrokenobjects;
+
+extern t_class *text_class;
+extern t_class *canvas_class;
+
+static void print_obj(const char*prefix, t_object *obj) {
+  int ntxt;
+  char *txt;
+  t_binbuf*bb=obj->te_binbuf;
+  binbuf_gettext(bb, &txt, &ntxt);
+  pd_error(obj, "%s%p\t%s", prefix, obj, txt);
+}
+
+static void findbrokenobjects_doit(t_canvas*cnv) {
+  t_gobj*src;
+  for (src = cnv->gl_list; src; src = src->g_next) { /* traverse all objects in canvas */
+    t_object*obj=pd_checkobject(&src->g_pd);
+    if (obj && (pd_class(&src->g_pd) == text_class && obj->te_type == T_OBJECT)) {
+      // found broken object
+      print_obj("broken:\t", obj);
+    }
+  }
+}
+
+static int fbo_has_ctor(t_atom*ab) {
+  t_symbol*s=(ab&&pd_objectmaker)?atom_getsymbol(ab):0;
+  if(!s)
+    return 0;
+  if(zgetfn(&pd_objectmaker, s))
+    return 1;
+  return 0;
+}
+
+static void fbo_iterate(t_findbrokenobjects*x, t_canvas*cnv, int verbose) {
+  // iterate over all top-level canvases
+  if(!(cnv && cnv->gl_name && cnv->gl_name->s_name))
+    return;
+  t_gobj*g=0;
+  int count=0;
+
+  for(g=cnv->gl_list;g;g=g->g_next) {
+    // iterate over all objects on the canvas
+    t_object*ob=pd_checkobject(&g->g_pd);
+    t_class*cls=0;
+    count++;
+
+    if(!(ob && ob->te_type == T_OBJECT))
+      continue;
+
+    cls=pd_class(&g->g_pd);
+    if (cls == canvas_class) {
+      // this is just another abstraction, recurse into it
+      fbo_iterate(x, ob, verbose);
+    } else if (cls == text_class) {
+      t_binbuf*bb=ob->te_binbuf;
+      t_atom*argv=binbuf_getvec(bb);
+      int argc=binbuf_getnatom(bb);
+      /* broken object */
+      if(verbose) {
+	int ntxt;
+	char *txt;
+	binbuf_gettext(bb, &txt, &ntxt);
+	pd_error(ob, "[%s] broken object!", txt);
+	freebytes(txt, ntxt);
+      }
+      //post("%s %d", cnv->gl_name->s_name, count);
+      if(argc && fbo_has_ctor(argv)) {
+	outlet_anything(x->x_out, gensym("not-created"), argc, argv);
+      } else {
+	outlet_anything(x->x_out, gensym("not-found"), argc, argv);
+      }
+    }
+  }
+}
+
+static void findbrokenobjects_iterate(t_findbrokenobjects *x, int verbose) {
+  // find all broken objects in the current patch
+  if(x->x_parent) {
+    fbo_iterate(x, x->x_parent, verbose);
+  } else {
+    t_canvas *c;
+    for (c = pd_getcanvaslist(); c; c = c->gl_next) {
+      const char*name=c->gl_name->s_name;
+      /* only allow names ending with '.pd'
+       * (reject template canvases)
+       */
+      int len=strlen(name);
+      const char*exclude_name;
+      int exclude=1;
+      for(exclude_name="etalpmet_"; *exclude_name && len; len--, exclude_name++) {
+	if(*exclude_name != name[len-1]) {
+	  exclude=0;
+	  break;
+	}
+      }
+      if(!exclude){
+	fbo_iterate(x, c, verbose);
+      }// else post("canvas: %s", name);
+    }
+  }
+}
+
+static void findbrokenobjects_bang(t_findbrokenobjects *x) {
+  findbrokenobjects_iterate(x, x->x_verbose);
+}
+static void findbrokenobjects_verbose(t_findbrokenobjects *x, t_float f) {
+  x->x_verbose=(int)f;
+}
+
+static void findbrokenobjects_free(t_findbrokenobjects *x)
+{
+  outlet_free(x->x_out);
+}
+
+static void *findbrokenobjects_new(t_symbol*s, int argc, t_atom*argv)
+{
+  t_findbrokenobjects *x = (t_findbrokenobjects *)pd_new(findbrokenobjects_class);
+  x->x_parent=0;
+  if(argc==1 && argv->a_type == A_FLOAT) {
+    int depth=atom_getint(argv);
+    t_glist *glist=(t_glist *)canvas_getcurrent();
+    if(depth>=0) {
+      t_canvas *canvas=(t_canvas*)glist_getcanvas(glist);
+      while(depth && canvas) {
+	canvas=canvas->gl_owner;
+	depth--;
+      }
+      if(canvas)
+	x->x_parent = canvas;
+    }
+  }
+  x->x_verbose=0;
+
+  x->x_out = outlet_new(&x->x_obj, 0);
+  return (x);
+}
+
+static char fbo_file[];
+static void fbo_persist(void) {
+  static t_pd*fbo_canvas=0;
+  if(fbo_canvas)
+    return;
+
+
+  t_binbuf *b = binbuf_new();
+  glob_setfilename(0, gensym("_deken_workspace"), gensym("."));
+  binbuf_text(b, fbo_file, strlen(fbo_file));
+  binbuf_eval(b, &pd_canvasmaker, 0, 0);
+  fbo_canvas = s__X.s_thing;
+  vmess(s__X.s_thing, gensym("pop"), "i", 0);
+  glob_setfilename(0, &s_, &s_);
+  binbuf_free(b);
+}
+
+void findbrokenobjects_setup(void)
+{
+  iemguts_boilerplate("[findbrokenobjects]", 0);
+  findbrokenobjects_class = class_new(gensym("findbrokenobjects"), (t_newmethod)findbrokenobjects_new,
+				     (t_method)findbrokenobjects_free, sizeof(t_findbrokenobjects), 0,
+				     A_GIMME, 0);
+  class_addbang  (findbrokenobjects_class, (t_method)findbrokenobjects_bang);
+  class_addmethod(findbrokenobjects_class, (t_method)findbrokenobjects_verbose, gensym("verbose"), A_FLOAT, 0);
+
+  if(0)
+    fbo_persist();
+}
+static char fbo_file[] = "\
+canvas 0 0 300 200;\n\
+#X obj 20 20 receive __deken_findbroken_objects;\n\
+#X obj 20 60 findbrokenobjects;\n\
+#X obj 20 80 list prepend plugin-dispatch deken;\n\
+#X msg 20 40 unique;\n\
+#X obj 20 100 list trim;\n\
+#X obj 20 120 s pd;\n\
+#X connect 0 0 3 0;\n\
+#X connect 1 0 2 0;\n\
+#X connect 2 0 4 0;\n\
+#X connect 3 0 1 0;\n\
+#X connect 4 0 5 0;\n\
+";
diff --git a/externals/iem/iemguts/src/iemguts-objlist.h b/externals/iem/iemguts/src/iemguts-objlist.h
index fedfdf103..b54d23a98 100644
--- a/externals/iem/iemguts/src/iemguts-objlist.h
+++ b/externals/iem/iemguts/src/iemguts-objlist.h
@@ -4,17 +4,17 @@
  *
  * copyleft (c) IOhannes m zmölnig
  *
- *   2008:forum::für::umläute:2008
+ *   2008:forum::für::umläute:2015
  *
  *   institute of electronic music and acoustics (iem)
  *
  ******************************************************
  *
- * license: GNU General Public License v.2
+ * license: GNU General Public License v.2 (or later)
  *
  ******************************************************/
 
-/* this file implements some helperr functions for dealing with lists of
+/* this file implements some helper functions for dealing with lists of
  * objects (containing other objects)
  *
  * used for callbacks to enumerated objects without $0 tricks
@@ -24,7 +24,9 @@
  * TODO: documentation
  */
 
-#include "m_pd.h"
+#ifndef INCLUDE_IEMGUTS_OBJECTLIST_H_
+#define INCLUDE_IEMGUTS_OBJECTLIST_H_
+#include "iemguts.h"
 
 
 /* ------------------------- helper methods for callbacks ---------------------------- */
@@ -61,7 +63,7 @@ static t_iemguts_canvaslist*addCanvas(const t_pd*parent)
 {
   t_iemguts_canvaslist*list=findCanvas(parent);
   if(!list) {
-    list=(t_iemguts_canvaslist*)getbytes(sizeof(t_iemguts_canvaslist));
+    list=getbytes(sizeof(*list));
     list->parent=parent;
     list->obj=0;
     list->next=0;
@@ -106,7 +108,7 @@ static void addObjectToCanvas(const t_pd*parent, const t_pd*obj) {
   }
 
   /* we are at the end of the list that does not contain obj yet, so add it */
-  entry=(t_iemguts_objlist*)getbytes(sizeof(t_iemguts_objlist));
+  entry=getbytes(sizeof(*entry));
   entry->obj=obj;
   entry->next=0;
   if(list) {
@@ -139,7 +141,7 @@ static void removeObjectFromCanvas(const t_pd*parent, const t_pd*obj) {
   else
     p->obj=next;
 
-  freebytes((void*)list, sizeof(t_iemguts_objlist));
+  freebytes(list, sizeof(*list));
   list=0;
 }
 
@@ -150,4 +152,5 @@ static void removeObjectFromCanvases(const t_pd*obj) {
     removeObjectFromCanvas(parents->parent, obj);
     parents=parents->next;
   }
+#endif /* INCLUDE_IEMGUTS_OBJECTLIST_H_ */
 }
diff --git a/externals/iem/iemguts/src/iemguts.h b/externals/iem/iemguts/src/iemguts.h
new file mode 100644
index 000000000..d2da38858
--- /dev/null
+++ b/externals/iem/iemguts/src/iemguts.h
@@ -0,0 +1,86 @@
+/******************************************************
+ *
+ * iemguts - implementation file
+ *
+ * copyleft (c) IOhannes m zmÃķlnig
+ *
+ *   2008:forum::fÞr::umlÃĪute:2015
+ *
+ *   institute of electronic music and acoustics (iem)
+ *
+ ******************************************************
+ *
+ * license: GNU General Public License v.2 (or later)
+ *
+ ******************************************************/
+
+/* generic include header for iemguts
+ * includes other necessary files (m_pd.h)
+ * and provides boilerplate functions/macros
+ */
+
+#ifndef INCLUDE_IEMGUTS_H_
+#define INCLUDE_IEMGUTS_H_
+
+#include "m_pd.h"
+
+#ifdef STRINGIFY
+# undef STRINGIFY
+#endif
+#define IEMGUTS_STRINGIFY_AUX(s) #s
+#define STRINGIFY(s) IEMGUTS_STRINGIFY_AUX(s)
+
+#ifndef BUILD_DATE
+# define BUILD_DATE "on " __DATE__ " at " __TIME__
+#endif
+
+
+/*
+ * check whether we run at least a given Pd-version
+ */
+static int iemguts_check_atleast_pdversion(int major, int minor, int bugfix) {
+  int got_major=0, got_minor=0, got_bugfix=0;
+  sys_getversion(&got_major, &got_minor, &got_bugfix);
+#pragma push_macro("cmpver_")
+#ifdef cmpver_
+# undef cmpver_
+#endif
+#define cmpver_(got, want)  if(got < want)return 0; else if (got > want)return 1;
+  cmpver_(got_major , major );
+  cmpver_(got_minor , minor );
+  cmpver_(got_bugfix, bugfix);
+  return 1;
+#pragma pop_macro("cmpver_")
+}
+
+/**
+ * print some boilerplate about when the external was compiled
+ * and against which version of Pd
+ */
+static void iemguts_boilerplate(const char*name, const char*copyright) {
+  const int v=0;
+  if(name && *name) {
+#ifdef VERSION
+    verbose(v, "%s " STRINGIFY(VERSION), name);
+#else
+    verbose(v, "%s", name);
+#endif
+    /* if copyright is NULL, assume default; if it's empty skip it */
+    if(!copyright)
+      copyright="IOhannes m zmÃķlnig, IEM <zmoelnig@iem.at>";
+    if(*copyright)
+      verbose(v, "\tÂĐ %s", copyright);
+
+  verbose(v, "\tcompiled "BUILD_DATE);
+  if(*PD_TEST_VERSION)
+    verbose(v, "\t         against Pd version %d.%d-%d (%s)",
+	 PD_MAJOR_VERSION, PD_MINOR_VERSION, PD_BUGFIX_VERSION,
+	 PD_TEST_VERSION);
+  else
+    verbose(v, "\t         against Pd version %d.%d-%d",
+	 PD_MAJOR_VERSION, PD_MINOR_VERSION, PD_BUGFIX_VERSION);
+  if(!iemguts_check_atleast_pdversion(PD_MAJOR_VERSION, PD_MINOR_VERSION, PD_BUGFIX_VERSION))
+    verbose(v, "\tNOTE: you are running an older version of Pd!");
+  }
+}
+#endif /* INCLUDE_IEMGUTS_H_ */
diff --git a/externals/iem/iemguts/src/initbang.c.disabled b/externals/iem/iemguts/src/initbang.c.disabled
new file mode 100644
index 000000000..35631102b
--- /dev/null
+++ b/externals/iem/iemguts/src/initbang.c.disabled
@@ -0,0 +1,74 @@
+/******************************************************
+ *
+ * initbang - implementation file
+ *
+ * copyleft (c) IOhannes m zmÃķlnig
+ *
+ *   1901:forum::fÞr::umlÃĪute:2016
+ *
+ *   institute of electronic music and acoustics (iem)
+ *
+ ******************************************************
+ *
+ * license: GNU General Public License v.2 (or later)
+ *
+ ******************************************************/
+
+
+/*
+ * this object send out a bang when an abstraction was loaded
+ * (but before the parent abstraction continues to load)
+ * usage:
+ *   + it can be used to create abstractions with dynamic numbers of iolets
+ * nice, eh?
+ */
+
+
+#include "iemguts.h"
+
+/* need g_canvas.h for loadbang-actions */
+#include "g_canvas.h"
+
+#ifndef LB_INIT
+# warning compiling against a version of Pd without initbang support
+# define LB_INIT 1
+# define LB_CLOSE 2
+#endif
+
+
+/* ------------------------- initbang ---------------------------- */
+
+static t_class *initbang_class;
+
+typedef struct _initbang
+{
+  t_object  x_obj;
+} t_initbang;
+
+
+static void initbang_loadbang(t_initbang *x, t_float type) {
+  if(LB_INIT == (int)type)
+    outlet_bang(x->x_obj.ob_outlet);
+}
+
+static void *initbang_new(void)
+{
+  t_initbang *x = (t_initbang *)pd_new(initbang_class);
+  outlet_new(&x->x_obj, &s_bang);
+  return (x);
+}
+
+void initbang_setup(void)
+{
+  iemguts_boilerplate("[initbang]", 0);
+#if (PD_MINOR_VERSION < 47)
+  verbose(0, "[initbang] has been compiled against an incompatible version of Pd, proceeding anyway...");
+#endif
+  initbang_class = class_new(gensym("initbang"), (t_newmethod)initbang_new, 0,
+			     sizeof(t_initbang), CLASS_NOINLET, 0);
+
+  if(iemguts_check_atleast_pdversion(0,47,0))
+    class_addmethod(initbang_class, (t_method)initbang_loadbang, gensym("loadbang"), A_DEFFLOAT, 0);
+  else
+    error("[initbang] requires Pd>=0.47");
+}
diff --git a/externals/iem/iemguts/src/oreceive.c b/externals/iem/iemguts/src/oreceive.c
index 5109f4b32..8c4c4b19f 100644
--- a/externals/iem/iemguts/src/oreceive.c
+++ b/externals/iem/iemguts/src/oreceive.c
@@ -3,29 +3,29 @@
  *
  * oreceive - implementation file
  *
- * copyleft (c) IOhannes m zmölnig
+ * copyleft (c) IOhannes m zmÃķlnig
  *
- *   2307:forum::für::umläute:2008
+ *   2307:forum::fÞr::umlÃĪute:2008
  *
  *   institute of electronic music and acoustics (iem)
  *   unsiversity of music and dramatic arts graz (kug)
  *
  ******************************************************
  *
- * license: GNU General Public License v.2
+ * license: GNU General Public License v.2 (or later)
  *
  ******************************************************/
 
 
-#include "m_pd.h"
+#include "iemguts.h"
 
 #if 0
 # define debug_post post
 #else
-# define debug_post
+static void debug_post(const char *fmt, ...) {;}
 #endif
 
-static t_class *oreceive_class, *oreceive_proxy_class, *oreceive_guts_class;
+static t_class *oreceive_class, *oreceive_proxy_class;
 
 
 /* ------------------------------------------------------------- */
@@ -151,7 +151,7 @@ static void pd_bind_priority(t_pd*x, t_symbol*key, t_float priority) {
     bind_list=guts_add_key(key);
   if(!bind_list)return;
 
-  element=(t_bind_element*)getbytes(sizeof(t_bind_element));
+  element=getbytes(sizeof(*element));
   element->object=x;
   element->priority=priority;
   element->next=0;
@@ -187,7 +187,7 @@ static void pd_unbind_priority(t_pd*x, t_symbol*key) {
     elements->priority=0;
     elements->next=0;
 
-    freebytes(elements, sizeof(elements));
+    freebytes(elements, sizeof(*elements));
   } else {
     // not here...
   }
@@ -248,8 +248,8 @@ static void oreceive_priority(t_oreceive *x, t_float p)
   x->x_priority=p;
   if(x->x_sym) {
     pd_unbind_priority(&x->x_obj.ob_pd, x->x_sym);
+    pd_bind_priority(&x->x_obj.ob_pd, x->x_sym, x->x_priority);
   }
-  pd_bind_priority(&x->x_obj.ob_pd, x->x_sym, x->x_priority);
 }
 
 static void oreceive_name(t_oreceive *x, t_symbol*s)
@@ -283,6 +283,7 @@ static void oreceive_free(t_oreceive *x)
 
 void oreceive_setup(void)
 {
+    iemguts_boilerplate("[oreceive] (ordered receive)", 0);
     oreceive_class = class_new(gensym("oreceive"), (t_newmethod)oreceive_new, 
                                (t_method)oreceive_free, sizeof(t_oreceive), CLASS_NOINLET, A_DEFSYM, A_DEFFLOAT, 0);
     class_addcreator((t_newmethod)oreceive_new, gensym("r"), A_DEFSYM, A_DEFFLOAT, 0);
diff --git a/externals/iem/iemguts/src/propertybang.c b/externals/iem/iemguts/src/propertybang.c
index 79b921fc8..7b712ca96 100644
--- a/externals/iem/iemguts/src/propertybang.c
+++ b/externals/iem/iemguts/src/propertybang.c
@@ -3,15 +3,15 @@
  *
  * propertybang - implementation file
  *
- * copyleft (c) IOhannes m zmölnig
+ * copyleft (c) IOhannes m zmÃķlnig
  *
- *   2007:forum::für::umläute:2010
+ *   2007:forum::fÞr::umlÃĪute:2010
  *
  *   institute of electronic music and acoustics (iem)
  *
  ******************************************************
  *
- * license: GNU General Public License v.2
+ * license: GNU General Public License v.2 (or later)
  *
  ******************************************************/
 
@@ -87,6 +87,7 @@ static void *propertybang_new(void)
 
 void propertybang_setup(void)
 {
+  iemguts_boilerplate("[propertybang]", 0);
   propertybang_class = class_new(gensym("propertybang"), (t_newmethod)propertybang_new,
     (t_method)propertybang_free, sizeof(t_propertybang), CLASS_NOINLET, 0);
   class_addbang(propertybang_class, propertybang_bang);
diff --git a/externals/iem/iemguts/src/receivecanvas.c b/externals/iem/iemguts/src/receivecanvas.c
index b545e78bb..96b3e55dc 100644
--- a/externals/iem/iemguts/src/receivecanvas.c
+++ b/externals/iem/iemguts/src/receivecanvas.c
@@ -3,15 +3,15 @@
  *
  * receivecanvas - implementation file
  *
- * copyleft (c) 2009, IOhannes m zmölnig
+ * copyleft (c) 2009, IOhannes m zmÃķlnig
  *
- *   forum::für::umläute
+ *   forum::fÞr::umlÃĪute
  *
  *   institute of electronic music and acoustics (iem)
  *
  ******************************************************
  *
- * license: GNU General Public License v.2
+ * license: GNU General Public License v.2 (or later)
  *
  ******************************************************/
 
@@ -30,21 +30,68 @@
  *  currently this objects only gets the messages from typedmess()...
  */
 
-#include "m_pd.h"
+#include "iemguts.h"
 #include "g_canvas.h"
 
 #include <stdio.h>
 
-/* ------------------------- receivecanvas ---------------------------- */
+static t_class *receivecanvas_class, *receivecanvas_proxy_class;
 
-static t_class *receivecanvas_class;
+typedef struct _receivecanvas_proxy
+{
+  t_object p_obj;
+  t_symbol*p_sym;
+  t_clock *p_clock;
+  struct _receivecanvas*p_parent;
+} t_receivecanvas_proxy;
 
 typedef struct _receivecanvas
 {
-  t_object  x_obj;
-  t_symbol  *x_sym;
+  t_object x_obj;
+  t_receivecanvas_proxy*x_proxy;
 } t_receivecanvas;
 
+/* ------------------------- receivecanvas proxy ---------------------------- */
+
+static void receivecanvas_anything(t_receivecanvas *x, t_symbol*s, int argc, t_atom*argv);
+
+static void receivecanvas_proxy_anything(t_receivecanvas_proxy *p, t_symbol*s, int argc, t_atom*argv) {
+  if(p->p_parent)
+    receivecanvas_anything(p->p_parent, s, argc, argv);
+}
+static void receivecanvas_proxy_free(t_receivecanvas_proxy *p)
+{
+  if(p->p_sym)
+    pd_unbind(&p->p_obj.ob_pd, p->p_sym);
+  p->p_sym=NULL;
+
+  clock_free(p->p_clock);
+  p->p_clock=NULL;
+
+  p->p_parent=NULL;
+  pd_free(&p->p_obj.ob_pd);
+
+  p=NULL;
+}
+static t_receivecanvas_proxy*receivecanvas_proxy_new(t_receivecanvas *x, t_symbol*s) {
+  t_receivecanvas_proxy*p=NULL;
+
+  if(!x) return p;
+
+  p=(t_receivecanvas_proxy*)pd_new(receivecanvas_proxy_class);
+
+  p->p_sym=s;
+  if(p->p_sym) {
+    pd_bind(&p->p_obj.ob_pd, p->p_sym);
+  }
+  p->p_parent=x;
+  p->p_clock=clock_new(p, (t_method)receivecanvas_proxy_free);
+
+  return p;
+}
+
+
+/* ------------------------- receivecanvas ---------------------------- */
 static void receivecanvas_anything(t_receivecanvas *x, t_symbol*s, int argc, t_atom*argv)
 {
   outlet_anything(x->x_obj.ob_outlet, s, argc, argv);
@@ -52,8 +99,10 @@ static void receivecanvas_anything(t_receivecanvas *x, t_symbol*s, int argc, t_a
 
 static void receivecanvas_free(t_receivecanvas *x)
 {
-  if(x->x_sym)
-    pd_unbind(&x->x_obj.ob_pd, x->x_sym);
+  if(x->x_proxy) {
+    x->x_proxy->p_parent = NULL;
+    clock_delay(x->x_proxy->p_clock, 0);
+  }
 }
 
 static void *receivecanvas_new(t_floatarg f)
@@ -69,15 +118,14 @@ static void *receivecanvas_new(t_floatarg f)
     depth--;
   }
 
-  x->x_sym=NULL;
+  x->x_proxy=NULL;
 
   if(canvas) {
-    char buf[40];
-    snprintf(buf, 40, ".x%lx", (t_int)canvas);
-    x->x_sym=gensym(buf);
-
-    pd_bind(&x->x_obj.ob_pd, x->x_sym);
+    char buf[MAXPDSTRING];
+    snprintf(buf, MAXPDSTRING-1, ".x%lx", (t_int)canvas);
+    buf[MAXPDSTRING-1]=0;
 
+    x->x_proxy=receivecanvas_proxy_new(x, gensym(buf));
   }
 
   outlet_new(&x->x_obj, 0);
@@ -87,7 +135,10 @@ static void *receivecanvas_new(t_floatarg f)
 
 void receivecanvas_setup(void)
 {
+  iemguts_boilerplate("[receivecanvas]", 0);
   receivecanvas_class = class_new(gensym("receivecanvas"), (t_newmethod)receivecanvas_new,
                                (t_method)receivecanvas_free, sizeof(t_receivecanvas), CLASS_NOINLET, A_DEFFLOAT, 0);
-  class_addanything(receivecanvas_class, (t_method)receivecanvas_anything);
+
+  receivecanvas_proxy_class = class_new(0, 0, 0, sizeof(t_receivecanvas_proxy), CLASS_NOINLET | CLASS_PD, 0);
+  class_addanything(receivecanvas_proxy_class, receivecanvas_proxy_anything);
 }
diff --git a/externals/iem/iemguts/src/savebangs.c b/externals/iem/iemguts/src/savebangs.c
index 0704bfba8..491a25a41 100644
--- a/externals/iem/iemguts/src/savebangs.c
+++ b/externals/iem/iemguts/src/savebangs.c
@@ -3,15 +3,15 @@
  *
  * propertybang - implementation file
  *
- * copyleft (c) IOhannes m zmölnig
+ * copyleft (c) IOhannes m zmÃķlnig
  *
- *   2007:forum::für::umläute:2007
+ *   2007:forum::fÞr::umlÃĪute:2007
  *
  *   institute of electronic music and acoustics (iem)
  *
  ******************************************************
  *
- * license: GNU General Public License v.2
+ * license: GNU General Public License v.2 (or later)
  *
  ******************************************************/
 
@@ -67,7 +67,7 @@ static void add_savefn(t_class*class)
   if(0!=find_savefn(class)) {
     return;
   } else {
-    t_savefuns*sfun=(t_savefuns*)getbytes(sizeof(t_savefuns));
+    t_savefuns*sfun=getbytes(sizeof(*sfun));
     sfun->class=class;
     sfun->savefn=class_getsavefn(class);
     sfun->next=0;
@@ -97,7 +97,7 @@ static void orig_savefn(t_gobj*z, t_binbuf*b)
 static void savebangs_bangem(t_iemguts_objlist*objs, int pst);
 static void savebangs_savefn(t_gobj*z, t_binbuf*b) {
   /* z is the parent abstraction;
-   * we maintain a list of all [savebangs] within such each parent, in order to call all of them 
+   * we maintain a list of all [savebangs] within a parent, in order to call all of them 
    */
   t_iemguts_objlist*obj=objectsInCanvas((t_pd*)z);
   savebangs_bangem(obj, 0);
@@ -184,6 +184,7 @@ static void savebangs_free(t_savebangs *x)
 
 void savebangs_setup(void)
 {
+  iemguts_boilerplate("[savebangs]", 0);
   savebangs_class = class_new(gensym("savebangs"), (t_newmethod)savebangs_new,
                               (t_method)savebangs_free, sizeof(t_savebangs), CLASS_NOINLET, A_DEFFLOAT, 0);
   add_savefn(savebangs_class);
diff --git a/externals/iem/iemguts/src/sendcanvas.c b/externals/iem/iemguts/src/sendcanvas.c
index 51d7f779b..01da06681 100644
--- a/externals/iem/iemguts/src/sendcanvas.c
+++ b/externals/iem/iemguts/src/sendcanvas.c
@@ -3,15 +3,15 @@
  *
  * sendcanvas - implementation file
  *
- * copyleft (c) IOhannes m zmölnig
+ * copyleft (c) IOhannes m zmÃķlnig
  *
- *   2007:forum::für::umläute:2007
+ *   2007:forum::fÞr::umlÃĪute:2007
  *
  *   institute of electronic music and acoustics (iem)
  *
  ******************************************************
  *
- * license: GNU General Public License v.2
+ * license: GNU General Public License v.2 (or later)
  *
  ******************************************************/
 
@@ -23,7 +23,7 @@
  * e.g. [sendcanvas 1] will send messages to the parent of the containing canvas
  */
 
-#include "m_pd.h"
+#include "iemguts.h"
 #include "g_canvas.h"
 
 int glist_getindex(t_glist *x, t_gobj *y);
@@ -70,6 +70,7 @@ static void *sendcanvas_new(t_floatarg f)
 
 void sendcanvas_setup(void)
 {
+  iemguts_boilerplate("[sendcanvas]", 0);
   sendcanvas_class = class_new(gensym("sendcanvas"), (t_newmethod)sendcanvas_new,
                                (t_method)sendcanvas_free, sizeof(t_sendcanvas), 0, A_DEFFLOAT, 0);
   class_addanything(sendcanvas_class, (t_method)sendcanvas_anything);
diff --git a/externals/iem/iemguts/src/try.c b/externals/iem/iemguts/src/try.c
index 97feaa3ef..c7715549b 100644
--- a/externals/iem/iemguts/src/try.c
+++ b/externals/iem/iemguts/src/try.c
@@ -3,15 +3,15 @@
  *
  * try - implementation file
  *
- * copyleft (c) IOhannes m zmölnig
+ * copyleft (c) IOhannes m zmÃķlnig
  *
- *   2007:forum::für::umläute:2007
+ *   2007:forum::fÞr::umlÃĪute:2007
  *
  *   institute of electronic music and acoustics (iem)
  *
  ******************************************************
  *
- * license: GNU General Public License v.2
+ * license: GNU General Public License v.2 (or later)
  *
  ******************************************************/
 
@@ -24,7 +24,7 @@
  * currently this doesn't work (well) with [list]  
  */
 
-#include "m_pd.h"
+#include "iemguts.h"
 #include "g_canvas.h"
 
 int glist_getindex(t_glist *x, t_gobj *y);
@@ -86,6 +86,7 @@ static void *try_new(t_symbol*s, int argc, t_atom*argv)
 
 void try_setup(void)
 {
+  iemguts_boilerplate("[try]", 0);
   try_class = class_new(gensym("try"), 
 			(t_newmethod)try_new, NULL, 
 			sizeof(t_try), 0, 
-- 
GitLab