externals/clr/PureData AssemblyInfo.cs, NONE, 1.1 Atom.cs, NONE, 1.1 PureData.cs, NONE, 1.1 PureData.csproj, NONE, 1.1 README.txt, NONE, 1.1 - Pd-cvs

7 Mar 2006


      Update of /cvsroot/pure-data/externals/clr/PureData
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29926/clr/PureData
Added Files:
    AssemblyInfo.cs Atom.cs PureData.cs PureData.csproj README.txt 
Log Message:
restructured project (MSVC can't cope well with folder/classname mismatch)
search for CLR DLLs in PD path
first steps to efficient method handling
--- NEW FILE: PureData.csproj ---
<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>
--- NEW FILE: PureData.cs ---
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);
    }
}
--- NEW FILE: Atom.cs ---
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+"}";
        }
    }	
}
--- NEW FILE: README.txt ---
to compile PureData.dll execute this command:
mcs Atom.cs pd.cs -out:PureData.dll -target:library
--- NEW FILE: AssemblyInfo.cs ---
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("")]