rbdc 0.8.0

data/dyncall/dyncall/dyncall_callvm_x86.h

@@ -0,0 +1,75 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_callvm_x86.h
+ Description: Call virtual machine for x86 architecture header
+ License:
+
+   Copyright (c) 2007-2011 Daniel Adler <dadler@uni-goettingen.de>, 
+                           Tassilo Philipp <tphilipp@potion-studios.com>
+
+   Permission to use, copy, modify, and distribute this software for any
+   purpose with or without fee is hereby granted, provided that the above
+   copyright notice and this permission notice appear in all copies.
+
+   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+*/
+
+
+#ifndef DYNCALL_CALLVM_X86_H
+#define DYNCALL_CALLVM_X86_H
+
+/*
+
+  dyncall callvm for 32bit X86 architectures
+  Copyright 2007 Daniel Adler.
+
+  SUPPORTED CALLING CONVENTIONS
+  cdecl,stdcall,fastcall,thiscall,msthiscall
+
+  REVISION
+  2007/12/10 initial
+
+*/
+
+
+#include "dyncall_call_x86.h"
+#include "dyncall_callvm.h"
+#include "dyncall_vector.h"
+
+typedef struct DCCallVM_x86_ DCCallVM_x86;
+
+struct DCCallVM_x86_
+{
+  DCCallVM  mInterface;
+  DCpointer mpCallFunc;
+  int       mIntRegs;     /* used by fastcall implementation */
+  DCVecHead mVecHead;
+};
+
+/* Plan9 has no support for OS foreign calling conventions at
+   the time, and vice-versa. */
+#if defined(DC__OS_Plan9)
+
+DCCallVM* dcNewCallVM_x86_plan9(DCsize size);
+
+#else
+
+DCCallVM* dcNewCallVM_x86_cdecl(DCsize size);
+DCCallVM* dcNewCallVM_x86_win32_std(DCsize size);
+DCCallVM* dcNewCallVM_x86_win32_fast_ms(DCsize size);
+DCCallVM* dcNewCallVM_x86_win32_fast_gnu(DCsize size);
+DCCallVM* dcNewCallVM_x86_win32_this_ms(DCsize size);
+
+#endif
+
+#endif /* DYNCALL_CALLVM_X86_H */
+

data/dyncall/dyncall/dyncall_config.h

@@ -0,0 +1,46 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_config.h
+ Description: Macro configuration file for non-standard C types
+ License:
+
+   Copyright (c) 2007-2011 Daniel Adler <dadler@uni-goettingen.de>, 
+                           Tassilo Philipp <tphilipp@potion-studios.com>
+
+   Permission to use, copy, modify, and distribute this software for any
+   purpose with or without fee is hereby granted, provided that the above
+   copyright notice and this permission notice appear in all copies.
+
+   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+*/
+
+
+/*
+
+  dyncall type configuration
+
+  REVISION
+  2007/12/11 initial
+
+*/
+
+#ifndef DYNCALL_CONFIG_H
+#define DYNCALL_CONFIG_H
+
+#include "dyncall_macros.h"
+
+#define DC_BOOL         int
+#define DC_LONG_LONG    long long
+#define DC_POINTER      void*
+
+#endif /* DYNCALL_CONFIG_H */
+

data/dyncall/dyncall/dyncall_macros.h

