aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorThomas Grill <xovo@users.sourceforge.net>2006-01-28 10:36:25 +0000
committerThomas Grill <xovo@users.sourceforge.net>2006-01-28 10:36:25 +0000
commit2147d5f788d36ebccb7981c427b7e430b1e4e8cd (patch)
tree240e2edded8005157f9949476043435a3f0ee79e
parent4c9cf49a5d436fbe355405d732290de5c72f17de (diff)
fixed line endings, now for real
svn path=/trunk/externals/clr/; revision=4513
-rwxr-xr-xclr.cpp2254
-rwxr-xr-xexternal/AssemblyInfo.cs116
-rwxr-xr-xexternal/Counter.cs148
-rwxr-xr-xpd/AssemblyInfo.cs116
-rwxr-xr-xpd/Atom.cs178
-rw-r--r--pd/PureData.cs92
6 files changed, 1452 insertions, 1452 deletions
diff --git a/clr.cpp b/clr.cpp
index 7a76509..f2797fd 100755
--- a/clr.cpp
+++ b/clr.cpp
@@ -1,964 +1,964 @@
-// mono
-extern "C" {
-#include <mono/jit/jit.h>
-#include <mono/metadata/object.h>
-#include <mono/metadata/environment.h>
-#include <mono/metadata/assembly.h>
-#include <mono/metadata/debug-helpers.h>
-#include <mono/metadata/class.h>
-#include <mono/metadata/metadata.h>
-}
-
-#ifdef _MSC_VER
-#pragma warning(disable: 4091)
-#endif
-#include <m_pd.h>
-
-#include <assert.h>
-#include <stdlib.h>
+// mono
+extern "C" {
+#include <mono/jit/jit.h>
+#include <mono/metadata/object.h>
+#include <mono/metadata/environment.h>
+#include <mono/metadata/assembly.h>
+#include <mono/metadata/debug-helpers.h>
+#include <mono/metadata/class.h>
+#include <mono/metadata/metadata.h>
+}
+
+#ifdef _MSC_VER
+#pragma warning(disable: 4091)
+#endif
+#include <m_pd.h>
+
+#include <assert.h>
+#include <stdlib.h>
#include <string.h>
-#ifdef _WIN32
-#include <io.h> // for _close
+#ifdef _WIN32
+#include <io.h> // for _close
#define close _close
#else
#include <unistd.h>
#endif
-
-#include <map>
-
-#if 0
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//// OLD VERSION
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-#include <time.h>
-#include <math.h>
-
-
-#define MAX_SELECTORS 256
-#define MAX_OUTLETS 32
-
-void *clr_new(t_symbol *s, int argc, t_atom *argv);
-
-typedef struct _clr
-{
- t_object x_obj; // myself
- t_outlet *l_out;
- t_symbol *assemblyname;
- t_symbol *filename;
- int loaded;
- // mono stuff
- MonoAssembly *assembly;
- MonoObject *obj;
- MonoImage *image;
- MonoMethod *method, *setUp, *manageBang, *manageSymbol, *manageFloat, *manageList;
- MonoClass *klass;
- int n;
-
- // TODO: dynamic memory allocation
- selectorList selectors[MAX_SELECTORS];
- outletList outlets[MAX_OUTLETS];
-
-} t_clr;
-
-// list of mono methods
-typedef struct
-{
- char *sel; // the selector
- MonoMethod *func; // the function
- int type;
-// selectorList *next; // next element of the list
-} selectorList;
-
-// list of outlets
-typedef struct
-{
- t_outlet *outlet_pointer;
-// outletList *next; // next element of the list
-} outletList;
-
-// simplyfied atom
-typedef enum
-{
- A_S_NULL=0,
- A_S_FLOAT=1,
- A_S_SYMBOL=2,
-} t_atomtype_simple;
-
-typedef struct
-{
- //t_atomtype_simple a_type;
- int a_type;
- float float_value;
- MonoString *string_value;
-
-} atom_simple;
-
-
-
-
-// mono functions
-
-static void mono_clean(t_clr *x)
-{
- // clean up stuff
- //mono_jit_cleanup (x->domain);
- //mono_domain_free(x->domain);
-}
-
-void registerMonoMethod(void *x, MonoString *selectorString, MonoString *methodString, int type);
-void createInlet(void *x1, MonoString *selectorString, int type);
-void createOutlet(void *x1, int type);
-void out2outlet(void *x1, int outlet, int atoms_length, MonoArray *array);
-void post2pd(MonoString *mesString);
-void error2pd(MonoString *mesString);
-
-
-// load the variables and init mono
-static void mono_load(t_clr *x, int argc, t_atom *argv)
-{
-// const char *file="D:\\Davide\\cygwin\\home\\Davide\\externalTest1.dll";
- //const char *file="External.dll";
-
- MonoMethod *m = NULL, *ctor = NULL, *fail = NULL, *mvalues;
- MonoClassField *classPointer;
- gpointer iter;
- gpointer *args;
- int val;
- int i,j;
- int params;
- t_symbol *strsymbol;
- atom_simple *listparams;
-
- if (x->loaded == 0)
- {
- error("assembly not specified");
- return;
- }
-
- // prepare the selectors list
- for (i=0; i<MAX_SELECTORS; i++)
- {
- x->selectors[i].sel = 0;
- x->selectors[i].func = 0;
- }
- // and the outlets list
- for (i=0; i<MAX_OUTLETS; i++)
- {
- x->outlets[i].outlet_pointer = 0;
- }
-
- //mono_set_dirs (NULL, NULL);
- //mono_config_parse (NULL);
-
- //mono_jit_init (random_name_str);
-// x->domain = mono_domain_get();
- // all done without errors
- x->loaded = 1;
-
-}
-
-/*
-// call the method
-static void clr_bang(t_clr *x) {
-
- gpointer args [2];
- int val;
- MonoObject *result;
-
- val = x->n;
- args [0] = &val;
-
- if (x->method)
- {
- result = mono_runtime_invoke (x->method, x->obj, args, NULL);
- val = *(int*)mono_object_unbox (result);
- x->n = val;
- // outlet_float(x->l_out, (float) x->n);
- }
-
-
-}
-*/
-
-// finds a method from its name
-void findMonoMethod( MonoClass *klass, char *function_name, MonoMethod **met)
-{
- int trovato;
- MonoMethod *m = NULL;
- gpointer iter;
- iter = NULL;
- while (m = mono_class_get_methods (klass, &iter))
- {
- if (strcmp (mono_method_get_name (m), function_name) == 0)
- {
- *met = m;
-//printf("%s trovata\n", function_name);
- return;
- }
- }
-}
-
-void clr_free(t_clr *x)
-{
- mono_clean(x);
-}
-
-static void clr_method_bang(t_clr *x)
-{
- if (x->loaded == 0)
- {
- error("assembly not specified");
- return;
- }
- if (x->manageBang)
- {
- mono_runtime_invoke (x->manageBang, x->obj, NULL, NULL);
- }
-}
-
-static void clr_method_symbol(t_clr *x, t_symbol *sl)
-{
- gpointer args [1];
- MonoString *strmono;
- strmono = mono_string_new (monodomain, sl->s_name);
- args[0] = &strmono;
- if (x->loaded == 0)
- {
- error("assembly not specified");
- return;
- }
- if (x->manageSymbol)
- {
- mono_runtime_invoke (x->manageSymbol, x->obj, args, NULL);
- }
-}
-
-static void clr_method_float(t_clr *x, float f)
-{
- gpointer args [1];
- args [0] = &f;
- if (x->loaded == 0)
- {
- error("assembly not specified");
- return;
- }
- if (x->manageFloat)
- {
- mono_runtime_invoke (x->manageFloat, x->obj, args, NULL);
- }
-}
-
-// here i look for the selector and call the right mono method
-static void clr_method_list(t_clr *x, t_symbol *sl, int argc, t_atom *argv)
-{
- gpointer args [2];
- int valInt;
- float valFloat;
-
- int i;
- if (x->loaded == 0)
- {
- error("assembly not specified");
- return;
- }
-
- // check if a selector is present !
- //printf("clr_manage_list, got symbol = %s\n", sl->s_name);
- if (strcmp("list", sl->s_name) == 0)
- {
- printf("lista senza selector");
- if (x->manageList)
- {
- gpointer args [1];
- MonoString *stringtmp;
- double *floattmp;
- t_atomtype_simple *typetmp;
- t_symbol *strsymbol;
- MonoArray *atoms;
- atom_simple *atom_array;
- int j;
- char strfloat[256], strnull[256];
- sprintf(strfloat, "float");
- sprintf(strnull, "null");
- atom_array = malloc(sizeof(atom_simple)*argc);
- atoms = mono_array_new (monodomain, clr_atom, argc);
- for (j=0; j<argc; j++)
- {
- switch ((argv+j)->a_type)
- {
- case A_FLOAT:
- atom_array[j].a_type = A_S_FLOAT;
- atom_array[j].float_value = (double) atom_getfloat(argv+j);
- atom_array[j].string_value = mono_string_new (monodomain, strfloat);
- break;
- case A_SYMBOL:
- atom_array[j].a_type = A_S_SYMBOL;
- strsymbol = atom_getsymbol(argv+j);
- atom_array[j].string_value = mono_string_new (monodomain, strsymbol->s_name);
- atom_array[j].float_value = 0;
- break;
- default:
- atom_array[j].a_type = A_S_NULL;
- atom_array[j].float_value = 0;
- atom_array[j].string_value = mono_string_new (monodomain, strnull);
- }
- mono_array_set (atoms, atom_simple , j, atom_array[j]);
- }
-
- args[0] = atoms;
- mono_runtime_invoke (x->manageList, x->obj, args, NULL);
- return;
- } else
- {
- error("you did not specified a function to call for lists without selectors");
- return;
- }
- }
- for (i=0; i<MAX_SELECTORS; i++)
- {
- if (strcmp(x->selectors[i].sel, sl->s_name) == 0)
- {
- // I've found the selector!
- if (x->selectors[i].func)
- {
- // ParametersType {None = 0, Float=1, Symbol=2, List=3};
- switch (x->selectors[i].type)
- {
- case 0:
- mono_runtime_invoke (x->selectors[i].func, x->obj, NULL, NULL);
- break;
- case 1:
- {
- gpointer args [1];
- float val = atom_getfloat(argv);
- args[0] = &val;
- mono_runtime_invoke (x->selectors[i].func, x->obj, args, NULL);
- break;
- }
- case 2:
- {
- gpointer args [1];
- t_symbol *strsymbol;
- MonoString *strmono;
- strsymbol = atom_getsymbol(argv);
- strmono = mono_string_new (monodomain, strsymbol->s_name);
- args[0] = &strmono;
- mono_runtime_invoke (x->selectors[i].func, x->obj, args, NULL);
- // memory leak ?
- break;
- }
- case 3:
- {
- gpointer args [1];
- MonoString *stringtmp;
- double *floattmp;
- t_atomtype_simple *typetmp;
- t_symbol *strsymbol;
- MonoArray *atoms;
- atom_simple *atom_array;
- int j;
- char strfloat[256], strnull[256];
- sprintf(strfloat, "float");
- sprintf(strnull, "null");
- atom_array = malloc(sizeof(atom_simple)*argc);
- atoms = mono_array_new (monodomain, clr_atom, argc);
- for (j=0; j<argc; j++)
- {
- switch ((argv+j)->a_type)
- {
- case A_FLOAT:
- atom_array[j].a_type = A_S_FLOAT;
- atom_array[j].float_value = (double) atom_getfloat(argv+j);
- atom_array[j].string_value = mono_string_new (monodomain, strfloat);
- break;
- case A_SYMBOL:
- atom_array[j].a_type = A_S_SYMBOL;
- strsymbol = atom_getsymbol(argv+j);
- atom_array[j].string_value = mono_string_new (monodomain, strsymbol->s_name);
- atom_array[j].float_value = 0;
- break;
- default:
- atom_array[j].a_type = A_S_NULL;
- atom_array[j].float_value = 0;
- atom_array[j].string_value = mono_string_new (monodomain, strnull);
- }
- mono_array_set (atoms, atom_simple , j, atom_array[j]);
- }
-
- args[0] = atoms;
- mono_runtime_invoke (x->selectors[i].func, x->obj, args, NULL);
- break;
- }
- }
- return;
- }
- }
- if (x->selectors[i].func == 0)
- i = MAX_SELECTORS;
- }
- error("clr: selector not recognized");
-}
-
-// this function is called by mono when it wants to register a selector callback
-void registerMonoMethod(void *x1, MonoString *selectorString, MonoString *methodString, int type)
-{
-
- char *selCstring, *metCstring;
- MonoMethod *met;
- t_clr *x;
- int this_selector, i;
- //int ret;
-
-
- selCstring = mono_string_to_utf8 (selectorString);
- metCstring = mono_string_to_utf8 (methodString);
-
- x = (t_clr *)x1;
-
- //ret = 0;
- met = 0;
- findMonoMethod( x->klass, metCstring, &met);
-
- if (!met)
- {
- error("method not found!");
- return;
- }
-
- //post("registerMonoMethod: associating %s to %s", selCstring, metCstring);
-
- if (selectorString->length == 0)
- {
- switch (type)
- {
- case 1: // float
- x->manageFloat = met;
- break;
- case 2: // string
- x->manageSymbol = met;
- break;
- case 3: // list
- x->manageList = met;
- break;
- case 4: // bang
- x->manageBang = met;
- break;
- }
- }
-
- this_selector = MAX_SELECTORS;
- for (i = 0; i < MAX_SELECTORS; i++)
- {
- if (x->selectors[i].func == 0)
- {
- // i found the first empty space
- this_selector = i;
- i = MAX_SELECTORS;
- }
-
- }
- if (this_selector == MAX_SELECTORS)
- {
- error("not enough space for selectors! MAX_SELECTORS = %i", MAX_SELECTORS);
- return;
- }
-
- x->selectors[this_selector].sel = selCstring;
- x->selectors[this_selector].func = met;
- x->selectors[this_selector].type = type;
-
- class_addmethod(clr_class, (t_method)clr_method_list, gensym(selCstring), A_GIMME, 0);
-
-
-}
-
-// this function is called by mono when it wants to create a new inlet
-void createInlet(void *x1, MonoString *selectorString, int type)
-{
- // public enum ParametersType {None = 0, Float=1, Symbol=2, List=3, Bang=4, Generic=5};
- char *selCstring;
- char typeString[256];
- t_clr *x;
-
- selCstring = mono_string_to_utf8 (selectorString);
- x = (t_clr *)x1;
- if (x->loaded == 0)
- {
- error("assembly not specified");
- return;
- }
- switch (type)
- {
- case 1:
- sprintf(typeString, "float");
- break;
- case 2:
- sprintf(typeString, "symbol");
- break;
- case 3:
- sprintf(typeString, "list");
- break;
- case 4:
- sprintf(typeString, "bang");
- break;
- default:
- sprintf(typeString, "");
- break;
- }
- // create the inlet
- inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym(typeString), gensym(selCstring));
-}
-
-// this function is called by mono when it wants to create a new outlet
-void createOutlet(void *x1, int type)
-{
- t_clr *x;
- int i = 0;
- char typeString[256];
- x = (t_clr *)x1;
- if (x->loaded == 0)
- {
- error("assembly not specified");
- return;
- }
- // public enum ParametersType {None = 0, Float=1, Symbol=2, List=3, Bang=4, Generic=5};
- switch (type)
- {
- case 1:
- sprintf(typeString, "float");
- break;
- case 2:
- sprintf(typeString, "symbol");
- break;
- case 3:
- sprintf(typeString, "list");
- break;
- case 4:
- sprintf(typeString, "bang");
- break;
- default:
- sprintf(typeString, "");
- break;
- }
-
- while (i < MAX_OUTLETS)
- {
- if (x->outlets[i].outlet_pointer == 0)
- {
- // empty space found!
- x->outlets[i].outlet_pointer = outlet_new(&x->x_obj, gensym(typeString));
- return;
- }
- i++;
- }
- error("the maximum number of outlets has been reached (%i)", MAX_OUTLETS);
-
-}
-
-// out to outlet
-void out2outlet(void *x1, int outlet, int atoms_length, MonoArray *array)
-{
- t_clr *x;
- t_atom *lista;
- atom_simple *atoms;
- int n;
- x = (t_clr *)x1;
- if (x->loaded == 0)
- {
- error("assembly not specified");
- return;
- }
- if ((outlet>MAX_OUTLETS) || (outlet<0))
- {
- error("outlet number out of range, max is %i", MAX_OUTLETS);
- return;
- }
- if (x->outlets[outlet].outlet_pointer == 0)
- {
- error("outlet %i not registered", outlet);
- return;
- }
- lista = (t_atom *) malloc(sizeof(t_atom) * atoms_length);
- atoms = (atom_simple *) malloc(sizeof(atom_simple) * atoms_length);
- for (n=0; n<atoms_length; n++)
- {
- char *mesCstring;
- atoms[n] = mono_array_get(array, atom_simple, n);
- switch (atoms[n].a_type)
- {
- case A_S_NULL:
- SETFLOAT(lista+n, (float) 0);
- break;
- case A_S_FLOAT:
- SETFLOAT(lista+n, (float) atoms[n].float_value);
- break;
- case A_S_SYMBOL:
- mesCstring = mono_string_to_utf8 (atoms[n].string_value);
- SETSYMBOL(lista+n, gensym(mesCstring));
- break;
- }
-
- }
- outlet_anything(x->outlets[outlet].outlet_pointer,
- gensym("list") ,
- atoms_length,
- lista);
- free(lista);
-}
-
-// this function is called by mono when it wants post messages to pd
-void post2pd(MonoString *mesString)
-{
-
- char *mesCstring;
- mesCstring = mono_string_to_utf8 (mesString);
- post(mesCstring);
-
-}
-
-// this function is called by mono when it wants to post errors to pd
-void error2pd(MonoString *mesString)
-{
-
- char *mesCstring;
- mesCstring = mono_string_to_utf8 (mesString);
- error(mesCstring);
-}
-/*
-//void ext_class_addbang(const char *funcName)
-void ext_class_addbang(t_method funcName)
-{
-// class_addbang(clr_class, (t_method)clr_bang);
- class_addbang(clr_class, funcName);
-}*/
-
-void *clr_new(t_symbol *s, int argc, t_atom *argv)
-{
-
- int i;
- time_t a;
- t_clr *x = (t_clr *)pd_new(clr_class);
-
- char strtmp[256];
- x->manageBang = 0;
- x->manageSymbol = 0;
- x->manageFloat = 0;
- x->manageList = 0;
-
- if (argc==0)
- {
- x->loaded = 0;
- error("clr: you must provide a class name as the first argument");
- return (x);
- }
- x->loaded = 1;
- x->assemblyname = atom_gensym(argv);
-
- if (argc<2)
- {
- // only main class passed
- // filename by default
- sprintf(strtmp, "%s.dll", x->assemblyname->s_name);
- x->filename = gensym(strtmp);
- printf(" used did not specified filename, I guess it is %s\n", strtmp);
- } else
- {
- x->filename = atom_gensym(argv+1);
- }
-
- x->obj = mono_object_new (monodomain, x->klass);
-
- // load mono, init the needed vars
-// mono_load(x, argc, argv);
- // now call the class constructor
- if (ctor)
- {
- args = malloc(sizeof(gpointer)*params);
- listparams = malloc(sizeof(atom_simple)*params);
- for (j=2; j<argc; j++)
- {
- switch ((argv+j)->a_type)
- {
- case A_FLOAT:
- listparams[j-2].a_type = A_S_FLOAT;
- listparams[j-2].float_value = (double) atom_getfloat(argv+j);
- args[j-2] = &(listparams[j-2].float_value);
- break;
- case A_SYMBOL:
- listparams[j-2].a_type = A_S_SYMBOL;
- strsymbol = atom_getsymbol(argv+j);
- listparams[j-2].string_value = mono_string_new (monodomain, strsymbol->s_name);
- args[j-2] = listparams[j-2].string_value;
- break;
- }
- }
- mono_runtime_invoke (ctor, x->obj, args, NULL);
- free(listparams);
- free(args);
- } else
- {
- error("%s doesn't have a constructor with %i parameters!",x->assemblyname->s_name, params);
- }
-
-
- return (x);
-}
-
-#endif
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//// NEW VERSION
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-static MonoDomain *monodomain;
-static MonoClass *clr_atom,*clr_symbol;
-static MonoClassField *clr_symbol_ptr;
-//static MonoMethod *clr_symbol_ctor;
-static MonoMethodDesc *clr_desc_main,*clr_desc_ctor;
-static MonoMethodDesc *clr_desc_bang,*clr_desc_float,*clr_desc_symbol,*clr_desc_pointer,*clr_desc_list,*clr_desc_anything;
-
-typedef std::map<t_symbol *,MonoMethod *> ClrMethodMap;
-
-// this is the class structure
-// holding the pd and mono class
-// and our CLR method pointers
-typedef struct
-{
- t_class *pd_class;
- MonoClass *mono_class;
- MonoClassField *mono_obj_field;
- MonoMethod *mono_ctor;
- MonoMethod *method_bang,*method_float, *method_symbol,*method_list,*method_pointer,*method_anything;
-// ClrMethodMap *methods;
-} t_clr_class;
-
-typedef std::map<t_symbol *,t_clr_class *> ClrMap;
-// this holds the class name to class structure association
-static ClrMap clr_map;
-
-// this is the class to be setup (while we are in the CLR static Main method)
-static t_clr_class *clr_setup_class = NULL;
-
-// this is the class instance object structure
-typedef struct
-{
- t_object pd_obj; // myself
- t_clr_class *clr_clss; // pointer to our class structure
- MonoObject *mono_obj;
-} t_clr;
-
-
-
-static void clr_method_bang(t_clr *x)
-{
- assert(x && x->clr_clss && x->clr_clss->method_bang);
- mono_runtime_invoke(x->clr_clss->method_bang,x->mono_obj,NULL,NULL);
-}
-
-static void clr_method_float(t_clr *x,t_float f)
-{
- assert(x && x->clr_clss && x->clr_clss->method_float);
- gpointer args = &f;
- mono_runtime_invoke(x->clr_clss->method_float,x->mono_obj,&args,NULL);
-}
-
-static void clr_method_symbol(t_clr *x,t_symbol *s)
-{
- assert(x && x->clr_clss && x->clr_clss->method_symbol);
+
+#include <map>
+
+#if 0
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//// OLD VERSION
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+#include <time.h>
+#include <math.h>
+
+
+#define MAX_SELECTORS 256
+#define MAX_OUTLETS 32
+
+void *clr_new(t_symbol *s, int argc, t_atom *argv);
+
+typedef struct _clr
+{
+ t_object x_obj; // myself
+ t_outlet *l_out;
+ t_symbol *assemblyname;
+ t_symbol *filename;
+ int loaded;
+ // mono stuff
+ MonoAssembly *assembly;
+ MonoObject *obj;
+ MonoImage *image;
+ MonoMethod *method, *setUp, *manageBang, *manageSymbol, *manageFloat, *manageList;
+ MonoClass *klass;
+ int n;
+
+ // TODO: dynamic memory allocation
+ selectorList selectors[MAX_SELECTORS];
+ outletList outlets[MAX_OUTLETS];
+
+} t_clr;
+
+// list of mono methods
+typedef struct
+{
+ char *sel; // the selector
+ MonoMethod *func; // the function
+ int type;
+// selectorList *next; // next element of the list
+} selectorList;
+
+// list of outlets
+typedef struct
+{
+ t_outlet *outlet_pointer;
+// outletList *next; // next element of the list
+} outletList;
+
+// simplyfied atom
+typedef enum
+{
+ A_S_NULL=0,
+ A_S_FLOAT=1,
+ A_S_SYMBOL=2,
+} t_atomtype_simple;
+
+typedef struct
+{
+ //t_atomtype_simple a_type;
+ int a_type;
+ float float_value;
+ MonoString *string_value;
+
+} atom_simple;
+
+
+
+
+// mono functions
+
+static void mono_clean(t_clr *x)
+{
+ // clean up stuff
+ //mono_jit_cleanup (x->domain);
+ //mono_domain_free(x->domain);
+}
+
+void registerMonoMethod(void *x, MonoString *selectorString, MonoString *methodString, int type);
+void createInlet(void *x1, MonoString *selectorString, int type);
+void createOutlet(void *x1, int type);
+void out2outlet(void *x1, int outlet, int atoms_length, MonoArray *array);
+void post2pd(MonoString *mesString);
+void error2pd(MonoString *mesString);
+
+
+// load the variables and init mono
+static void mono_load(t_clr *x, int argc, t_atom *argv)
+{
+// const char *file="D:\\Davide\\cygwin\\home\\Davide\\externalTest1.dll";
+ //const char *file="External.dll";
+
+ MonoMethod *m = NULL, *ctor = NULL, *fail = NULL, *mvalues;
+ MonoClassField *classPointer;
+ gpointer iter;
+ gpointer *args;
+ int val;
+ int i,j;
+ int params;
+ t_symbol *strsymbol;
+ atom_simple *listparams;
+
+ if (x->loaded == 0)
+ {
+ error("assembly not specified");
+ return;
+ }
+
+ // prepare the selectors list
+ for (i=0; i<MAX_SELECTORS; i++)
+ {
+ x->selectors[i].sel = 0;
+ x->selectors[i].func = 0;
+ }
+ // and the outlets list
+ for (i=0; i<MAX_OUTLETS; i++)
+ {
+ x->outlets[i].outlet_pointer = 0;
+ }
+
+ //mono_set_dirs (NULL, NULL);
+ //mono_config_parse (NULL);
+
+ //mono_jit_init (random_name_str);
+// x->domain = mono_domain_get();
+ // all done without errors
+ x->loaded = 1;
+
+}
+
+/*
+// call the method
+static void clr_bang(t_clr *x) {
+
+ gpointer args [2];
+ int val;
+ MonoObject *result;
+
+ val = x->n;
+ args [0] = &val;
+
+ if (x->method)
+ {
+ result = mono_runtime_invoke (x->method, x->obj, args, NULL);
+ val = *(int*)mono_object_unbox (result);
+ x->n = val;
+ // outlet_float(x->l_out, (float) x->n);
+ }
+
+
+}
+*/
+
+// finds a method from its name
+void findMonoMethod( MonoClass *klass, char *function_name, MonoMethod **met)
+{
+ int trovato;
+ MonoMethod *m = NULL;
+ gpointer iter;
+ iter = NULL;
+ while (m = mono_class_get_methods (klass, &iter))
+ {
+ if (strcmp (mono_method_get_name (m), function_name) == 0)
+ {
+ *met = m;
+//printf("%s trovata\n", function_name);
+ return;
+ }
+ }
+}
+
+void clr_free(t_clr *x)
+{
+ mono_clean(x);
+}
+
+static void clr_method_bang(t_clr *x)
+{
+ if (x->loaded == 0)
+ {
+ error("assembly not specified");
+ return;
+ }
+ if (x->manageBang)
+ {
+ mono_runtime_invoke (x->manageBang, x->obj, NULL, NULL);
+ }
+}
+
+static void clr_method_symbol(t_clr *x, t_symbol *sl)
+{
+ gpointer args [1];
+ MonoString *strmono;
+ strmono = mono_string_new (monodomain, sl->s_name);
+ args[0] = &strmono;
+ if (x->loaded == 0)
+ {
+ error("assembly not specified");
+ return;
+ }
+ if (x->manageSymbol)
+ {
+ mono_runtime_invoke (x->manageSymbol, x->obj, args, NULL);
+ }
+}
+
+static void clr_method_float(t_clr *x, float f)
+{
+ gpointer args [1];
+ args [0] = &f;
+ if (x->loaded == 0)
+ {
+ error("assembly not specified");
+ return;
+ }
+ if (x->manageFloat)
+ {
+ mono_runtime_invoke (x->manageFloat, x->obj, args, NULL);
+ }
+}
+
+// here i look for the selector and call the right mono method
+static void clr_method_list(t_clr *x, t_symbol *sl, int argc, t_atom *argv)
+{
+ gpointer args [2];
+ int valInt;
+ float valFloat;
+
+ int i;
+ if (x->loaded == 0)
+ {
+ error("assembly not specified");
+ return;
+ }
+
+ // check if a selector is present !
+ //printf("clr_manage_list, got symbol = %s\n", sl->s_name);
+ if (strcmp("list", sl->s_name) == 0)
+ {
+ printf("lista senza selector");
+ if (x->manageList)
+ {
+ gpointer args [1];
+ MonoString *stringtmp;
+ double *floattmp;
+ t_atomtype_simple *typetmp;
+ t_symbol *strsymbol;
+ MonoArray *atoms;
+ atom_simple *atom_array;
+ int j;
+ char strfloat[256], strnull[256];
+ sprintf(strfloat, "float");
+ sprintf(strnull, "null");
+ atom_array = malloc(sizeof(atom_simple)*argc);
+ atoms = mono_array_new (monodomain, clr_atom, argc);
+ for (j=0; j<argc; j++)
+ {
+ switch ((argv+j)->a_type)
+ {
+ case A_FLOAT:
+ atom_array[j].a_type = A_S_FLOAT;
+ atom_array[j].float_value = (double) atom_getfloat(argv+j);
+ atom_array[j].string_value = mono_string_new (monodomain, strfloat);
+ break;
+ case A_SYMBOL:
+ atom_array[j].a_type = A_S_SYMBOL;
+ strsymbol = atom_getsymbol(argv+j);
+ atom_array[j].string_value = mono_string_new (monodomain, strsymbol->s_name);
+ atom_array[j].float_value = 0;
+ break;
+ default:
+ atom_array[j].a_type = A_S_NULL;
+ atom_array[j].float_value = 0;
+ atom_array[j].string_value = mono_string_new (monodomain, strnull);
+ }
+ mono_array_set (atoms, atom_simple , j, atom_array[j]);
+ }
+
+ args[0] = atoms;
+ mono_runtime_invoke (x->manageList, x->obj, args, NULL);
+ return;
+ } else
+ {
+ error("you did not specified a function to call for lists without selectors");
+ return;
+ }
+ }
+ for (i=0; i<MAX_SELECTORS; i++)
+ {
+ if (strcmp(x->selectors[i].sel, sl->s_name) == 0)
+ {
+ // I've found the selector!
+ if (x->selectors[i].func)
+ {
+ // ParametersType {None = 0, Float=1, Symbol=2, List=3};
+ switch (x->selectors[i].type)
+ {
+ case 0:
+ mono_runtime_invoke (x->selectors[i].func, x->obj, NULL, NULL);
+ break;
+ case 1:
+ {
+ gpointer args [1];
+ float val = atom_getfloat(argv);
+ args[0] = &val;
+ mono_runtime_invoke (x->selectors[i].func, x->obj, args, NULL);
+ break;
+ }
+ case 2:
+ {
+ gpointer args [1];
+ t_symbol *strsymbol;
+ MonoString *strmono;
+ strsymbol = atom_getsymbol(argv);
+ strmono = mono_string_new (monodomain, strsymbol->s_name);
+ args[0] = &strmono;
+ mono_runtime_invoke (x->selectors[i].func, x->obj, args, NULL);
+ // memory leak ?
+ break;
+ }
+ case 3:
+ {
+ gpointer args [1];
+ MonoString *stringtmp;
+ double *floattmp;
+ t_atomtype_simple *typetmp;
+ t_symbol *strsymbol;
+ MonoArray *atoms;
+ atom_simple *atom_array;
+ int j;
+ char strfloat[256], strnull[256];
+ sprintf(strfloat, "float");
+ sprintf(strnull, "null");
+ atom_array = malloc(sizeof(atom_simple)*argc);
+ atoms = mono_array_new (monodomain, clr_atom, argc);
+ for (j=0; j<argc; j++)
+ {
+ switch ((argv+j)->a_type)
+ {
+ case A_FLOAT:
+ atom_array[j].a_type = A_S_FLOAT;
+ atom_array[j].float_value = (double) atom_getfloat(argv+j);
+ atom_array[j].string_value = mono_string_new (monodomain, strfloat);
+ break;
+ case A_SYMBOL:
+ atom_array[j].a_type = A_S_SYMBOL;
+ strsymbol = atom_getsymbol(argv+j);
+ atom_array[j].string_value = mono_string_new (monodomain, strsymbol->s_name);
+ atom_array[j].float_value = 0;
+ break;
+ default:
+ atom_array[j].a_type = A_S_NULL;
+ atom_array[j].float_value = 0;
+ atom_array[j].string_value = mono_string_new (monodomain, strnull);
+ }
+ mono_array_set (atoms, atom_simple , j, atom_array[j]);
+ }
+
+ args[0] = atoms;
+ mono_runtime_invoke (x->selectors[i].func, x->obj, args, NULL);
+ break;
+ }
+ }
+ return;
+ }
+ }
+ if (x->selectors[i].func == 0)
+ i = MAX_SELECTORS;
+ }
+ error("clr: selector not recognized");
+}
+
+// this function is called by mono when it wants to register a selector callback
+void registerMonoMethod(void *x1, MonoString *selectorString, MonoString *methodString, int type)
+{
+
+ char *selCstring, *metCstring;
+ MonoMethod *met;
+ t_clr *x;
+ int this_selector, i;
+ //int ret;
+
+
+ selCstring = mono_string_to_utf8 (selectorString);
+ metCstring = mono_string_to_utf8 (methodString);
+
+ x = (t_clr *)x1;
+
+ //ret = 0;
+ met = 0;
+ findMonoMethod( x->klass, metCstring, &met);
+
+ if (!met)
+ {
+ error("method not found!");
+ return;
+ }
+
+ //post("registerMonoMethod: associating %s to %s", selCstring, metCstring);
+
+ if (selectorString->length == 0)
+ {
+ switch (type)
+ {
+ case 1: // float
+ x->manageFloat = met;
+ break;
+ case 2: // string
+ x->manageSymbol = met;
+ break;
+ case 3: // list
+ x->manageList = met;
+ break;
+ case 4: // bang
+ x->manageBang = met;
+ break;
+ }
+ }
+
+ this_selector = MAX_SELECTORS;
+ for (i = 0; i < MAX_SELECTORS; i++)
+ {
+ if (x->selectors[i].func == 0)
+ {
+ // i found the first empty space
+ this_selector = i;
+ i = MAX_SELECTORS;
+ }
+
+ }
+ if (this_selector == MAX_SELECTORS)
+ {
+ error("not enough space for selectors! MAX_SELECTORS = %i", MAX_SELECTORS);
+ return;
+ }
+
+ x->selectors[this_selector].sel = selCstring;
+ x->selectors[this_selector].func = met;
+ x->selectors[this_selector].type = type;
+
+ class_addmethod(clr_class, (t_method)clr_method_list, gensym(selCstring), A_GIMME, 0);
+
+
+}
+
+// this function is called by mono when it wants to create a new inlet
+void createInlet(void *x1, MonoString *selectorString, int type)
+{
+ // public enum ParametersType {None = 0, Float=1, Symbol=2, List=3, Bang=4, Generic=5};
+ char *selCstring;
+ char typeString[256];
+ t_clr *x;
+
+ selCstring = mono_string_to_utf8 (selectorString);
+ x = (t_clr *)x1;
+ if (x->loaded == 0)
+ {
+ error("assembly not specified");
+ return;
+ }
+ switch (type)
+ {
+ case 1:
+ sprintf(typeString, "float");
+ break;
+ case 2:
+ sprintf(typeString, "symbol");
+ break;
+ case 3:
+ sprintf(typeString, "list");
+ break;
+ case 4:
+ sprintf(typeString, "bang");
+ break;
+ default:
+ sprintf(typeString, "");
+ break;
+ }
+ // create the inlet
+ inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym(typeString), gensym(selCstring));
+}
+
+// this function is called by mono when it wants to create a new outlet
+void createOutlet(void *x1, int type)
+{
+ t_clr *x;
+ int i = 0;
+ char typeString[256];
+ x = (t_clr *)x1;
+ if (x->loaded == 0)
+ {
+ error("assembly not specified");
+ return;
+ }
+ // public enum ParametersType {None = 0, Float=1, Symbol=2, List=3, Bang=4, Generic=5};
+ switch (type)
+ {
+ case 1:
+ sprintf(typeString, "float");
+ break;
+ case 2:
+ sprintf(typeString, "symbol");
+ break;
+ case 3:
+ sprintf(typeString, "list");
+ break;
+ case 4:
+ sprintf(typeString, "bang");
+ break;
+ default:
+ sprintf(typeString, "");
+ break;
+ }
+
+ while (i < MAX_OUTLETS)
+ {
+ if (x->outlets[i].outlet_pointer == 0)
+ {
+ // empty space found!
+ x->outlets[i].outlet_pointer = outlet_new(&x->x_obj, gensym(typeString));
+ return;
+ }
+ i++;
+ }
+ error("the maximum number of outlets has been reached (%i)", MAX_OUTLETS);
+
+}
+
+// out to outlet
+void out2outlet(void *x1, int outlet, int atoms_length, MonoArray *array)
+{
+ t_clr *x;
+ t_atom *lista;
+ atom_simple *atoms;
+ int n;
+ x = (t_clr *)x1;
+ if (x->loaded == 0)
+ {
+ error("assembly not specified");
+ return;
+ }
+ if ((outlet>MAX_OUTLETS) || (outlet<0))
+ {
+ error("outlet number out of range, max is %i", MAX_OUTLETS);
+ return;
+ }
+ if (x->outlets[outlet].outlet_pointer == 0)
+ {
+ error("outlet %i not registered", outlet);
+ return;
+ }
+ lista = (t_atom *) malloc(sizeof(t_atom) * atoms_length);
+ atoms = (atom_simple *) malloc(sizeof(atom_simple) * atoms_length);
+ for (n=0; n<atoms_length; n++)
+ {
+ char *mesCstring;
+ atoms[n] = mono_array_get(array, atom_simple, n);
+ switch (atoms[n].a_type)
+ {
+ case A_S_NULL:
+ SETFLOAT(lista+n, (float) 0);
+ break;
+ case A_S_FLOAT:
+ SETFLOAT(lista+n, (float) atoms[n].float_value);
+ break;
+ case A_S_SYMBOL:
+ mesCstring = mono_string_to_utf8 (atoms[n].string_value);
+ SETSYMBOL(lista+n, gensym(mesCstring));
+ break;
+ }
+
+ }
+ outlet_anything(x->outlets[outlet].outlet_pointer,
+ gensym("list") ,
+ atoms_length,
+ lista);
+ free(lista);
+}
+
+// this function is called by mono when it wants post messages to pd
+void post2pd(MonoString *mesString)
+{
+
+ char *mesCstring;
+ mesCstring = mono_string_to_utf8 (mesString);
+ post(mesCstring);
+
+}
+
+// this function is called by mono when it wants to post errors to pd
+void error2pd(MonoString *mesString)
+{
+
+ char *mesCstring;
+ mesCstring = mono_string_to_utf8 (mesString);
+ error(mesCstring);
+}
+/*
+//void ext_class_addbang(const char *funcName)
+void ext_class_addbang(t_method funcName)
+{
+// class_addbang(clr_class, (t_method)clr_bang);
+ class_addbang(clr_class, funcName);
+}*/
+
+void *clr_new(t_symbol *s, int argc, t_atom *argv)
+{
+
+ int i;
+ time_t a;
+ t_clr *x = (t_clr *)pd_new(clr_class);
+
+ char strtmp[256];
+ x->manageBang = 0;
+ x->manageSymbol = 0;
+ x->manageFloat = 0;
+ x->manageList = 0;
+
+ if (argc==0)
+ {
+ x->loaded = 0;
+ error("clr: you must provide a class name as the first argument");
+ return (x);
+ }
+ x->loaded = 1;
+ x->assemblyname = atom_gensym(argv);
+
+ if (argc<2)
+ {
+ // only main class passed
+ // filename by default
+ sprintf(strtmp, "%s.dll", x->assemblyname->s_name);
+ x->filename = gensym(strtmp);
+ printf(" used did not specified filename, I guess it is %s\n", strtmp);
+ } else
+ {
+ x->filename = atom_gensym(argv+1);
+ }
+
+ x->obj = mono_object_new (monodomain, x->klass);
+
+ // load mono, init the needed vars
+// mono_load(x, argc, argv);
+ // now call the class constructor
+ if (ctor)
+ {
+ args = malloc(sizeof(gpointer)*params);
+ listparams = malloc(sizeof(atom_simple)*params);
+ for (j=2; j<argc; j++)
+ {
+ switch ((argv+j)->a_type)
+ {
+ case A_FLOAT:
+ listparams[j-2].a_type = A_S_FLOAT;
+ listparams[j-2].float_value = (double) atom_getfloat(argv+j);
+ args[j-2] = &(listparams[j-2].float_value);
+ break;
+ case A_SYMBOL:
+ listparams[j-2].a_type = A_S_SYMBOL;
+ strsymbol = atom_getsymbol(argv+j);
+ listparams[j-2].string_value = mono_string_new (monodomain, strsymbol->s_name);
+ args[j-2] = listparams[j-2].string_value;
+ break;
+ }
+ }
+ mono_runtime_invoke (ctor, x->obj, args, NULL);
+ free(listparams);
+ free(args);
+ } else
+ {
+ error("%s doesn't have a constructor with %i parameters!",x->assemblyname->s_name, params);
+ }
+
+
+ return (x);
+}
+
+#endif
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//// NEW VERSION
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+static MonoDomain *monodomain;
+static MonoClass *clr_atom,*clr_symbol;
+static MonoClassField *clr_symbol_ptr;
+//static MonoMethod *clr_symbol_ctor;
+static MonoMethodDesc *clr_desc_main,*clr_desc_ctor;
+static MonoMethodDesc *clr_desc_bang,*clr_desc_float,*clr_desc_symbol,*clr_desc_pointer,*clr_desc_list,*clr_desc_anything;
+
+typedef std::map<t_symbol *,MonoMethod *> ClrMethodMap;
+
+// this is the class structure
+// holding the pd and mono class
+// and our CLR method pointers
+typedef struct
+{
+ t_class *pd_class;
+ MonoClass *mono_class;
+ MonoClassField *mono_obj_field;
+ MonoMethod *mono_ctor;
+ MonoMethod *method_bang,*method_float, *method_symbol,*method_list,*method_pointer,*method_anything;
+// ClrMethodMap *methods;
+} t_clr_class;
+
+typedef std::map<t_symbol *,t_clr_class *> ClrMap;
+// this holds the class name to class structure association
+static ClrMap clr_map;
+
+// this is the class to be setup (while we are in the CLR static Main method)
+static t_clr_class *clr_setup_class = NULL;
+
+// this is the class instance object structure
+typedef struct
+{
+ t_object pd_obj; // myself
+ t_clr_class *clr_clss; // pointer to our class structure
+ MonoObject *mono_obj;
+} t_clr;
+
+
+
+static void clr_method_bang(t_clr *x)
+{
+ assert(x && x->clr_clss && x->clr_clss->method_bang);
+ mono_runtime_invoke(x->clr_clss->method_bang,x->mono_obj,NULL,NULL);
+}
+
+static void clr_method_float(t_clr *x,t_float f)
+{
+ assert(x && x->clr_clss && x->clr_clss->method_float);
+ gpointer args = &f;
+ mono_runtime_invoke(x->clr_clss->method_float,x->mono_obj,&args,NULL);
+}
+
+static void clr_method_symbol(t_clr *x,t_symbol *s)
+{
+ assert(x && x->clr_clss && x->clr_clss->method_symbol);
MonoObject *symobj = mono_object_new(monodomain,clr_symbol);
-// gpointer args = &s;
-// mono_runtime_invoke(clr_symbol_ctor,symobj,&args,NULL);
- // setting the field directly doesn't seem to work?!
- mono_field_set_value(symobj,clr_symbol_ptr,s);
- gpointer args = symobj;
- mono_runtime_invoke(x->clr_clss->method_symbol,x->mono_obj,&args,NULL);
-}
-
-static void clr_method_list(t_clr *x,int argc, t_atom *argv)
-{
- assert(x && x->clr_clss && x->clr_clss->method_list);
-}
-
-static void clr_method_pointer(t_clr *x,t_gpointer *ptr)
-{
- assert(x && x->clr_clss && x->clr_clss->method_pointer);
-}
-
-static void clr_method_anything(t_clr *x,t_symbol *sl, int argc, t_atom *argv)
-{
-#if 0
- assert(x && x->clr_clss);
- ClrMethodMap *methods = x->clr_clss->methods;
- if(methods) {
- ClrMethodMap::iterator it = methods->find(sl);
- if(it != methods->end()) {
- // \TODO call m
- return;
- }
- }
- if(x->clr_clss->method_anything) {
- // \TODO call methodanything
- }
- else
- post("CLR - no method for %s found",sl->s_name);
-#else
- assert(x && x->clr_clss && x->clr_clss->method_anything);
-#endif
-}
-
-
-// this function is called by mono when it wants post messages to pd
-static void PD_Post(MonoString *str)
-{
- post("%s",mono_string_to_utf8(str));
-}
-
-// this function is called by mono when it wants post messages to pd
-static void PD_PostError(MonoString *str)
-{
- error("%s",mono_string_to_utf8(str));
-}
-
-// this function is called by mono when it wants post messages to pd
-static void PD_PostBug(MonoString *str)
-{
- bug("%s",mono_string_to_utf8(str));
-}
-
-// this function is called by mono when it wants post messages to pd
-static void PD_PostVerbose(int lvl,MonoString *str)
-{
- verbose(lvl,"%s",mono_string_to_utf8(str));
-}
-
-static void *PD_GenSym(MonoString *str)
-{
- return gensym(mono_string_to_utf8(str));
-}
-
-static MonoString *PD_EvalSym(MonoObject *symobj)
-{
- t_symbol *sym;
- mono_field_get_value(symobj,clr_symbol_ptr,&sym);
- return mono_string_new(monodomain,sym->s_name);
-}
-
-
-#if 0
-// this function is called by mono when it wants post messages to pd
-static void PD_AddMethod(MonoObject *symobj,MonoObject *obj)
-{
- assert(clr_setup_class);
-
-// char *tag = mono_string_to_utf8(str);
-// post("register method %s",tag);
- t_symbol *sym;
- mono_field_get_value(symobj,clr_symbol_ptr,&sym);
-
- // \TODO convert from obj
- MonoMethod *m = NULL;
-
- if(sym == &s_bang) {
- if(!clr_setup_class->method_bang)
- class_addbang(clr_setup_class->pd_class,clr_method_bang);
- clr_setup_class->method_bang = m;
- }
- else if(sym == &s_float) {
- if(!clr_setup_class->method_bang)
- class_addfloat(clr_setup_class->pd_class,clr_method_float);
- clr_setup_class->method_bang = m;
- }
- else if(sym == &s_symbol) {
- if(!clr_setup_class->method_symbol)
- class_addsymbol(clr_setup_class->pd_class,clr_method_symbol);
- clr_setup_class->method_symbol = m;
- }
- else if(sym == &s_list) {
- if(!clr_setup_class->method_list)
- class_addlist(clr_setup_class->pd_class,clr_method_list);
- clr_setup_class->method_list = m;
- }
- else if(sym == &s_pointer) {
- if(!clr_setup_class->method_pointer)
- class_addpointer(clr_setup_class->pd_class,clr_method_pointer);
- clr_setup_class->method_pointer = m;
- }
- else if(sym == &s_) {
- if(!clr_setup_class->method_anything && !clr_setup_class->methods) // only register once!
- class_addanything(clr_setup_class->pd_class,clr_method_anything);
- clr_setup_class->method_anything = m;
- }
- else {
- if(!clr_setup_class->methods) {
- // no methods yet
- clr_setup_class->methods = new ClrMethodMap;
- if(!clr_setup_class->method_anything) // only register once!
- class_addanything(clr_setup_class->pd_class,clr_method_anything);
- }
-
- // add tag to map
- (*clr_setup_class->methods)[sym] = m;
- }
-}
-#endif
-
-void *clr_new(t_symbol *classname, int argc, t_atom *argv)
-{
- // find class name in map
- ClrMap::iterator it = clr_map.find(classname);
- if(it == clr_map.end()) {
- error("CLR class %s not found",classname->s_name);
- return NULL;
- }
-
- t_clr_class *clss = it->second;
-
- // make instance
- t_clr *x = (t_clr *)pd_new(clss->pd_class);
- x->mono_obj = mono_object_new (monodomain,clss->mono_class);
- if(!x->mono_obj) {
- pd_free((t_pd *)x);
- error("CLR class %s could not be instantiated",classname->s_name);
- return NULL;
- }
-
- // store class pointer
- x->clr_clss = clss;
-
- // store our object pointer in External::ptr member
- mono_field_set_value(x->mono_obj,clss->mono_obj_field,x);
-
- // ok, we have an object - look for constructor
- if(clss->mono_ctor) {
- // call static Main method
- MonoObject *ret = mono_runtime_invoke(clss->mono_ctor,x->mono_obj,NULL,NULL);
- if(ret) {
- post("Warning: returned value from %s::.ctor ignored",classname->s_name);
- // ??? do we have to mark ret as free?
- }
- }
- else
- post("Warning: no %s.Main method found",classname);
-
- return x;
-}
-
-void clr_free(t_clr *x)
-{
-}
-
-static int classloader(char *dirname, char *classname)
-{
- t_clr_class *clr_class = NULL;
- t_symbol *classsym;
- MonoAssembly *assembly;
- MonoImage *image;
- MonoMethod *method;
-
+// gpointer args = &s;
+// mono_runtime_invoke(clr_symbol_ctor,symobj,&args,NULL);
+ // setting the field directly doesn't seem to work?!
+ mono_field_set_value(symobj,clr_symbol_ptr,s);
+ gpointer args = symobj;
+ mono_runtime_invoke(x->clr_clss->method_symbol,x->mono_obj,&args,NULL);
+}
+
+static void clr_method_list(t_clr *x,int argc, t_atom *argv)
+{
+ assert(x && x->clr_clss && x->clr_clss->method_list);
+}
+
+static void clr_method_pointer(t_clr *x,t_gpointer *ptr)
+{
+ assert(x && x->clr_clss && x->clr_clss->method_pointer);
+}
+
+static void clr_method_anything(t_clr *x,t_symbol *sl, int argc, t_atom *argv)
+{
+#if 0
+ assert(x && x->clr_clss);
+ ClrMethodMap *methods = x->clr_clss->methods;
+ if(methods) {
+ ClrMethodMap::iterator it = methods->find(sl);
+ if(it != methods->end()) {
+ // \TODO call m
+ return;
+ }
+ }
+ if(x->clr_clss->method_anything) {
+ // \TODO call methodanything
+ }
+ else
+ post("CLR - no method for %s found",sl->s_name);
+#else
+ assert(x && x->clr_clss && x->clr_clss->method_anything);
+#endif
+}
+
+
+// this function is called by mono when it wants post messages to pd
+static void PD_Post(MonoString *str)
+{
+ post("%s",mono_string_to_utf8(str));
+}
+
+// this function is called by mono when it wants post messages to pd
+static void PD_PostError(MonoString *str)
+{
+ error("%s",mono_string_to_utf8(str));
+}
+
+// this function is called by mono when it wants post messages to pd
+static void PD_PostBug(MonoString *str)
+{
+ bug("%s",mono_string_to_utf8(str));
+}
+
+// this function is called by mono when it wants post messages to pd
+static void PD_PostVerbose(int lvl,MonoString *str)
+{
+ verbose(lvl,"%s",mono_string_to_utf8(str));
+}
+
+static void *PD_GenSym(MonoString *str)
+{
+ return gensym(mono_string_to_utf8(str));
+}
+
+static MonoString *PD_EvalSym(MonoObject *symobj)
+{
+ t_symbol *sym;
+ mono_field_get_value(symobj,clr_symbol_ptr,&sym);
+ return mono_string_new(monodomain,sym->s_name);
+}
+
+
+#if 0
+// this function is called by mono when it wants post messages to pd
+static void PD_AddMethod(MonoObject *symobj,MonoObject *obj)
+{
+ assert(clr_setup_class);
+
+// char *tag = mono_string_to_utf8(str);
+// post("register method %s",tag);
+ t_symbol *sym;
+ mono_field_get_value(symobj,clr_symbol_ptr,&sym);
+
+ // \TODO convert from obj
+ MonoMethod *m = NULL;
+
+ if(sym == &s_bang) {
+ if(!clr_setup_class->method_bang)
+ class_addbang(clr_setup_class->pd_class,clr_method_bang);
+ clr_setup_class->method_bang = m;
+ }
+ else if(sym == &s_float) {
+ if(!clr_setup_class->method_bang)
+ class_addfloat(clr_setup_class->pd_class,clr_method_float);
+ clr_setup_class->method_bang = m;
+ }
+ else if(sym == &s_symbol) {
+ if(!clr_setup_class->method_symbol)
+ class_addsymbol(clr_setup_class->pd_class,clr_method_symbol);
+ clr_setup_class->method_symbol = m;
+ }
+ else if(sym == &s_list) {
+ if(!clr_setup_class->method_list)
+ class_addlist(clr_setup_class->pd_class,clr_method_list);
+ clr_setup_class->method_list = m;
+ }
+ else if(sym == &s_pointer) {
+ if(!clr_setup_class->method_pointer)
+ class_addpointer(clr_setup_class->pd_class,clr_method_pointer);
+ clr_setup_class->method_pointer = m;
+ }
+ else if(sym == &s_) {
+ if(!clr_setup_class->method_anything && !clr_setup_class->methods) // only register once!
+ class_addanything(clr_setup_class->pd_class,clr_method_anything);
+ clr_setup_class->method_anything = m;
+ }
+ else {
+ if(!clr_setup_class->methods) {
+ // no methods yet
+ clr_setup_class->methods = new ClrMethodMap;
+ if(!clr_setup_class->method_anything) // only register once!
+ class_addanything(clr_setup_class->pd_class,clr_method_anything);
+ }
+
+ // add tag to map
+ (*clr_setup_class->methods)[sym] = m;
+ }
+}
+#endif
+
+void *clr_new(t_symbol *classname, int argc, t_atom *argv)
+{
+ // find class name in map
+ ClrMap::iterator it = clr_map.find(classname);
+ if(it == clr_map.end()) {
+ error("CLR class %s not found",classname->s_name);
+ return NULL;
+ }
+
+ t_clr_class *clss = it->second;
+
+ // make instance
+ t_clr *x = (t_clr *)pd_new(clss->pd_class);
+ x->mono_obj = mono_object_new (monodomain,clss->mono_class);
+ if(!x->mono_obj) {
+ pd_free((t_pd *)x);
+ error("CLR class %s could not be instantiated",classname->s_name);
+ return NULL;
+ }
+
+ // store class pointer
+ x->clr_clss = clss;
+
+ // store our object pointer in External::ptr member
+ mono_field_set_value(x->mono_obj,clss->mono_obj_field,x);
+
+ // ok, we have an object - look for constructor
+ if(clss->mono_ctor) {
+ // call static Main method
+ MonoObject *ret = mono_runtime_invoke(clss->mono_ctor,x->mono_obj,NULL,NULL);
+ if(ret) {
+ post("Warning: returned value from %s::.ctor ignored",classname->s_name);
+ // ??? do we have to mark ret as free?
+ }
+ }
+ else
+ post("Warning: no %s.Main method found",classname);
+
+ return x;
+}
+
+void clr_free(t_clr *x)
+{
+}
+
+static int classloader(char *dirname, char *classname)
+{
+ t_clr_class *clr_class = NULL;
+ t_symbol *classsym;
+ MonoAssembly *assembly;
+ MonoImage *image;
+ MonoMethod *method;
+
char dirbuf[MAXPDSTRING],*nameptr;
// search for classname.dll in the PD path
int fd;
@@ -967,185 +967,185 @@ static int classloader(char *dirname, char *classname)
goto bailout;
// found
- close(fd);
-
- clr_class = (t_clr_class *)getbytes(sizeof(t_clr_class));
-
-// clr_class->methods = NULL;
-
- // try to load assembly
+ close(fd);
+
+ clr_class = (t_clr_class *)getbytes(sizeof(t_clr_class));
+
+// clr_class->methods = NULL;
+
+ // try to load assembly
char path[MAXPDSTRING];
- strcpy(path,dirname);
- strcat(path,"/");
-// strcat(path,dirbuf);
-// strcat(path,"/");
- strcat(path,nameptr);
-
- assembly = mono_domain_assembly_open(monodomain,path);
- if(!assembly) {
- error("clr: file %s couldn't be loaded!",path);
- goto bailout;
- }
-
- image = mono_assembly_get_image(assembly);
- assert(image);
-
- // try to find class
- // "" means no namespace
- clr_class->mono_class = mono_class_from_name(image,"",classname);
- if(!clr_class->mono_class) {
- error("Can't find %s class in %s\n",classname,mono_image_get_filename(image));
- goto bailout;
- }
-
- clr_class->mono_obj_field = mono_class_get_field_from_name(clr_class->mono_class,"ptr");
- assert(clr_class->mono_obj_field);
-
- // ok
-
- post("CLR class %s loaded",classname);
-
- // make new class (with classname)
- classsym = gensym(classname);
- clr_class->pd_class = class_new(classsym,(t_newmethod)clr_new,(t_method)clr_free, sizeof(t_clr), CLASS_DEFAULT, A_GIMME, 0);
-
- // find static Main method
-
- method = mono_method_desc_search_in_class(clr_desc_main,clr_class->mono_class);
- if(method) {
- // set current class
- clr_setup_class = clr_class;
-
- // call static Main method
- MonoObject *ret = mono_runtime_invoke(method,NULL,NULL,NULL);
-
- // unset current class
- clr_setup_class = NULL;
-
- if(ret) {
- post("CLR - Warning: returned value from %s.Main ignored",classname);
- // ??? do we have to mark ret as free?
- }
- }
- else
- post("CLR - Warning: no %s.Main method found",classname);
-
- // find and save constructor
- clr_class->mono_ctor = mono_method_desc_search_in_class(clr_desc_ctor,clr_class->mono_class);
-
- // find && register methods
+ strcpy(path,dirname);
+ strcat(path,"/");
+// strcat(path,dirbuf);
+// strcat(path,"/");
+ strcat(path,nameptr);
+
+ assembly = mono_domain_assembly_open(monodomain,path);
+ if(!assembly) {
+ error("clr: file %s couldn't be loaded!",path);
+ goto bailout;
+ }
+
+ image = mono_assembly_get_image(assembly);
+ assert(image);
+
+ // try to find class
+ // "" means no namespace
+ clr_class->mono_class = mono_class_from_name(image,"",classname);
+ if(!clr_class->mono_class) {
+ error("Can't find %s class in %s\n",classname,mono_image_get_filename(image));
+ goto bailout;
+ }
+
+ clr_class->mono_obj_field = mono_class_get_field_from_name(clr_class->mono_class,"ptr");
+ assert(clr_class->mono_obj_field);
+
+ // ok
+
+ post("CLR class %s loaded",classname);
+
+ // make new class (with classname)
+ classsym = gensym(classname);
+ clr_class->pd_class = class_new(classsym,(t_newmethod)clr_new,(t_method)clr_free, sizeof(t_clr), CLASS_DEFAULT, A_GIMME, 0);
+
+ // find static Main method
+
+ method = mono_method_desc_search_in_class(clr_desc_main,clr_class->mono_class);
+ if(method) {
+ // set current class
+ clr_setup_class = clr_class;
+
+ // call static Main method
+ MonoObject *ret = mono_runtime_invoke(method,NULL,NULL,NULL);
+
+ // unset current class
+ clr_setup_class = NULL;
+
+ if(ret) {
+ post("CLR - Warning: returned value from %s.Main ignored",classname);
+ // ??? do we have to mark ret as free?
+ }
+ }
+ else
+ post("CLR - Warning: no %s.Main method found",classname);
+
+ // find and save constructor
+ clr_class->mono_ctor = mono_method_desc_search_in_class(clr_desc_ctor,clr_class->mono_class);
+
+ // find && register methods
if((clr_class->method_bang = mono_method_desc_search_in_class(clr_desc_bang,clr_class->mono_class)) != NULL)
- class_addbang(clr_class->pd_class,clr_method_bang);
- if((clr_class->method_float = mono_method_desc_search_in_class(clr_desc_float,clr_class->mono_class)) != NULL)
- class_addfloat(clr_class->pd_class,clr_method_float);
- if((clr_class->method_symbol = mono_method_desc_search_in_class(clr_desc_symbol,clr_class->mono_class)) != NULL)
- class_addsymbol(clr_class->pd_class,clr_method_symbol);
- if((clr_class->method_pointer = mono_method_desc_search_in_class(clr_desc_pointer,clr_class->mono_class)) != NULL)
- class_addpointer(clr_class->pd_class,clr_method_pointer);
- if((clr_class->method_list = mono_method_desc_search_in_class(clr_desc_list,clr_class->mono_class)) != NULL)
- class_addlist(clr_class->pd_class,clr_method_list);
- if((clr_class->method_anything = mono_method_desc_search_in_class(clr_desc_anything,clr_class->mono_class)) != NULL)
- class_addanything(clr_class->pd_class,clr_method_anything);
-
-
- // put into map
- clr_map[classsym] = clr_class;
-
- post("Loaded class %s OK",classname);
-
- return 1;
-
-bailout:
- if(clr_class) freebytes(clr_class,sizeof(t_clr_class));
-
- return 0;
-}
-
-extern "C"
-#ifdef _MSC_VER
-__declspec(dllexport)
-#endif
-void clr_setup(void)
-{
-#ifdef _WIN32
- // set mono paths
- const char *monopath = getenv("MONO_PATH");
- if(!monopath) {
- error("CLR - Please set the MONO_PATH environment variable to the folder of your MONO installation - CLR not loaded!");
- return;
- }
-
- char tlib[256],tconf[256];
- strcpy(tlib,monopath);
- strcat(tlib,"/lib");
- strcpy(tconf,monopath);
- strcat(tconf,"/etc");
- mono_set_dirs(tlib,tconf);
-#endif
+ class_addbang(clr_class->pd_class,clr_method_bang);
+ if((clr_class->method_float = mono_method_desc_search_in_class(clr_desc_float,clr_class->mono_class)) != NULL)
+ class_addfloat(clr_class->pd_class,clr_method_float);
+ if((clr_class->method_symbol = mono_method_desc_search_in_class(clr_desc_symbol,clr_class->mono_class)) != NULL)
+ class_addsymbol(clr_class->pd_class,clr_method_symbol);
+ if((clr_class->method_pointer = mono_method_desc_search_in_class(clr_desc_pointer,clr_class->mono_class)) != NULL)
+ class_addpointer(clr_class->pd_class,clr_method_pointer);
+ if((clr_class->method_list = mono_method_desc_search_in_class(clr_desc_list,clr_class->mono_class)) != NULL)
+ class_addlist(clr_class->pd_class,clr_method_list);
+ if((clr_class->method_anything = mono_method_desc_search_in_class(clr_desc_anything,clr_class->mono_class)) != NULL)
+ class_addanything(clr_class->pd_class,clr_method_anything);
+
+
+ // put into map
+ clr_map[classsym] = clr_class;
+
+ post("Loaded class %s OK",classname);
+
+ return 1;
+
+bailout:
+ if(clr_class) freebytes(clr_class,sizeof(t_clr_class));
+
+ return 0;
+}
+
+extern "C"
+#ifdef _MSC_VER
+__declspec(dllexport)
+#endif
+void clr_setup(void)
+{
+#ifdef _WIN32
+ // set mono paths
+ const char *monopath = getenv("MONO_PATH");
+ if(!monopath) {
+ error("CLR - Please set the MONO_PATH environment variable to the folder of your MONO installation - CLR not loaded!");
+ return;
+ }
+
+ char tlib[256],tconf[256];
+ strcpy(tlib,monopath);
+ strcat(tlib,"/lib");
+ strcpy(tconf,monopath);
+ strcat(tconf,"/etc");
+ mono_set_dirs(tlib,tconf);
+#endif
try {
monodomain = mono_jit_init("PureData");
- }
+ }
catch(...) {
monodomain = NULL;
}
- if(monodomain) {
- // add mono to C hooks
- mono_add_internal_call("PureData.Core::Post",(const void *)PD_Post);
- mono_add_internal_call("PureData.Core::PostError",(const void *)PD_PostError);
- mono_add_internal_call("PureData.Core::PostBug",(const void *)PD_PostBug);
- mono_add_internal_call("PureData.Core::PostVerbose",(const void *)PD_PostVerbose);
-
- mono_add_internal_call("PureData.Core::GenSym", (const void *)PD_GenSym);
- mono_add_internal_call("PureData.Core::EvalSym", (const void *)PD_EvalSym);
-
-
- MonoAssembly *assembly = mono_domain_assembly_open (monodomain, "PureData.dll");
- if(!assembly) {
- error("clr: assembly PureData.dll not found!");
- return;
- }
-
- MonoImage *image = mono_assembly_get_image(assembly);
- assert(image);
-
- // load important classes
- clr_atom = mono_class_from_name(image,"PureData","Atom");
- assert(clr_atom);
- clr_symbol = mono_class_from_name(image,"PureData","Symbol");
- assert(clr_symbol);
- clr_symbol_ptr = mono_class_get_field_from_name(clr_symbol,"ptr");
- assert(clr_symbol_ptr);
-// MonoMethodDesc *d = mono_method_desc_new("::.ctor(System.IntPtr)",FALSE);
-// assert(d);
-// clr_symbol_ctor = mono_method_desc_search_in_class(d,clr_symbol);
-// assert(clr_symbol_ctor);
-
- clr_desc_main = mono_method_desc_new("::Main",FALSE);
- assert(clr_desc_main);
- clr_desc_ctor = mono_method_desc_new("::.ctor",FALSE);
- assert(clr_desc_ctor);
-
- clr_desc_bang = mono_method_desc_new(":MethodBang",FALSE);
- assert(clr_desc_bang);
- clr_desc_float = mono_method_desc_new(":MethodFloat",FALSE);
- assert(clr_desc_float);
- clr_desc_symbol = mono_method_desc_new(":MethodSymbol",FALSE);
- assert(clr_desc_symbol);
- clr_desc_pointer = mono_method_desc_new(":MethodPointer",TRUE);
- assert(clr_desc_pointer);
- clr_desc_list = mono_method_desc_new(":MethodList",TRUE);
- assert(clr_desc_list);
- clr_desc_anything = mono_method_desc_new(":MethodAnything",TRUE);
- assert(clr_desc_anything);
-
- // install loader hook
- sys_loader(classloader);
-
- // ready!
- post("CLR - (c) Davide Morelli, Thomas Grill");
- }
- else
- error("clr: mono domain couldn't be initialized!");
-}
+ if(monodomain) {
+ // add mono to C hooks
+ mono_add_internal_call("PureData.Core::Post",(const void *)PD_Post);
+ mono_add_internal_call("PureData.Core::PostError",(const void *)PD_PostError);
+ mono_add_internal_call("PureData.Core::PostBug",(const void *)PD_PostBug);
+ mono_add_internal_call("PureData.Core::PostVerbose",(const void *)PD_PostVerbose);
+
+ mono_add_internal_call("PureData.Core::GenSym", (const void *)PD_GenSym);
+ mono_add_internal_call("PureData.Core::EvalSym", (const void *)PD_EvalSym);
+
+
+ MonoAssembly *assembly = mono_domain_assembly_open (monodomain, "PureData.dll");
+ if(!assembly) {
+ error("clr: assembly PureData.dll not found!");
+ return;
+ }
+
+ MonoImage *image = mono_assembly_get_image(assembly);
+ assert(image);
+
+ // load important classes
+ clr_atom = mono_class_from_name(image,"PureData","Atom");
+ assert(clr_atom);
+ clr_symbol = mono_class_from_name(image,"PureData","Symbol");
+ assert(clr_symbol);
+ clr_symbol_ptr = mono_class_get_field_from_name(clr_symbol,"ptr");
+ assert(clr_symbol_ptr);
+// MonoMethodDesc *d = mono_method_desc_new("::.ctor(System.IntPtr)",FALSE);
+// assert(d);
+// clr_symbol_ctor = mono_method_desc_search_in_class(d,clr_symbol);
+// assert(clr_symbol_ctor);
+
+ clr_desc_main = mono_method_desc_new("::Main",FALSE);
+ assert(clr_desc_main);
+ clr_desc_ctor = mono_method_desc_new("::.ctor",FALSE);
+ assert(clr_desc_ctor);
+
+ clr_desc_bang = mono_method_desc_new(":MethodBang",FALSE);
+ assert(clr_desc_bang);
+ clr_desc_float = mono_method_desc_new(":MethodFloat",FALSE);
+ assert(clr_desc_float);
+ clr_desc_symbol = mono_method_desc_new(":MethodSymbol",FALSE);
+ assert(clr_desc_symbol);
+ clr_desc_pointer = mono_method_desc_new(":MethodPointer",TRUE);
+ assert(clr_desc_pointer);
+ clr_desc_list = mono_method_desc_new(":MethodList",TRUE);
+ assert(clr_desc_list);
+ clr_desc_anything = mono_method_desc_new(":MethodAnything",TRUE);
+ assert(clr_desc_anything);
+
+ // install loader hook
+ sys_loader(classloader);
+
+ // ready!
+ post("CLR - (c) Davide Morelli, Thomas Grill");
+ }
+ else
+ error("clr: mono domain couldn't be initialized!");
+}
diff --git a/external/AssemblyInfo.cs b/external/AssemblyInfo.cs
index 1c62411..f341568 100755
--- a/external/AssemblyInfo.cs
+++ b/external/AssemblyInfo.cs
@@ -1,58 +1,58 @@
-using System.Reflection;
-using System.Runtime.CompilerServices;
-
-//
-// Le informazioni generali relative a un assembly sono controllate dal seguente
-// insieme di attributi. Per modificare le informazioni associate a un assembly
-// occorre quindi modificare i valori di questi attributi.
-//
-[assembly: AssemblyTitle("")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("")]
-[assembly: AssemblyCopyright("")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-
-//
-// Le informazioni sulla versione di un assembly sono costituite dai seguenti quattro valori:
-//
-// Numero di versione principale
-// Numero di versione secondario
-// Numero revisione
-// Numero build
-//
-// È possibile specificare tutti i valori o impostare come predefiniti i valori Numero revisione e Numero build
-// utilizzando l'asterisco (*) come illustrato di seguito:
-
-[assembly: AssemblyVersion("1.0.*")]
-
-//
-// Per firmare l'assembly è necessario specificare una chiave da utilizzare.
-// Fare riferimento alla documentazione di Microsoft .NET Framework per ulteriori informazioni sulla firma degli assembly.
-//
-// Utilizzare gli attributi elencati di seguito per verificare la chiave utilizzata per la firma.
-//
-// Note:
-// (*) Se non è specificata alcuna chiave, non sarà possibile firmare l'assembly.
-// (*) KeyName fa riferimento a una chiave installata nel provider di servizi di
-// crittografia (CSP) sul computer in uso. KeyFile fa riferimento a un file che contiene
-// una chiave.
-// (*) Se entrambi i valori KeyFile e KeyName sono specificati, si
-// verificherà il seguente processo:
-// (1) Se KeyName è presente in CSP, verrà utilizzata tale chiave.
-// (2) Se KeyName non esiste e KeyFile esiste, la chiave
-// di KeyFile verrà installata nel CSP e utilizzata.
-// (*) Per creare un KeyFile, è possibile utilizzare l'utilità sn.exe (Strong Name).
-// Quando si specifica il KeyFile, il percorso dovrà essere
-// relativo alla directory di output del progetto, ovvero
-// %Project Directory%\obj\<configuration>. Se ad esempio il KeyFile si
-// trova nella directory del progetto, occorre specificare l'attributo AssemblyKeyFile
-// come [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
-// (*) La firma ritardata è un'opzione avanzata. Vedere la documentazione di Microsoft
-// .NET Framework per ulteriori informazioni.
-//
-[assembly: AssemblyDelaySign(false)]
-[assembly: AssemblyKeyFile("")]
-[assembly: AssemblyKeyName("")]
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+//
+// Le informazioni generali relative a un assembly sono controllate dal seguente
+// insieme di attributi. Per modificare le informazioni associate a un assembly
+// occorre quindi modificare i valori di questi attributi.
+//
+[assembly: AssemblyTitle("")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("")]
+[assembly: AssemblyCopyright("")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+//
+// Le informazioni sulla versione di un assembly sono costituite dai seguenti quattro valori:
+//
+// Numero di versione principale
+// Numero di versione secondario
+// Numero revisione
+// Numero build
+//
+// È possibile specificare tutti i valori o impostare come predefiniti i valori Numero revisione e Numero build
+// utilizzando l'asterisco (*) come illustrato di seguito:
+
+[assembly: AssemblyVersion("1.0.*")]
+
+//
+// Per firmare l'assembly è necessario specificare una chiave da utilizzare.
+// Fare riferimento alla documentazione di Microsoft .NET Framework per ulteriori informazioni sulla firma degli assembly.
+//
+// Utilizzare gli attributi elencati di seguito per verificare la chiave utilizzata per la firma.
+//
+// Note:
+// (*) Se non è specificata alcuna chiave, non sarà possibile firmare l'assembly.
+// (*) KeyName fa riferimento a una chiave installata nel provider di servizi di
+// crittografia (CSP) sul computer in uso. KeyFile fa riferimento a un file che contiene
+// una chiave.
+// (*) Se entrambi i valori KeyFile e KeyName sono specificati, si
+// verificherà il seguente processo:
+// (1) Se KeyName è presente in CSP, verrà utilizzata tale chiave.
+// (2) Se KeyName non esiste e KeyFile esiste, la chiave
+// di KeyFile verrà installata nel CSP e utilizzata.
+// (*) Per creare un KeyFile, è possibile utilizzare l'utilità sn.exe (Strong Name).
+// Quando si specifica il KeyFile, il percorso dovrà essere
+// relativo alla directory di output del progetto, ovvero
+// %Project Directory%\obj\<configuration>. Se ad esempio il KeyFile si
+// trova nella directory del progetto, occorre specificare l'attributo AssemblyKeyFile
+// come [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
+// (*) La firma ritardata è un'opzione avanzata. Vedere la documentazione di Microsoft
+// .NET Framework per ulteriori informazioni.
+//
+[assembly: AssemblyDelaySign(false)]
+[assembly: AssemblyKeyFile("")]
+[assembly: AssemblyKeyName("")]
diff --git a/external/Counter.cs b/external/Counter.cs
index 32f9409..9ec6ddc 100755
--- a/external/Counter.cs
+++ b/external/Counter.cs
@@ -1,74 +1,74 @@
-using System;
-
-/// <summary>
-/// Descrizione di riepilogo per Counter.
-/// </summary>
-public class Counter:
- PureData.External
-{
- public Counter()
- {
- Post("Count");
-
-// EventFloat += new MethodFloat(MyFloat);
- }
-
- public Counter(PureData.Atom[] args)
- {
- Post("Count with args");
-
-// pd.AddInlet(x, "init", ParametersType.Float);
-// pd.AddOutlet(x, ParametersType.Float);
- }
-
- // this function MUST exist
- public static void Main()
- {
- Post("Count.Main");
- }
-
-/*
- public void MyBang()
- {
- Post("Count-BANG");
- }
-
- public void MyFloat(float f)
- {
- Post(String.Format("Count-FLOAT {0}",f));
- }
-*/
- protected override void MethodBang()
- {
- Post("Count-BANG");
- }
-
- protected override void MethodFloat(float f)
- {
- Post("Count-FLOAT "+f.ToString());
- }
-
- protected override void MethodSymbol(PureData.Symbol s)
- {
- Post("Count-SYMBOL "+s.ToString());
- }
-
- /*
- public void Init(float f)
- {
- curr = (int) f;
- }
-
- public void SendOut()
- {
- pd.SendToOutlet(x, 0, new Atom(curr));
- }
-
- public void Sum(float f)
- {
- curr += (int) f;
- pd.SendToOutlet(x, 0, new Atom(curr));
- }
-
-*/
-}
+using System;
+
+/// <summary>
+/// Descrizione di riepilogo per Counter.
+/// </summary>
+public class Counter:
+ PureData.External
+{
+ public Counter()
+ {
+ Post("Count");
+
+// EventFloat += new MethodFloat(MyFloat);
+ }
+
+ public Counter(PureData.Atom[] args)
+ {
+ Post("Count with args");
+
+// pd.AddInlet(x, "init", ParametersType.Float);
+// pd.AddOutlet(x, ParametersType.Float);
+ }
+
+ // this function MUST exist
+ public static void Main()
+ {
+ Post("Count.Main");
+ }
+
+/*
+ public void MyBang()
+ {
+ Post("Count-BANG");
+ }
+
+ public void MyFloat(float f)
+ {
+ Post(String.Format("Count-FLOAT {0}",f));
+ }
+*/
+ protected override void MethodBang()
+ {
+ Post("Count-BANG");
+ }
+
+ protected override void MethodFloat(float f)
+ {
+ Post("Count-FLOAT "+f.ToString());
+ }
+
+ protected override void MethodSymbol(PureData.Symbol s)
+ {
+ Post("Count-SYMBOL "+s.ToString());
+ }
+
+ /*
+ public void Init(float f)
+ {
+ curr = (int) f;
+ }
+
+ public void SendOut()
+ {
+ pd.SendToOutlet(x, 0, new Atom(curr));
+ }
+
+ public void Sum(float f)
+ {
+ curr += (int) f;
+ pd.SendToOutlet(x, 0, new Atom(curr));
+ }
+
+*/
+}
diff --git a/pd/AssemblyInfo.cs b/pd/AssemblyInfo.cs
index a9f1b83..93484d8 100755
--- a/pd/AssemblyInfo.cs
+++ b/pd/AssemblyInfo.cs
@@ -1,58 +1,58 @@
-using System.Reflection;
-using System.Runtime.CompilerServices;
-
-//
-// Le informazioni generali relative a un assembly sono controllate dal seguente
-// insieme di attributi. Per modificare le informazioni associate a un assembly
-// occorre quindi modificare i valori di questi attributi.
-//
-[assembly: AssemblyTitle("PureData")]
-[assembly: AssemblyDescription("bridge between C sharp externals and pd")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("")]
-[assembly: AssemblyCopyright("Davide Morelli, Thomas Grill")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-
-//
-// Le informazioni sulla versione di un assembly sono costituite dai seguenti quattro valori:
-//
-// Numero di versione principale
-// Numero di versione secondario
-// Numero revisione
-// Numero build
-//
-// È possibile specificare tutti i valori o impostare come predefiniti i valori Numero revisione e Numero build
-// utilizzando l'asterisco (*) come illustrato di seguito:
-
-[assembly: AssemblyVersion("1.0.*")]
-
-//
-// Per firmare l'assembly è necessario specificare una chiave da utilizzare.
-// Fare riferimento alla documentazione di Microsoft .NET Framework per ulteriori informazioni sulla firma degli assembly.
-//
-// Utilizzare gli attributi elencati di seguito per verificare la chiave utilizzata per la firma.
-//
-// Note:
-// (*) Se non è specificata alcuna chiave, non sarà possibile firmare l'assembly.
-// (*) KeyName fa riferimento a una chiave installata nel provider di servizi di
-// crittografia (CSP) sul computer in uso. KeyFile fa riferimento a un file che contiene
-// una chiave.
-// (*) Se entrambi i valori KeyFile e KeyName sono specificati, si
-// verificherà il seguente processo:
-// (1) Se KeyName è presente in CSP, verrà utilizzata tale chiave.
-// (2) Se KeyName non esiste e KeyFile esiste, la chiave
-// di KeyFile verrà installata nel CSP e utilizzata.
-// (*) Per creare un KeyFile, è possibile utilizzare l'utilità sn.exe (Strong Name).
-// Quando si specifica il KeyFile, il percorso dovrà essere
-// relativo alla directory di output del progetto, ovvero
-// %Project Directory%\obj\<configuration>. Se ad esempio il KeyFile si
-// trova nella directory del progetto, occorre specificare l'attributo AssemblyKeyFile
-// come [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
-// (*) La firma ritardata è un'opzione avanzata. Vedere la documentazione di Microsoft
-// .NET Framework per ulteriori informazioni.
-//
-[assembly: AssemblyDelaySign(false)]
-[assembly: AssemblyKeyFile("")]
-[assembly: AssemblyKeyName("")]
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+//
+// Le informazioni generali relative a un assembly sono controllate dal seguente
+// insieme di attributi. Per modificare le informazioni associate a un assembly
+// occorre quindi modificare i valori di questi attributi.
+//
+[assembly: AssemblyTitle("PureData")]
+[assembly: AssemblyDescription("bridge between C sharp externals and pd")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("")]
+[assembly: AssemblyCopyright("Davide Morelli, Thomas Grill")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+//
+// Le informazioni sulla versione di un assembly sono costituite dai seguenti quattro valori:
+//
+// Numero di versione principale
+// Numero di versione secondario
+// Numero revisione
+// Numero build
+//
+// È possibile specificare tutti i valori o impostare come predefiniti i valori Numero revisione e Numero build
+// utilizzando l'asterisco (*) come illustrato di seguito:
+
+[assembly: AssemblyVersion("1.0.*")]
+
+//
+// Per firmare l'assembly è necessario specificare una chiave da utilizzare.
+// Fare riferimento alla documentazione di Microsoft .NET Framework per ulteriori informazioni sulla firma degli assembly.
+//
+// Utilizzare gli attributi elencati di seguito per verificare la chiave utilizzata per la firma.
+//
+// Note:
+// (*) Se non è specificata alcuna chiave, non sarà possibile firmare l'assembly.
+// (*) KeyName fa riferimento a una chiave installata nel provider di servizi di
+// crittografia (CSP) sul computer in uso. KeyFile fa riferimento a un file che contiene
+// una chiave.
+// (*) Se entrambi i valori KeyFile e KeyName sono specificati, si
+// verificherà il seguente processo:
+// (1) Se KeyName è presente in CSP, verrà utilizzata tale chiave.
+// (2) Se KeyName non esiste e KeyFile esiste, la chiave
+// di KeyFile verrà installata nel CSP e utilizzata.
+// (*) Per creare un KeyFile, è possibile utilizzare l'utilità sn.exe (Strong Name).
+// Quando si specifica il KeyFile, il percorso dovrà essere
+// relativo alla directory di output del progetto, ovvero
+// %Project Directory%\obj\<configuration>. Se ad esempio il KeyFile si
+// trova nella directory del progetto, occorre specificare l'attributo AssemblyKeyFile
+// come [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
+// (*) La firma ritardata è un'opzione avanzata. Vedere la documentazione di Microsoft
+// .NET Framework per ulteriori informazioni.
+//
+[assembly: AssemblyDelaySign(false)]
+[assembly: AssemblyKeyFile("")]
+[assembly: AssemblyKeyName("")]
diff --git a/pd/Atom.cs b/pd/Atom.cs
index 532956e..e3b6f3c 100755
--- a/pd/Atom.cs
+++ b/pd/Atom.cs
@@ -1,104 +1,104 @@
-using System;
-using System.Runtime.InteropServices; // for structures
-
-namespace PureData
-{
- public enum AtomType {Null = 0, Float = 1, Symbol = 2, Pointer = 3};
+using System;
+using System.Runtime.InteropServices; // for structures
- [StructLayout (LayoutKind.Sequential)]
+namespace PureData
+{
+ public enum AtomType {Null = 0, Float = 1, Symbol = 2, Pointer = 3};
+
+ [StructLayout (LayoutKind.Sequential)]
sealed public class Symbol
- {
- // this should NOT be public
- readonly private IntPtr ptr;
-
- public Symbol(IntPtr p)
- {
- ptr = p;
- }
-
- public Symbol(Symbol s)
- {
- ptr = s.ptr;
- }
-
- public Symbol(string s)
- {
- ptr = Core.GenSym(s);
- }
-
- override public string ToString()
- {
- return Core.EvalSym(this);
- }
- }
+ {
+ // this should NOT be public
+ readonly private IntPtr ptr;
+
+ public Symbol(IntPtr p)
+ {
+ ptr = p;
+ }
+
+ public Symbol(Symbol s)
+ {
+ ptr = s.ptr;
+ }
+
+ public Symbol(string s)
+ {
+ ptr = Core.GenSym(s);
+ }
+
+ override public string ToString()
+ {
+ return Core.EvalSym(this);
+ }
+ }
- [StructLayout (LayoutKind.Sequential)]
+ [StructLayout (LayoutKind.Sequential)]
sealed public class Pointer
- {
- public IntPtr ptr;
+ {
+ public IntPtr ptr;
}
- [StructLayout (LayoutKind.Explicit)]
- public struct Word
- {
- [FieldOffset(0)] public float w_float;
- [FieldOffset(0)] public Symbol w_symbol;
- [FieldOffset(0)] public Pointer w_pointer;
- }
+ [StructLayout (LayoutKind.Explicit)]
+ public struct Word
+ {
+ [FieldOffset(0)] public float w_float;
+ [FieldOffset(0)] public Symbol w_symbol;
+ [FieldOffset(0)] public Pointer w_pointer;
+ }
- //[StructLayout (LayoutKind.Explicit)]
- [StructLayout (LayoutKind.Sequential)]
+ //[StructLayout (LayoutKind.Explicit)]
+ [StructLayout (LayoutKind.Sequential)]
sealed public class Atom
- {
-
- public AtomType type;
- public Word word;
-
- public Atom(float f)
- {
- type = AtomType.Float;
- word.w_float = f;
- }
-
- public Atom(int i)
- {
- type = AtomType.Float;
- word.w_float = (float)i;
- }
-
- public Atom(Symbol s)
- {
- type = AtomType.Symbol;
- word.w_symbol = s;
- }
-
- public Atom(string s)
- {
- type = AtomType.Symbol;
- word.w_symbol = new Symbol(s);
- }
- }
-
-
- // this struct is relative to this c struct, see clr.c
-
- /*
- // simplyfied atom
- typedef struct atom_simple atom_simple;
+ {
+
+ public AtomType type;
+ public Word word;
+
+ public Atom(float f)
+ {
+ type = AtomType.Float;
+ word.w_float = f;
+ }
+
+ public Atom(int i)
+ {
+ type = AtomType.Float;
+ word.w_float = (float)i;
+ }
+
+ public Atom(Symbol s)
+ {
+ type = AtomType.Symbol;
+ word.w_symbol = s;
+ }
+
+ public Atom(string s)
+ {
+ type = AtomType.Symbol;
+ word.w_symbol = new Symbol(s);
+ }
+ }
+
+
+ // this struct is relative to this c struct, see clr.c
+
+ /*
+ // simplyfied atom
+ typedef struct atom_simple atom_simple;
typedef enum
{
A_S_NULL=0,
A_S_FLOAT=1,
A_S_SYMBOL=2,
- } t_atomtype_simple;
- typedef struct atom_simple
- {
- t_atomtype_simple a_type;
- union{
+ } t_atomtype_simple;
+ typedef struct atom_simple
+ {
+ t_atomtype_simple a_type;
+ union{
float float_value;
- MonoString *string_value;
- } stuff;
- };
- */
-
+ MonoString *string_value;
+ } stuff;
+ };
+ */
+
} \ No newline at end of file
diff --git a/pd/PureData.cs b/pd/PureData.cs
index 2ff8cfe..2d6cf16 100644
--- a/pd/PureData.cs
+++ b/pd/PureData.cs
@@ -1,46 +1,46 @@
-using System;
-using System.Runtime.CompilerServices; // for extern import
-
-namespace PureData
-{
- // PD core functions
- public class Core
- {
- [MethodImplAttribute (MethodImplOptions.InternalCall)]
- public extern static void Post(string message);
-
- [MethodImplAttribute (MethodImplOptions.InternalCall)]
- public extern static void PostError(string message);
-
- [MethodImplAttribute (MethodImplOptions.InternalCall)]
- public extern static void PostBug(string message);
-
- [MethodImplAttribute (MethodImplOptions.InternalCall)]
- public extern static void PostVerbose(string message);
-
- [MethodImplAttribute (MethodImplOptions.InternalCall)]
- public extern static IntPtr GenSym(string sym);
-
- [MethodImplAttribute (MethodImplOptions.InternalCall)]
- public extern static string EvalSym(Symbol sym);
- }
-
- // This is the base class for a PD/CLR external
- public class External
- : Core
- {
- private readonly IntPtr ptr;
-
- protected virtual void MethodBang() { Post("No bang handler"); }
-
- protected virtual void MethodFloat(float f) { Post("No float handler"); }
-
- protected virtual void MethodSymbol(Symbol s) { Post("No symbol handler"); }
-
- protected virtual void MethodPointer(Pointer p) { Post("No pointer handler");}
-
- protected virtual void MethodList(Atom[] lst) { Post("No list handler"); }
-
- protected virtual void MethodAnything(Atom[] lst) { Post("No list handler"); }
- }
-}
+using System;
+using System.Runtime.CompilerServices; // for extern import
+
+namespace PureData
+{
+ // PD core functions
+ public class Core
+ {
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ public extern static void Post(string message);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ public extern static void PostError(string message);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ public extern static void PostBug(string message);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ public extern static void PostVerbose(string message);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ public extern static IntPtr GenSym(string sym);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ public extern static string EvalSym(Symbol sym);
+ }
+
+ // This is the base class for a PD/CLR external
+ public class External
+ : Core
+ {
+ private readonly IntPtr ptr;
+
+ protected virtual void MethodBang() { Post("No bang handler"); }
+
+ protected virtual void MethodFloat(float f) { Post("No float handler"); }
+
+ protected virtual void MethodSymbol(Symbol s) { Post("No symbol handler"); }
+
+ protected virtual void MethodPointer(Pointer p) { Post("No pointer handler");}
+
+ protected virtual void MethodList(Atom[] lst) { Post("No list handler"); }
+
+ protected virtual void MethodAnything(Atom[] lst) { Post("No list handler"); }
+ }
+}