aboutsummaryrefslogtreecommitdiff
path: root/PureData
diff options
context:
space:
mode:
Diffstat (limited to 'PureData')
-rwxr-xr-xPureData/AssemblyInfo.cs58
-rwxr-xr-xPureData/Atom.cs270
-rw-r--r--PureData/PureData.cs64
-rw-r--r--PureData/PureData.csproj105
-rwxr-xr-xPureData/README.txt3
5 files changed, 500 insertions, 0 deletions
diff --git a/PureData/AssemblyInfo.cs b/PureData/AssemblyInfo.cs
new file mode 100755
index 0000000..93484d8
--- /dev/null
+++ b/PureData/AssemblyInfo.cs
@@ -0,0 +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("")]
diff --git a/PureData/Atom.cs b/PureData/Atom.cs
new file mode 100755
index 0000000..6a29483
--- /dev/null
+++ b/PureData/Atom.cs
@@ -0,0 +1,270 @@
+using System;
+using System.Runtime.InteropServices; // for structures
+using System.Collections;
+#if NET_2_0
+using System.Collections.Generic;
+#endif
+
+namespace PureData
+{
+ [StructLayout (LayoutKind.Sequential)]
+ public unsafe struct Symbol
+ {
+ // this should NOT be public (or at least read only)
+ private readonly void *sym;
+
+ public Symbol(string s)
+ {
+ sym = Internal.SymGen(s);
+ }
+
+ public override string ToString()
+ {
+ return Internal.SymEval(sym);
+ }
+ }
+
+ [StructLayout (LayoutKind.Sequential)]
+ public unsafe struct Pointer
+ {
+ private readonly void *ptr;
+
+ public override string ToString()
+ {
+ if(sizeof(void *) == 4)
+ return ((int)ptr).ToString();
+ else
+ return ((long)ptr).ToString();
+ }
+ }
+
+ [StructLayout (LayoutKind.Sequential)]
+ public unsafe struct Atom
+ {
+ private enum AtomType {Null = 0, Float = 1, Symbol = 2, Pointer = 3};
+
+ [StructLayout (LayoutKind.Explicit)]
+ private struct Word
+ {
+ [FieldOffset(0)] public float w_float;
+ [FieldOffset(0)] public Symbol w_sym;
+ [FieldOffset(0)] public Pointer w_ptr;
+ }
+
+ private AtomType type;
+ private Word word;
+
+ public Atom(float f)
+ {
+ type = AtomType.Float;
+ word = new Word();
+ word.w_float = f;
+ }
+
+ public Atom(int i)
+ {
+ type = AtomType.Float;
+ word = new Word();
+ word.w_float = (float)i;
+ }
+
+ public Atom(Symbol s)
+ {
+ type = AtomType.Symbol;
+ word = new Word();
+ word.w_sym = s;
+ }
+
+ public Atom(string s)
+ {
+ type = AtomType.Symbol;
+ word = new Word();
+ word.w_sym = new Symbol(s);
+ }
+
+ public Atom(Pointer p)
+ {
+ type = AtomType.Pointer;
+ word = new Word();
+ word.w_ptr = p;
+ }
+
+ public bool IsFloat { get { return type == AtomType.Float; } }
+ public bool IsSymbol { get { return type == AtomType.Symbol; } }
+ public bool IsPointer { get { return type == AtomType.Pointer; } }
+
+ public float ToFloat()
+ {
+ if(IsFloat)
+ return word.w_float;
+ else
+ throw new System.InvalidCastException("Can't be cast to float.");
+ }
+
+ public Symbol ToSymbol()
+ {
+ if(IsSymbol)
+ return word.w_sym;
+ else
+ throw new System.InvalidCastException("Can't be cast to Symbol.");
+ }
+
+ public Pointer ToPointer()
+ {
+ if(IsPointer)
+ return word.w_ptr;
+ else
+ throw new System.InvalidCastException("Can't be cast to Pointer.");
+ }
+
+ override public string ToString()
+ {
+ if(IsFloat)
+ return word.w_float.ToString();
+ else if(IsSymbol)
+ return word.w_sym.ToString();
+ else if(IsPointer)
+ return word.w_ptr.ToString();
+ else
+ // should never happen
+ throw new System.InvalidProgramException("Internal error.");
+ }
+
+ public static explicit operator float(Atom a)
+ {
+ return a.ToFloat();
+ }
+
+ public static explicit operator Symbol(Atom a)
+ {
+ return a.ToSymbol();
+ }
+
+ public static explicit operator Pointer(Atom a)
+ {
+ return a.ToPointer();
+ }
+ }
+
+ public class AtomListEnum
+ : IEnumerator
+ {
+ public AtomList list;
+
+ // Enumerators are positioned before the first element
+ // until the first MoveNext() call.
+ int position = -1;
+
+ public AtomListEnum(AtomList l)
+ {
+ list = l;
+ }
+
+ public bool MoveNext()
+ {
+ return ++position < list.Count;
+ }
+
+ public void Reset()
+ {
+ position = -1;
+ }
+
+ public object Current
+ {
+ get
+ {
+ try
+ {
+ return list[position];
+ }
+ catch (IndexOutOfRangeException)
+ {
+ throw new InvalidOperationException();
+ }
+ }
+ }
+ }
+
+
+ // attention: this is dangerous, because we could do the following
+ // AtomList l2 = l;
+ // with l also being an AtomList... the two private memebers will get copied, although atoms is only a temporary reference
+
+ [StructLayout (LayoutKind.Sequential)]
+ unsafe public struct AtomList
+#if NET_2_0
+ : ICollection<Atom>
+#else
+ : ICollection
+#endif
+ {
+ private readonly int len;
+ private readonly Atom *atoms;
+
+ public int Count { get { return len; } }
+#if NET_2_0
+ public bool IsReadOnly { get { return false; } } // member of generic.ICollection<Atom> (C# 2.0)
+#endif
+ public bool IsSynchronized { get { return false; } }
+ public Object SyncRoot { get { return null; } }
+
+ // protect this from being used
+ private AtomList(AtomList a) { len = 0; atoms = null; }
+
+#if NET_2_0
+ public void CopyTo(Atom[] array,int start)
+#else
+ public void CopyTo(Array array,int start)
+#endif
+ {
+ if(len > array.GetUpperBound(0)+1-start)
+ throw new System.ArgumentException("Destination array is not long enough.");
+ int i;
+ for(i = 0; i < len-start; ++i)
+ array.SetValue(atoms[start+i],i);
+ }
+
+ public IEnumerator GetEnumerator()
+ {
+ return new AtomListEnum(this);
+ }
+
+ public Atom this[int i]
+ {
+ get
+ {
+ if(i < 0 || i >= len)
+ throw new System.IndexOutOfRangeException("Index outside array bounds.");
+ return atoms[i];
+ }
+ set
+ {
+ if(i < 0 || i >= len)
+ throw new System.IndexOutOfRangeException("Index outside array bounds.");
+ atoms[i] = value;
+ }
+ }
+
+#if !NET_2_0
+ public static explicit operator Atom[](AtomList l)
+ {
+ Atom[] ret = new Atom[l.Count];
+ int i;
+ for(i = 0; i < l.Count; ++i) ret[i] = l.atoms[i];
+ return ret;
+ }
+#endif
+
+ override public string ToString()
+ {
+ string n = "{";
+ if(len > 0) {
+ int i;
+ for(i = 0; i < len-1; ++i) n += atoms[i].ToString()+",";
+ n += atoms[i].ToString();
+ }
+ return n+"}";
+ }
+ }
+}
diff --git a/PureData/PureData.cs b/PureData/PureData.cs
new file mode 100644
index 0000000..c9ac143
--- /dev/null
+++ b/PureData/PureData.cs
@@ -0,0 +1,64 @@
+using System;
+using System.Runtime.CompilerServices; // for extern import
+using System.Runtime.InteropServices; // for structures
+
+namespace PureData
+{
+ // PD core functions
+ public unsafe class Internal
+ {
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ internal extern static void *SymGen(string sym);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ internal extern static string SymEval(void *sym);
+ }
+
+ // This is the base class for a PD/CLR external
+ public unsafe class External
+ {
+ // PD object pointer
+ private readonly void *ptr;
+
+ // --------------------------------------------------------------------------
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ protected extern static void Post(string message);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ protected extern static void PostError(string message);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ protected extern static void PostBug(string message);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ protected extern static void PostVerbose(string message);
+
+ // --------------------------------------------------------------------------
+
+ protected delegate void MethodBang();
+ protected delegate void MethodFloat(float f);
+ protected delegate void MethodSymbol(Symbol s);
+ protected delegate void MethodPointer(Pointer p);
+ protected delegate void MethodList(AtomList lst);
+ protected delegate void MethodAnything(Symbol tag,AtomList lst);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ protected extern static void Add(MethodBang m);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ protected extern static void Add(MethodFloat m);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ protected extern static void Add(MethodSymbol m);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ protected extern static void Add(MethodPointer m);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ protected extern static void Add(MethodList m);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ protected extern static void Add(MethodAnything m);
+ }
+}
diff --git a/PureData/PureData.csproj b/PureData/PureData.csproj
new file mode 100644
index 0000000..f1b3d08
--- /dev/null
+++ b/PureData/PureData.csproj
@@ -0,0 +1,105 @@
+<VisualStudioProject>
+ <CSHARP
+ ProjectType = "Local"
+ ProductVersion = "7.10.3077"
+ SchemaVersion = "2.0"
+ ProjectGuid = "{0015D5E7-B0FB-4F06-B334-225447D1F992}"
+ >
+ <Build>
+ <Settings
+ ApplicationIcon = ""
+ AssemblyKeyContainerName = ""
+ AssemblyName = "PureData"
+ AssemblyOriginatorKeyFile = ""
+ DefaultClientScript = "JScript"
+ DefaultHTMLPageLayout = "Grid"
+ DefaultTargetSchema = "IE50"
+ DelaySign = "false"
+ OutputType = "Library"
+ PreBuildEvent = ""
+ PostBuildEvent = ""
+ RootNamespace = "PureData"
+ RunPostBuildEvent = "OnBuildSuccess"
+ StartupObject = ""
+ >
+ <Config
+ Name = "Debug"
+ AllowUnsafeBlocks = "true"
+ BaseAddress = "285212672"
+ CheckForOverflowUnderflow = "false"
+ ConfigurationOverrideFile = ""
+ DefineConstants = "DEBUG;TRACE"
+ DocumentationFile = ""
+ DebugSymbols = "true"
+ FileAlignment = "4096"
+ IncrementalBuild = "false"
+ NoStdLib = "false"
+ NoWarn = ""
+ Optimize = "false"
+ OutputPath = "bin\Debug\"
+ RegisterForComInterop = "false"
+ RemoveIntegerChecks = "false"
+ TreatWarningsAsErrors = "false"
+ WarningLevel = "4"
+ />
+ <Config
+ Name = "Release"
+ AllowUnsafeBlocks = "true"
+ BaseAddress = "285212672"
+ CheckForOverflowUnderflow = "false"
+ ConfigurationOverrideFile = ""
+ DefineConstants = "TRACE"
+ DocumentationFile = ""
+ DebugSymbols = "false"
+ FileAlignment = "4096"
+ IncrementalBuild = "false"
+ NoStdLib = "false"
+ NoWarn = ""
+ Optimize = "true"
+ OutputPath = "bin\Release\"
+ RegisterForComInterop = "false"
+ RemoveIntegerChecks = "false"
+ TreatWarningsAsErrors = "false"
+ WarningLevel = "4"
+ />
+ </Settings>
+ <References>
+ <Reference
+ Name = "System"
+ AssemblyName = "System"
+ HintPath = "..\..\..\..\..\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.dll"
+ />
+ <Reference
+ Name = "System.Data"
+ AssemblyName = "System.Data"
+ HintPath = "..\..\..\..\..\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.Data.dll"
+ />
+ <Reference
+ Name = "System.XML"
+ AssemblyName = "System.XML"
+ HintPath = "..\..\..\..\..\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.XML.dll"
+ />
+ </References>
+ </Build>
+ <Files>
+ <Include>
+ <File
+ RelPath = "AssemblyInfo.cs"
+ SubType = "Code"
+ BuildAction = "Compile"
+ />
+ <File
+ RelPath = "Atom.cs"
+ SubType = "Code"
+ BuildAction = "Compile"
+ />
+ <File
+ RelPath = "PureData.cs"
+ SubType = "Code"
+ BuildAction = "Compile"
+ />
+ </Include>
+ </Files>
+ </CSHARP>
+</VisualStudioProject>
+
diff --git a/PureData/README.txt b/PureData/README.txt
new file mode 100755
index 0000000..323f00c
--- /dev/null
+++ b/PureData/README.txt
@@ -0,0 +1,3 @@
+to compile PureData.dll execute this command:
+
+mcs Atom.cs pd.cs -out:PureData.dll -target:library \ No newline at end of file