Restoring authorship annotation for Anton Samokhvalov <pg83@yandex.ru>. Commit 1 of 2.

1 files changed, 249 insertions, 249 deletions

diff --git a/contrib/restricted/libffi/src/raw_api.c b/contrib/restricted/libffi/src/raw_api.c
index be156116cb..bded12239d 100644
--- a/contrib/restricted/libffi/src/raw_api.c
+++ b/contrib/restricted/libffi/src/raw_api.c
@@ -1,267 +1,267 @@
-/* -----------------------------------------------------------------------
-   raw_api.c - Copyright (c) 1999, 2008  Red Hat, Inc.
-
-   Author: Kresten Krab Thorup <krab@gnu.org>
-
-   Permission is hereby granted, free of charge, to any person obtaining
-   a copy of this software and associated documentation files (the
-   ``Software''), to deal in the Software without restriction, including
-   without limitation the rights to use, copy, modify, merge, publish,
-   distribute, sublicense, and/or sell copies of the Software, and to
-   permit persons to whom the Software is furnished to do so, subject to
-   the following conditions:
-
-   The above copyright notice and this permission notice shall be included
-   in all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
-   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-   NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-   ----------------------------------------------------------------------- */
-
-/* This file defines generic functions for use with the raw api. */
-
-#include <ffi.h>
-#include <ffi_common.h>
-
-#if !FFI_NO_RAW_API
-
-size_t
-ffi_raw_size (ffi_cif *cif)
-{
-  size_t result = 0;
-  int i;
-
-  ffi_type **at = cif->arg_types;
-
-  for (i = cif->nargs-1; i >= 0; i--, at++)
-    {
-#if !FFI_NO_STRUCTS
-      if ((*at)->type == FFI_TYPE_STRUCT)
+/* ----------------------------------------------------------------------- 
+   raw_api.c - Copyright (c) 1999, 2008  Red Hat, Inc. 
+ 
+   Author: Kresten Krab Thorup <krab@gnu.org> 
+ 
+   Permission is hereby granted, free of charge, to any person obtaining 
+   a copy of this software and associated documentation files (the 
+   ``Software''), to deal in the Software without restriction, including 
+   without limitation the rights to use, copy, modify, merge, publish, 
+   distribute, sublicense, and/or sell copies of the Software, and to 
+   permit persons to whom the Software is furnished to do so, subject to 
+   the following conditions: 
+ 
+   The above copyright notice and this permission notice shall be included 
+   in all copies or substantial portions of the Software. 
+ 
+   THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, 
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+   NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 
+   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+   DEALINGS IN THE SOFTWARE. 
+   ----------------------------------------------------------------------- */ 
+ 
+/* This file defines generic functions for use with the raw api. */ 
+ 
+#include <ffi.h> 
+#include <ffi_common.h> 
+ 
+#if !FFI_NO_RAW_API 
+ 
+size_t 
+ffi_raw_size (ffi_cif *cif) 
+{ 
+  size_t result = 0; 
+  int i; 
+ 
+  ffi_type **at = cif->arg_types; 
+ 
+  for (i = cif->nargs-1; i >= 0; i--, at++) 
+    { 
+#if !FFI_NO_STRUCTS 
+      if ((*at)->type == FFI_TYPE_STRUCT) 
 	result += FFI_ALIGN (sizeof (void*), FFI_SIZEOF_ARG);
-      else
-#endif
+      else 
+#endif 
 	result += FFI_ALIGN ((*at)->size, FFI_SIZEOF_ARG);
-    }
-
-  return result;
-}
-
-
-void
-ffi_raw_to_ptrarray (ffi_cif *cif, ffi_raw *raw, void **args)
-{
-  unsigned i;
-  ffi_type **tp = cif->arg_types;
-
-#if WORDS_BIGENDIAN
-
-  for (i = 0; i < cif->nargs; i++, tp++, args++)
-    {	  
-      switch ((*tp)->type)
-	{
-	case FFI_TYPE_UINT8:
-	case FFI_TYPE_SINT8:
-	  *args = (void*) ((char*)(raw++) + FFI_SIZEOF_ARG - 1);
-	  break;
-	  
-	case FFI_TYPE_UINT16:
-	case FFI_TYPE_SINT16:
-	  *args = (void*) ((char*)(raw++) + FFI_SIZEOF_ARG - 2);
-	  break;
-
-#if FFI_SIZEOF_ARG >= 4	  
-	case FFI_TYPE_UINT32:
-	case FFI_TYPE_SINT32:
-	  *args = (void*) ((char*)(raw++) + FFI_SIZEOF_ARG - 4);
-	  break;
-#endif
-	
-#if !FFI_NO_STRUCTS  
-	case FFI_TYPE_STRUCT:
-	  *args = (raw++)->ptr;
-	  break;
-#endif
-
+    } 
+ 
+  return result; 
+} 
+ 
+ 
+void 
+ffi_raw_to_ptrarray (ffi_cif *cif, ffi_raw *raw, void **args) 
+{ 
+  unsigned i; 
+  ffi_type **tp = cif->arg_types; 
+ 
+#if WORDS_BIGENDIAN 
+ 
+  for (i = 0; i < cif->nargs; i++, tp++, args++) 
+    {	   
+      switch ((*tp)->type) 
+	{ 
+	case FFI_TYPE_UINT8: 
+	case FFI_TYPE_SINT8: 
+	  *args = (void*) ((char*)(raw++) + FFI_SIZEOF_ARG - 1); 
+	  break; 
+	   
+	case FFI_TYPE_UINT16: 
+	case FFI_TYPE_SINT16: 
+	  *args = (void*) ((char*)(raw++) + FFI_SIZEOF_ARG - 2); 
+	  break; 
+ 
+#if FFI_SIZEOF_ARG >= 4	   
+	case FFI_TYPE_UINT32: 
+	case FFI_TYPE_SINT32: 
+	  *args = (void*) ((char*)(raw++) + FFI_SIZEOF_ARG - 4); 
+	  break; 
+#endif 
+	 
+#if !FFI_NO_STRUCTS   
+	case FFI_TYPE_STRUCT: 
+	  *args = (raw++)->ptr; 
+	  break; 
+#endif 
+ 
 	case FFI_TYPE_COMPLEX:
 	  *args = (raw++)->ptr;
 	  break;
 
-	case FFI_TYPE_POINTER:
-	  *args = (void*) &(raw++)->ptr;
-	  break;
-	  
-	default:
-	  *args = raw;
+	case FFI_TYPE_POINTER: 
+	  *args = (void*) &(raw++)->ptr; 
+	  break; 
+	   
+	default: 
+	  *args = raw; 
 	  raw += FFI_ALIGN ((*tp)->size, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
-	}
-    }
-
-#else /* WORDS_BIGENDIAN */
-
-#if !PDP
-
-  /* then assume little endian */
-  for (i = 0; i < cif->nargs; i++, tp++, args++)
-    {	  
-#if !FFI_NO_STRUCTS
-      if ((*tp)->type == FFI_TYPE_STRUCT)
-	{
-	  *args = (raw++)->ptr;
-	}
-      else
-#endif
+	} 
+    } 
+ 
+#else /* WORDS_BIGENDIAN */ 
+ 
+#if !PDP 
+ 
+  /* then assume little endian */ 
+  for (i = 0; i < cif->nargs; i++, tp++, args++) 
+    {	   
+#if !FFI_NO_STRUCTS 
+      if ((*tp)->type == FFI_TYPE_STRUCT) 
+	{ 
+	  *args = (raw++)->ptr; 
+	} 
+      else 
+#endif 
       if ((*tp)->type == FFI_TYPE_COMPLEX)
-	{
+	{ 
 	  *args = (raw++)->ptr;
 	}
       else
 	{
-	  *args = (void*) raw;
+	  *args = (void*) raw; 
 	  raw += FFI_ALIGN ((*tp)->size, sizeof (void*)) / sizeof (void*);
-	}
-    }
-
-#else
-#error "pdp endian not supported"
-#endif /* ! PDP */
-
-#endif /* WORDS_BIGENDIAN */
-}
-
-void
-ffi_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_raw *raw)
-{
-  unsigned i;
-  ffi_type **tp = cif->arg_types;
-
-  for (i = 0; i < cif->nargs; i++, tp++, args++)
-    {	  
-      switch ((*tp)->type)
-	{
-	case FFI_TYPE_UINT8:
-	  (raw++)->uint = *(UINT8*) (*args);
-	  break;
-
-	case FFI_TYPE_SINT8:
-	  (raw++)->sint = *(SINT8*) (*args);
-	  break;
-
-	case FFI_TYPE_UINT16:
-	  (raw++)->uint = *(UINT16*) (*args);
-	  break;
-
-	case FFI_TYPE_SINT16:
-	  (raw++)->sint = *(SINT16*) (*args);
-	  break;
-
-#if FFI_SIZEOF_ARG >= 4
-	case FFI_TYPE_UINT32:
-	  (raw++)->uint = *(UINT32*) (*args);
-	  break;
-
-	case FFI_TYPE_SINT32:
-	  (raw++)->sint = *(SINT32*) (*args);
-	  break;
-#endif
-
-#if !FFI_NO_STRUCTS
-	case FFI_TYPE_STRUCT:
-	  (raw++)->ptr = *args;
-	  break;
-#endif
-
+	} 
+    } 
+ 
+#else 
+#error "pdp endian not supported" 
+#endif /* ! PDP */ 
+ 
+#endif /* WORDS_BIGENDIAN */ 
+} 
+ 
+void 
+ffi_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_raw *raw) 
+{ 
+  unsigned i; 
+  ffi_type **tp = cif->arg_types; 
+ 
+  for (i = 0; i < cif->nargs; i++, tp++, args++) 
+    {	   
+      switch ((*tp)->type) 
+	{ 
+	case FFI_TYPE_UINT8: 
+	  (raw++)->uint = *(UINT8*) (*args); 
+	  break; 
+ 
+	case FFI_TYPE_SINT8: 
+	  (raw++)->sint = *(SINT8*) (*args); 
+	  break; 
+ 
+	case FFI_TYPE_UINT16: 
+	  (raw++)->uint = *(UINT16*) (*args); 
+	  break; 
+ 
+	case FFI_TYPE_SINT16: 
+	  (raw++)->sint = *(SINT16*) (*args); 
+	  break; 
+ 
+#if FFI_SIZEOF_ARG >= 4 
+	case FFI_TYPE_UINT32: 
+	  (raw++)->uint = *(UINT32*) (*args); 
+	  break; 
+ 
+	case FFI_TYPE_SINT32: 
+	  (raw++)->sint = *(SINT32*) (*args); 
+	  break; 
+#endif 
+ 
+#if !FFI_NO_STRUCTS 
+	case FFI_TYPE_STRUCT: 
+	  (raw++)->ptr = *args; 
+	  break; 
+#endif 
+ 
 	case FFI_TYPE_COMPLEX:
 	  (raw++)->ptr = *args;
 	  break;
 
-	case FFI_TYPE_POINTER:
-	  (raw++)->ptr = **(void***) args;
-	  break;
-
-	default:
-	  memcpy ((void*) raw->data, (void*)*args, (*tp)->size);
+	case FFI_TYPE_POINTER: 
+	  (raw++)->ptr = **(void***) args; 
+	  break; 
+ 
+	default: 
+	  memcpy ((void*) raw->data, (void*)*args, (*tp)->size); 
 	  raw += FFI_ALIGN ((*tp)->size, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
-	}
-    }
-}
-
-#if !FFI_NATIVE_RAW_API
-
-
-/* This is a generic definition of ffi_raw_call, to be used if the
- * native system does not provide a machine-specific implementation.
- * Having this, allows code to be written for the raw API, without
- * the need for system-specific code to handle input in that format;
- * these following couple of functions will handle the translation forth
- * and back automatically. */
-
-void ffi_raw_call (ffi_cif *cif, void (*fn)(void), void *rvalue, ffi_raw *raw)
-{
-  void **avalue = (void**) alloca (cif->nargs * sizeof (void*));
-  ffi_raw_to_ptrarray (cif, raw, avalue);
-  ffi_call (cif, fn, rvalue, avalue);
-}
-
-#if FFI_CLOSURES		/* base system provides closures */
-
-static void
-ffi_translate_args (ffi_cif *cif, void *rvalue,
-		    void **avalue, void *user_data)
-{
-  ffi_raw *raw = (ffi_raw*)alloca (ffi_raw_size (cif));
-  ffi_raw_closure *cl = (ffi_raw_closure*)user_data;
-
-  ffi_ptrarray_to_raw (cif, avalue, raw);
-  (*cl->fun) (cif, rvalue, raw, cl->user_data);
-}
-
-ffi_status
-ffi_prep_raw_closure_loc (ffi_raw_closure* cl,
-			  ffi_cif *cif,
-			  void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
-			  void *user_data,
-			  void *codeloc)
-{
-  ffi_status status;
-
-  status = ffi_prep_closure_loc ((ffi_closure*) cl,
-				 cif,
-				 &ffi_translate_args,
-				 codeloc,
-				 codeloc);
-  if (status == FFI_OK)
-    {
-      cl->fun       = fun;
-      cl->user_data = user_data;
-    }
-
-  return status;
-}
-
-#endif /* FFI_CLOSURES */
-#endif /* !FFI_NATIVE_RAW_API */
-
-#if FFI_CLOSURES
-
-/* Again, here is the generic version of ffi_prep_raw_closure, which
- * will install an intermediate "hub" for translation of arguments from
- * the pointer-array format, to the raw format */
-
-ffi_status
-ffi_prep_raw_closure (ffi_raw_closure* cl,
-		      ffi_cif *cif,
-		      void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
-		      void *user_data)
-{
-  return ffi_prep_raw_closure_loc (cl, cif, fun, user_data, cl);
-}
-
-#endif /* FFI_CLOSURES */
-
-#endif /* !FFI_NO_RAW_API */
+	} 
+    } 
+} 
+ 
+#if !FFI_NATIVE_RAW_API 
+ 
+ 
+/* This is a generic definition of ffi_raw_call, to be used if the 
+ * native system does not provide a machine-specific implementation. 
+ * Having this, allows code to be written for the raw API, without 
+ * the need for system-specific code to handle input in that format; 
+ * these following couple of functions will handle the translation forth 
+ * and back automatically. */ 
+ 
+void ffi_raw_call (ffi_cif *cif, void (*fn)(void), void *rvalue, ffi_raw *raw) 
+{ 
+  void **avalue = (void**) alloca (cif->nargs * sizeof (void*)); 
+  ffi_raw_to_ptrarray (cif, raw, avalue); 
+  ffi_call (cif, fn, rvalue, avalue); 
+} 
+ 
+#if FFI_CLOSURES		/* base system provides closures */ 
+ 
+static void 
+ffi_translate_args (ffi_cif *cif, void *rvalue, 
+		    void **avalue, void *user_data) 
+{ 
+  ffi_raw *raw = (ffi_raw*)alloca (ffi_raw_size (cif)); 
+  ffi_raw_closure *cl = (ffi_raw_closure*)user_data; 
+ 
+  ffi_ptrarray_to_raw (cif, avalue, raw); 
+  (*cl->fun) (cif, rvalue, raw, cl->user_data); 
+} 
+ 
+ffi_status 
+ffi_prep_raw_closure_loc (ffi_raw_closure* cl, 
+			  ffi_cif *cif, 
+			  void (*fun)(ffi_cif*,void*,ffi_raw*,void*), 
+			  void *user_data, 
+			  void *codeloc) 
+{ 
+  ffi_status status; 
+ 
+  status = ffi_prep_closure_loc ((ffi_closure*) cl, 
+				 cif, 
+				 &ffi_translate_args, 
+				 codeloc, 
+				 codeloc); 
+  if (status == FFI_OK) 
+    { 
+      cl->fun       = fun; 
+      cl->user_data = user_data; 
+    } 
+ 
+  return status; 
+} 
+ 
+#endif /* FFI_CLOSURES */ 
+#endif /* !FFI_NATIVE_RAW_API */ 
+ 
+#if FFI_CLOSURES 
+ 
+/* Again, here is the generic version of ffi_prep_raw_closure, which 
+ * will install an intermediate "hub" for translation of arguments from 
+ * the pointer-array format, to the raw format */ 
+ 
+ffi_status 
+ffi_prep_raw_closure (ffi_raw_closure* cl, 
+		      ffi_cif *cif, 
+		      void (*fun)(ffi_cif*,void*,ffi_raw*,void*), 
+		      void *user_data) 
+{ 
+  return ffi_prep_raw_closure_loc (cl, cif, fun, user_data, cl); 
+} 
+ 
+#endif /* FFI_CLOSURES */ 
+ 
+#endif /* !FFI_NO_RAW_API */