@@ -0,0 +1,248 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_macros.h
+ Description: Platform detection macros
+ License:
+
+   Copyright (c) 2007-2011 Daniel Adler <dadler@uni-goettingen.de>, 
+                           Tassilo Philipp <tphilipp@potion-studios.com>
+
+   Permission to use, copy, modify, and distribute this software for any
+   purpose with or without fee is hereby granted, provided that the above
+   copyright notice and this permission notice appear in all copies.
+
+   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+*/
+
+
+/*
+
+  dyncall macros
+
+  Platform detection, specific defines and configuration.
+  The purpose of this file is to provide coherent platform and compiler
+  specific defines. So instead of defines like WIN32, _OpenBSD_ or
+  __GNUC__, one should use DC__OS_Win32, DC__OS_OpenBSD or DC__C_GNU,
+  respectively.
+
+  REVISION
+  2007/12/11 initial
+
+*/
+
+
+#ifndef DYNCALL_MACROS_H
+#define DYNCALL_MACROS_H
+
+
+/* Platform specific defines. */
+
+/* MS Windows XP x64/Vista64 or later. */
+#if defined(WIN64) || defined(_WIN64) || defined(__WIN64__)
+#define DC__OS_Win64
+
+/* MS Windows NT/95/98/ME/2000/XP/Vista32. */
+#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__) || defined(__WINDOWS__) || defined(_WINDOWS)
+#define DC__OS_Win32
+
+/* All the OS' based on Darwin OS (MacOS X, OpenDarwin). Note that '__APPLE__' may be defined for classic MacOS, too. */
+/* __MACOSX__ is not defined in gcc assembler mode (switch: -S) */
+/* @@@ TODO: Check for Classic OS */
+
+#elif defined(__APPLE__) || defined(__Darwin__)
+#  define DC__OS_Darwin
+#  if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__)
+#    define DC__OS_IPhone
+#  else /* defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) */
+#    define DC__OS_MacOSX
+#  endif
+
+/* The most popular open source Unix-like OS - Linux. */
+#elif defined(__linux__) || defined(__linux) || defined(__gnu_linux__)
+#define DC__OS_Linux
+
+/* The most powerful open source Unix-like OS - FreeBSD. */
+#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+#define DC__OS_FreeBSD
+
+/* The most secure open source Unix-like OS - OpenBSD. */
+#elif defined(__OpenBSD__)
+#define DC__OS_OpenBSD
+
+/* The most portable open source Unix-like OS - NetBSD. */
+#elif defined(__NetBSD__)
+#define DC__OS_NetBSD
+
+/* The FreeBSD fork having heavy clusterization in mind - DragonFlyBSD. */
+#elif defined(__DragonFly__)
+#define DC__OS_DragonFlyBSD
+
+/* Sun's Unix-like OS - SunOS / Solaris. */
+#elif defined(__sun__) || defined(__sun) || defined(sun)
+#define DC__OS_SunOS
+
+/* The "Linux-like environment for Windows" - Cygwin. */
+#elif defined(__CYGWIN__)
+#define DC__OS_Cygwin
+
+/* The "Minimalist GNU for Windows" - MinGW. */
+#elif defined(__MINGW__)/*@@@*/
+#define DC__OS_MinGW
+
+/* The Nintendo DS (homebrew) using devkitpro. */
+#elif defined(__nds__)
+#define DC__OS_NDS
+
+/* The PlayStation Portable (homebrew) SDK. */
+#elif defined(__psp__) || defined(PSP)
+#define DC__OS_PSP
+
+/* Haiku (BeOS alike). */
+#elif defined(__HAIKU__)
+#define DC__OS_BeOS
+
+/* The Unix successor - Plan9 from Bell Labs */
+#elif defined(Plan9) || defined(__Plan9__)
+#define DC__OS_Plan9
+
+/* Digital's Unix-like OS - VMS */
+#elif defined(__vms)
+#define DC__OS_VMS
+
+#elif defined(__minix)
+#define DC__OS_Minix
+
+#else
+	#error Unsupported OS.
+#endif
+
+
+
+/* Compiler specific defines. Do not change the order, because  */
+/* some of the compilers define flags for compatible ones, too. */
+
+/* Intel's C/C++ compiler. */
+#if defined(__INTEL_COMPILER)
+#define DC__C_Intel
+
+/* MS C/C++ compiler. */
+#elif defined(_MSC_VER)
+#define DC__C_MSVC
+
+/* The GNU Compiler Collection - GCC. */
+#elif defined(__GNUC__)
+#define DC__C_GNU
+
+/* Watcom compiler. */
+#elif defined(__WATCOMC__)
+#define DC__C_WATCOM
+
+/* Portable C Compiler. */
+#elif defined(__PCC__)
+#define DC__C_PCC
+
+/* Sun Pro C. */
+#elif defined(__SUNPRO_C)
+#define DC__C_SUNPRO
+
+/* Undetected C Compiler. */
+#else
+#define DC__C_UNKNOWN
+#endif
+
+
+
+/* Architecture. */
+
+/* Check architecture. */
+#if defined(_M_IX86) || defined(__i386__) || defined(__i486__) || defined(__i586__) || defined(__i686__) || defined(__386__) || defined(__i386)
+# define DC__Arch_Intel_x86
+#elif defined(_M_X64_) || defined(_M_AMD64) || defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) 
+# define DC__Arch_AMD64
+#elif defined(_M_IA64) || defined(__ia64__)
+# define DC__Arch_Itanium
+#elif defined(_M_PPC) || defined(__powerpc__) || defined(__powerpc) || defined(__POWERPC__) || defined(__ppc__) || defined(__power__)
+# define DC__Arch_PowerPC
+#elif defined(__ppc64__) || defined(_ARCH_PPC64) || defined(__power64__)
+# define DC__Arch_PPC64
+#elif defined(__mips64__) || defined(__mips64)
+# define DC__Arch_MIPS64
+#elif defined(_M_MRX000) || defined(__mips__) || defined(__mips) || defined(_mips)
+# define DC__Arch_MIPS
+#elif defined(__arm__) 
+# define DC__Arch_ARM
+#elif defined(__sh__)
+# define DC__Arch_SuperH
+#elif defined(__sparcv9) || defined(__sparc64__) || ( defined(__sparc) && defined(__arch64__) ) 
+/* this could be needed on Linux/GNU sparc64 in the future: || ( defined(__sparc) && defined(__arch64__) ) */
+# define DC__Arch_Sparcv9
+#elif defined(__sparc)
+# define DC__Arch_Sparc
+#endif
+
+
+
+/* Rough OS classification. */
+
+#if defined(DC__OS_Win32) || defined(DC__OS_Win64)
+# define DC_WINDOWS
+#elif defined(DC__OS_Plan9)
+# define DC_PLAN9
+#elif defined(DC__OS_NDS) || defined(DC__OS_PSP)
+# define DC_OTHER
+#else
+# define DC_UNIX
+#endif
+
+
+
+/* Misc machine-dependent quirks. */
+
+#if defined(__arm__) && !defined(__thumb__)
+# define DC__Arch_ARM_ARM
+#elif defined(__arm__) && defined(__thumb__)
+# define DC__Arch_ARM_THUMB
+#endif
+
+#if defined(DC__Arch_ARM_ARM) || defined(DC__Arch_ARM_THUMB)
+# if defined(__ARM_EABI__) || defined(DC__OS_NDS)
+#  if defined (__ARM_PCS_VFP) && (__ARM_PCS_VFP == 1)
+#    define DC__ABI_ARM_HF
+#  else
+#    define DC__ABI_ARM_EABI
+#  endif
+# elif defined(__APCS_32__)
+#  define DC__ABI_ARM_OABI
+# endif
+#endif /* ARM */
+
+#if defined(DC__Arch_MIPS) || defined(DC__Arch_MIPS64)
+# if defined(_ABIO32) || defined(_MIPS_ARCH_MIPS1) || defined(_MIPS_ARCH_MIPS2)
+#  define DC__ABI_MIPS_O32
+# elif defined(_ABIN32)
+#  define DC__ABI_MIPS_N32
+# elif defined(_ABI64)
+#  define DC__ABI_MIPS_N64
+# else
+#  define DC__ABI_MIPS_EABI
+# endif
+#endif /* MIPS */
+
+
+
+/* Internal macro/tag. */
+#if !defined(DC_API)
+#define DC_API
+#endif
+
+#endif /* DYNCALL_MACROS_H */
+

data/dyncall/dyncall/dyncall_signature.h

@@ -0,0 +1,71 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_signature.h
+ Description: Type and calling-convention signature character defines
+ License:
+
+   Copyright (c) 2007-2011 Daniel Adler <dadler@uni-goettingen.de>, 
+                           Tassilo Philipp <tphilipp@potion-studios.com>
+
+   Permission to use, copy, modify, and distribute this software for any
+   purpose with or without fee is hereby granted, provided that the above
+   copyright notice and this permission notice appear in all copies.
+
+   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+*/
+
+
+/*
+
+  dyncall signature characters
+
+  REVISION
+  2007/12/11 initial
+  
+*/
+
+
+#ifndef DYNCALL_SIGNATURE_H
+#define DYNCALL_SIGNATURE_H
+
+typedef char DCsigchar;
+
+#define DC_SIGCHAR_VOID         'v'
+#define DC_SIGCHAR_BOOL         'B'
+#define DC_SIGCHAR_CHAR         'c'
+#define DC_SIGCHAR_UCHAR        'C'
+#define DC_SIGCHAR_SHORT        's'
+#define DC_SIGCHAR_USHORT       'S'
+#define DC_SIGCHAR_INT          'i'
+#define DC_SIGCHAR_UINT         'I'
+#define DC_SIGCHAR_LONG         'j'
+#define DC_SIGCHAR_ULONG        'J'
+#define DC_SIGCHAR_LONGLONG     'l'
+#define DC_SIGCHAR_ULONGLONG    'L'
+#define DC_SIGCHAR_FLOAT        'f'
+#define DC_SIGCHAR_DOUBLE       'd'
+#define DC_SIGCHAR_POINTER      'p'
+#define DC_SIGCHAR_STRING       'Z'
+#define DC_SIGCHAR_STRUCT       'T'
+#define DC_SIGCHAR_ENDARG       ')' /* also works for end struct */
+
+/* callback signatures */
+
+#define DC_SIGCHAR_CC_PREFIX        '_'
+#define DC_SIGCHAR_CC_ELLIPSIS      'e'
+#define DC_SIGCHAR_CC_STDCALL       's'
+#define DC_SIGCHAR_CC_FASTCALL_GNU  'f'
+#define DC_SIGCHAR_CC_FASTCALL_MS   'F'
+#define DC_SIGCHAR_CC_THISCALL_MS   '+'
+
+#endif /* DYNCALL_SIGNATURE_H */
+

data/dyncall/dyncall/dyncall_struct.c

@@ -0,0 +1,255 @@
+/*
+
+ Package: dyncall
+ Library: dyncall
+ File: dyncall/dyncall_struct.c
+ Description: C interface to compute struct size
+ License:
+
+   Copyright (c) 2010-2011 Olivier Chafik <olivier.chafik@centraliens.net>
+
+   Permission to use, copy, modify, and distribute this software for any
+   purpose with or without fee is hereby granted, provided that the above
+   copyright notice and this permission notice appear in all copies.
+
+   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+*/
+
+
+#include "dyncall.h"
+#include "dyncall_signature.h"
+#include "dyncall_struct.h"
+#include "dyncall_alloc.h"
+#include <stdio.h>
+#include <assert.h>
+
+
+DCstruct* dcNewStruct(DCsize fieldCount, DCint alignment)
+{
+	DCstruct* s = (DCstruct*)dcAllocMem(sizeof(DCstruct));
+	s->pCurrentStruct = s;
+	s->pLastStruct = NULL;
+	s->nextField = 0;
+	s->fieldCount = fieldCount;
+	s->alignment = alignment;
+	s->size = 0;
+	s->pFields = (DCfield*)dcAllocMem(fieldCount * sizeof(DCfield));
+	return s;
+}
+
+
+void dcStructField(DCstruct* s, DCint type, DCint alignment, DCsize arrayLength)
+{
+	DCfield *f;
+	if (type == DC_SIGCHAR_STRING) {
+		assert(!"Use dcSubStruct instead !!!");
+		return;
+	}
+	assert(s && s->pCurrentStruct);
+	assert(s->pCurrentStruct->nextField <= (DCint)s->pCurrentStruct->fieldCount - 1);
+	f = s->pCurrentStruct->pFields + (s->pCurrentStruct->nextField++);
+	f->type = type;
+	f->alignment = alignment;
+	f->arrayLength = arrayLength;
+	f->pSubStruct = NULL;
+	switch (type) {
+    	case DC_SIGCHAR_BOOL:       f->size = sizeof(DCbool);     break;
+    	case DC_SIGCHAR_CHAR:       
+    	case DC_SIGCHAR_UCHAR:      f->size = sizeof(DCchar);     break;
+    	case DC_SIGCHAR_SHORT:      
+    	case DC_SIGCHAR_USHORT:     f->size = sizeof(DCshort);    break;
+    	case DC_SIGCHAR_INT:        
+    	case DC_SIGCHAR_UINT:       f->size = sizeof(DCint);      break;
+    	case DC_SIGCHAR_LONG:       
+    	case DC_SIGCHAR_ULONG:      f->size = sizeof(DClong);     break;
+    	case DC_SIGCHAR_LONGLONG:   
+    	case DC_SIGCHAR_ULONGLONG:  f->size = sizeof(DClonglong); break;
+    	case DC_SIGCHAR_FLOAT:      f->size = sizeof(DCfloat);    break;
+    	case DC_SIGCHAR_DOUBLE:     f->size = sizeof(DCdouble);   break;
+    	case DC_SIGCHAR_POINTER:
+		case DC_SIGCHAR_STRING:     f->size = sizeof(DCpointer);  break;
+		default:                    assert(0);
+	}
+}
+
+
+void dcSubStruct(DCstruct* s, DCsize fieldCount, DCint alignment, DCsize arrayLength)
+{
+	DCfield *f = s->pCurrentStruct->pFields + (s->pCurrentStruct->nextField++);
+	f->type = DC_SIGCHAR_STRUCT;
+	f->arrayLength = arrayLength;
+	f->alignment = alignment;
+	f->pSubStruct = dcNewStruct(fieldCount, alignment);
+	f->pSubStruct->pLastStruct = s->pCurrentStruct;
+	s->pCurrentStruct = f->pSubStruct;
+}  	
+
+
+static void dcAlign(DCsize *size, DCsize alignment)
+{
+	DCsize mod = (*size) % alignment;
+	if (mod) {
+		DCsize rest = alignment - mod;
+		(*size) += rest;
+	}
+}
+
+
+static void dcComputeStructSize(DCstruct* s)
+{
+	DCsize i;
+	assert(s);
+	for (i = 0; i < s->fieldCount; i++) {
+		DCfield *f = s->pFields + i;
+		DCsize fieldAlignment;
+		if (f->type == DC_SIGCHAR_STRUCT) {
+			dcComputeStructSize(f->pSubStruct);
+			f->size = f->pSubStruct->size;
+			fieldAlignment = f->pSubStruct->alignment;
+		} else {
+			fieldAlignment = f->size;
+		}
+		if (!f->alignment)
+			f->alignment = fieldAlignment;
+		
+		if (f->alignment > s->alignment)
+			s->alignment = f->alignment;
+		
+		f->size *= f->arrayLength;
+		
+		/*printf("FIELD %d, size = %d, alignment = %d\n", (int)i, (int)f->size, (int)f->alignment);@@@*/
+	}
+	for (i = 0; i < s->fieldCount; i++) {
+		DCfield *f = s->pFields + i;
+		dcAlign(&s->size, f->alignment);
+		s->size += f->size;
+	}
+	dcAlign(&s->size, s->alignment);
+	
+	/*printf("STRUCT size = %d, alignment = %d\n", (int)s->size, (int)s->alignment);@@@*/
+}
+
+
+void dcCloseStruct(DCstruct* s)
+{
+	assert(s);
+	assert(s->pCurrentStruct);
+	assert(s->pCurrentStruct->nextField == s->pCurrentStruct->fieldCount);
+	if (!s->pCurrentStruct->pLastStruct) {
+		dcComputeStructSize(s->pCurrentStruct);
+	}
+	s->pCurrentStruct = s->pCurrentStruct->pLastStruct;
+}
+
+
+void dcFreeStruct(DCstruct* s)
+{
+	DCsize i;
+	assert(s);
+	for (i = 0; i < s->fieldCount; i++) {
+		DCfield *f = s->pFields + i;
+		if (f->type == DC_SIGCHAR_STRUCT)
+			dcFreeStruct(f->pSubStruct);
+	}
+	free(s->pFields);
+	free(s);
+}
+
+
+DCsize dcStructSize(DCstruct* s)
+{
+	assert(!s->pCurrentStruct && "Struct was not closed");
+	return s->size;
+}
+
+DCsize dcStructAlignment(DCstruct* s)
+{
+	assert(!s->pCurrentStruct && "Struct was not closed");
+	return s->alignment;
+}
+
+
+void dcArgStructUnroll(DCCallVM* vm, DCstruct* s, DCpointer  value)
+{
+	DCsize i;
+	/*printf("UNROLLING STRUCT !\n");@@@*/
+	assert(s && value);
+	for (i = 0; i < s->fieldCount; i++) {
+		DCfield *f = s->pFields + i;
+		DCpointer p = (char*)value + f->offset;
+		switch(f->type) {
+		  case DC_SIGCHAR_STRUCT:
+		  	dcArgStruct(vm, f->pSubStruct, p);
+		  	break;
+		  case DC_SIGCHAR_BOOL: 
+			dcArgBool      (vm, *(DCbool*)p); 
+			break;
+		  case DC_SIGCHAR_CHAR:
+		  case DC_SIGCHAR_UCHAR:
+			dcArgChar      (vm, *(DCchar*)p);
+			break;
+		  case DC_SIGCHAR_SHORT:
+		  case DC_SIGCHAR_USHORT:
+			dcArgShort     (vm, *(DCshort*)p);
+			break;
+		  case DC_SIGCHAR_INT:
+		  case DC_SIGCHAR_UINT:
+			dcArgInt       (vm, *(DCint*)p);
+			break;
+		  case DC_SIGCHAR_LONG:
+		  case DC_SIGCHAR_ULONG:
+			dcArgLong      (vm, *(DCulong*)p);
+			break;
+		  case DC_SIGCHAR_LONGLONG:
+		  case DC_SIGCHAR_ULONGLONG:
+			dcArgLongLong  (vm, *(DCulonglong*)p);
+			break;
+		  case DC_SIGCHAR_FLOAT:
+			dcArgFloat     (vm, *(DCfloat*)p);
+			break;
+		  case DC_SIGCHAR_DOUBLE:
+			dcArgDouble    (vm, *(DCdouble*)p);
+			break;
+		  case DC_SIGCHAR_POINTER:
+		  case DC_SIGCHAR_STRING:
+			dcArgPointer   (vm, *(DCpointer**)p);
+			break;
+	       default:
+	       	assert(0);
+		}	
+	}
+}
+
+
+static DCint readInt(const char** ptr)
+{
+	return strtol(*ptr, (char**)ptr, 10);/*@@@ enough*/
+}
+
+
+DCstruct* dcDefineStruct(const char* signature)
+{
+	DCstruct* s;
+	const char* ptr = signature;
+	DCint fieldCount = readInt(&ptr);
+	s = dcNewStruct(fieldCount, DEFAULT_ALIGNMENT);
+	
+	while (*ptr) {
+		char type = *(ptr++);
+		if (type == DC_SIGCHAR_STRUCT) {
+			/*dcSubStruct(	@@@*/
+		} else {
+			dcStructField(s, type, DEFAULT_ALIGNMENT, readInt(&ptr));
+		}
+	}
+	dcCloseStruct(s);
+	return s;
+}
+