ffi 0.6.3-x86-mingw32 → 1.0.1-x86-mingw32

data/ext/ffi_c/Struct.h

@@ -32,6 +32,11 @@
 
 #include "AbstractMemory.h"
 #include "Type.h"
+#ifdef RUBY_1_9
+#include <ruby/st.h>
+#else
+#include <st.h>
+#endif
 
 #ifdef	__cplusplus
 extern "C" {
@@ -63,6 +68,7 @@ extern "C" {
         int size;
         int align;
         ffi_type** ffiTypes;
+        struct st_table* fieldSymbolTable;
         VALUE rbFieldNames;
         VALUE rbFieldMap;
         VALUE rbFields;

data/ext/ffi_c/StructByReference.c

@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2010, Wayne Meissner
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright notice
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * * The name of the author or authors may not be used to endorse or promote
+ *   products derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/param.h>
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <errno.h>
+#include <ruby.h>
+
+#include <ffi.h>
+#include "rbffi.h"
+#include "compat.h"
+
+#include "Pointer.h"
+#include "Struct.h"
+#include "StructByReference.h"
+
+
+#define FFI_ALIGN(v, a)  (((((size_t) (v))-1) | ((a)-1))+1)
+
+static VALUE sbr_allocate(VALUE);
+static VALUE sbr_initialize(VALUE, VALUE);
+static void sbr_mark(StructByReference *);
+
+VALUE rbffi_StructByReferenceClass = Qnil;
+
+static VALUE
+sbr_allocate(VALUE klass)
+{
+    StructByReference* sbr;
+
+    VALUE obj = Data_Make_Struct(klass, StructByReference, sbr_mark, -1, sbr);
+
+    sbr->rbStructClass = Qnil;
+
+    return obj;
+}
+
+static VALUE
+sbr_initialize(VALUE self, VALUE rbStructClass)
+{
+    StructByReference* sbr = NULL;
+    
+    if (!rb_class_inherited_p(rbStructClass, rbffi_StructClass)) {
+        rb_raise(rb_eTypeError, "wrong type (expected subclass of FFI::Struct)");
+    }
+
+    Data_Get_Struct(self, StructByReference, sbr);
+    sbr->rbStructClass = rbStructClass;
+    
+    return self;
+}
+
+static void
+sbr_mark(StructByReference *sbr)
+{
+    rb_gc_mark(sbr->rbStructClass);
+}
+
+
+static VALUE
+sbr_struct_class(VALUE self)
+{
+    StructByReference* sbr;
+
+    Data_Get_Struct(self, StructByReference, sbr);
+
+    return sbr->rbStructClass;
+}
+
+static VALUE
+sbr_native_type(VALUE self)
+{
+    return rb_const_get(rbffi_TypeClass, rb_intern("POINTER"));
+}
+
+static VALUE
+sbr_to_native(VALUE self, VALUE value, VALUE ctx)
+{
+    StructByReference* sbr;
+    Struct* s;
+
+    if (unlikely(value == Qnil)) {
+        return rbffi_NullPointerSingleton;
+    }
+
+    Data_Get_Struct(self, StructByReference, sbr);
+    if (!rb_obj_is_kind_of(value, sbr->rbStructClass)) {
+        rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)",
+                rb_obj_classname(value),
+                RSTRING_PTR(rb_class_name(sbr->rbStructClass)));
+    }
+
+    Data_Get_Struct(value, Struct, s);
+
+    return s->rbPointer;
+}
+
+static VALUE
+sbr_from_native(VALUE self, VALUE value, VALUE ctx)
+{
+    StructByReference* sbr;
+
+    Data_Get_Struct(self, StructByReference, sbr);
+
+    return rb_class_new_instance(1, &value, sbr->rbStructClass);
+}
+
+
+void
+rbffi_StructByReference_Init(VALUE moduleFFI)
+{
+    rbffi_StructByReferenceClass = rb_define_class_under(moduleFFI, "StructByReference", rb_cObject);
+    rb_global_variable(&rbffi_StructByReferenceClass);
+    rb_include_module(rbffi_StructByReferenceClass, rb_const_get(moduleFFI, rb_intern("DataConverter")));
+    
+    rb_define_alloc_func(rbffi_StructByReferenceClass, sbr_allocate);
+    rb_define_method(rbffi_StructByReferenceClass, "initialize", sbr_initialize, 1);
+    rb_define_method(rbffi_StructByReferenceClass, "struct_class", sbr_struct_class, 0);
+    rb_define_method(rbffi_StructByReferenceClass, "native_type", sbr_native_type, 0);
+    rb_define_method(rbffi_StructByReferenceClass, "to_native", sbr_to_native, 2);
+    rb_define_method(rbffi_StructByReferenceClass, "from_native", sbr_from_native, 2);
+}
+

data/ext/ffi_c/StructByReference.h

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2009, Wayne Meissner
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright notice
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * * The name of the author or authors may not be used to endorse or promote
+ *   products derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef RBFFI_STRUCTBYREFERENCE_H
+#define	RBFFI_STRUCTBYREFERENCE_H
+
+#include <ruby.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef struct StructByReference_ {
+    VALUE rbStructClass;
+} StructByReference;
+
+void rbffi_StructByReference_Init(VALUE moduleFFI);
+
+extern VALUE rbffi_StructByReferenceClass;
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* RBFFI_STRUCTBYREFERENCE_H */
+

data/ext/ffi_c/StructLayout.c

@@ -52,6 +52,8 @@ static void struct_layout_free(StructLayout *);
 static void struct_field_mark(StructField* );
 
 VALUE rbffi_StructLayoutFieldClass = Qnil;
+VALUE rbffi_StructLayoutNumberFieldClass = Qnil, rbffi_StructLayoutPointerFieldClass = Qnil;
+VALUE rbffi_StructLayoutStringFieldClass = Qnil;
 VALUE rbffi_StructLayoutFunctionFieldClass = Qnil, rbffi_StructLayoutArrayFieldClass = Qnil;
 
 VALUE rbffi_StructLayoutClass = Qnil;
@@ -320,6 +322,7 @@ struct_layout_allocate(VALUE klass)
     layout->rbFieldMap = Qnil;
     layout->rbFieldNames = Qnil;
     layout->rbFields = Qnil;
+    layout->fieldSymbolTable = st_init_numtable();
     layout->base.ffiType = xcalloc(1, sizeof(*layout->base.ffiType));
     layout->base.ffiType->size = 0;
     layout->base.ffiType->alignment = 0;
@@ -329,29 +332,29 @@ struct_layout_allocate(VALUE klass)
 }
 
 static VALUE
-struct_layout_initialize(VALUE self, VALUE field_names, VALUE fields, VALUE size, VALUE align)
+struct_layout_initialize(VALUE self, VALUE fields, VALUE size, VALUE align)
 {
     StructLayout* layout;
     ffi_type* ltype;
     int i;
 
     Data_Get_Struct(self, StructLayout, layout);
+    layout->fieldCount = RARRAY_LEN(fields);
     layout->rbFieldMap = rb_hash_new();
-    layout->rbFieldNames = rb_ary_dup(field_names);
+    layout->rbFieldNames = rb_ary_new2(layout->fieldCount);
     layout->size = NUM2INT(size);
     layout->align = NUM2INT(align);
-    layout->fieldCount = RARRAY_LEN(field_names);
     layout->fields = xcalloc(layout->fieldCount, sizeof(StructField *));
     layout->ffiTypes = xcalloc(layout->fieldCount + 1, sizeof(ffi_type *));
     layout->rbFields = rb_ary_new2(layout->fieldCount);
     layout->base.ffiType->elements = layout->ffiTypes;
-    layout->base.ffiType->size = 0;
-    layout->base.ffiType->alignment = 1;
+    layout->base.ffiType->size = layout->size;
+    layout->base.ffiType->alignment = layout->align;
 
     ltype = layout->base.ffiType;
     for (i = 0; i < (int) layout->fieldCount; ++i) {
-        VALUE rbName = rb_ary_entry(field_names, i);
-        VALUE rbField = rb_hash_aref(fields, rbName);
+        VALUE rbField = rb_ary_entry(fields, i);
+        VALUE rbName;
         StructField* field;
         ffi_type* ftype;
 
@@ -359,6 +362,7 @@ struct_layout_initialize(VALUE self, VALUE field_names, VALUE fields, VALUE size
         if (!rb_obj_is_kind_of(rbField, rbffi_StructLayoutFieldClass)) {
             rb_raise(rb_eTypeError, "wrong type for field %d.", i);
         }
+        rbName = rb_funcall2(rbField, rb_intern("name"), 0, NULL);
 
         Data_Get_Struct(rbField, StructField, field = layout->fields[i]);
 
@@ -371,20 +375,17 @@ struct_layout_initialize(VALUE self, VALUE field_names, VALUE fields, VALUE size
             rb_raise(rb_eTypeError, "type of field %d has zero size", i);
         }
 
-        rb_hash_aset(layout->rbFieldMap, rbName, rbField);
         layout->ffiTypes[i] = ftype;
+        st_insert(layout->fieldSymbolTable, rbName, rbField);
+        rb_hash_aset(layout->rbFieldMap, rbName, rbField);
         rb_ary_push(layout->rbFields, rbField);
-        ltype->size = MAX(ltype->size, field->offset + ftype->size);
-        ltype->alignment = MAX(ltype->alignment, ftype->alignment);
+        rb_ary_push(layout->rbFieldNames, rbName);
     }
 
     if (ltype->size == 0) {
         rb_raise(rb_eRuntimeError, "Struct size is zero");
     }
 
-    // Include tail padding
-    ltype->size = FFI_ALIGN(ltype->size, ltype->alignment);
-
     return self;
 }
 
@@ -442,6 +443,7 @@ struct_layout_free(StructLayout *layout)
     xfree(layout->ffiTypes);
     xfree(layout->base.ffiType);
     xfree(layout->fields);
+    st_free_table(layout->fieldSymbolTable);
     xfree(layout);
 }
 
@@ -455,6 +457,15 @@ rbffi_StructLayout_Init(VALUE moduleFFI)
     rbffi_StructLayoutFieldClass = rb_define_class_under(rbffi_StructLayoutClass, "Field", rb_cObject);
     rb_global_variable(&rbffi_StructLayoutFieldClass);
 
+    rbffi_StructLayoutNumberFieldClass = rb_define_class_under(rbffi_StructLayoutClass, "Number", rbffi_StructLayoutFieldClass);
+    rb_global_variable(&rbffi_StructLayoutNumberFieldClass);
+
+    rbffi_StructLayoutStringFieldClass = rb_define_class_under(rbffi_StructLayoutClass, "String", rbffi_StructLayoutFieldClass);
+    rb_global_variable(&rbffi_StructLayoutStringFieldClass);
+
+    rbffi_StructLayoutPointerFieldClass = rb_define_class_under(rbffi_StructLayoutClass, "Pointer", rbffi_StructLayoutFieldClass);
+    rb_global_variable(&rbffi_StructLayoutPointerFieldClass);
+
     rbffi_StructLayoutFunctionFieldClass = rb_define_class_under(rbffi_StructLayoutClass, "Function", rbffi_StructLayoutFieldClass);
     rb_global_variable(&rbffi_StructLayoutFunctionFieldClass);
 
@@ -478,7 +489,7 @@ rbffi_StructLayout_Init(VALUE moduleFFI)
     rb_define_method(rbffi_StructLayoutArrayFieldClass, "put", array_field_put, 2);
 
     rb_define_alloc_func(rbffi_StructLayoutClass, struct_layout_allocate);
-    rb_define_method(rbffi_StructLayoutClass, "initialize", struct_layout_initialize, 4);
+    rb_define_method(rbffi_StructLayoutClass, "initialize", struct_layout_initialize, 3);
     rb_define_method(rbffi_StructLayoutClass, "[]", struct_layout_aref, 1);
     rb_define_method(rbffi_StructLayoutClass, "fields", struct_layout_fields, 0);
     rb_define_method(rbffi_StructLayoutClass, "members", struct_layout_members, 0);

data/ext/ffi_c/Type.c

@@ -1,28 +1,19 @@
 /*
  * Copyright (c) 2009, Wayne Meissner
- * All rights reserved.
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
+ * This file is part of ruby-ffi.
  *
- * * Redistributions of source code must retain the above copyright notice, this
- *   list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright notice
- *   this list of conditions and the following disclaimer in the documentation
- *   and/or other materials provided with the distribution.
- * * The name of the author or authors may not be used to endorse or promote
- *   products derived from this software without specific prior written permission.
+ * This code is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3 only, as
+ * published by the Free Software Foundation.
  *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+ * version 3 for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <sys/param.h>
@@ -42,7 +33,7 @@ typedef struct BuiltinType_ {
 
 static void builtin_type_free(BuiltinType *);
 
-VALUE rbffi_TypeClass = Qnil, rbffi_EnumTypeClass = Qnil;
+VALUE rbffi_TypeClass = Qnil;
 
 static VALUE classBuiltinType = Qnil;
 static VALUE typeMap = Qnil, sizeMap = Qnil;
@@ -104,41 +95,12 @@ type_alignment(VALUE self)
 static VALUE
 type_inspect(VALUE self)
 {
-    char buf[256];
     Type *type;
 
     Data_Get_Struct(self, Type, type);
-    snprintf(buf, sizeof(buf), "#<FFI::Type:%p size=%d alignment=%d>", 
-            type, (int) type->ffiType->size, (int) type->ffiType->alignment);
-
-    return rb_str_new2(buf);
-}
-
-static VALUE
-enum_allocate(VALUE klass)
-{
-    Type* type;
-    VALUE obj;
-
-    obj = Data_Make_Struct(klass, Type, NULL, -1, type);
-    type->nativeType = NATIVE_ENUM;
-    type->ffiType = &ffi_type_sint;
-
-    return obj;
-}
-
-int
-rbffi_Type_GetIntValue(VALUE type)
-{
-    Type* t;
-
-    if (!rb_obj_is_kind_of(type, rbffi_TypeClass)) {
-        rb_raise(rb_eTypeError, "wrong type.  Expected (FFI::Type)");
-    }
-
-    Data_Get_Struct(type, Type, t);
 
-    return t->nativeType;
+    return rb_sprintf("#<%s:%p size=%d alignment=%d>",
+            rb_obj_classname(self), type, (int) type->ffiType->size, (int) type->ffiType->alignment);
 }
 
 static VALUE
@@ -166,14 +128,11 @@ builtin_type_free(BuiltinType *type)
 static VALUE
 builtin_type_inspect(VALUE self)
 {
-    char buf[256];
     BuiltinType *type;
 
     Data_Get_Struct(self, BuiltinType, type);
-    snprintf(buf, sizeof(buf), "#<FFI::Type::Builtin:%s size=%d alignment=%d>",
-            type->name, (int) type->type.ffiType->size, type->type.ffiType->alignment);
-
-    return rb_str_new2(buf);
+    return rb_sprintf("#<%s:%s size=%d alignment=%d>",
+            rb_obj_classname(self), type->name, (int) type->type.ffiType->size, type->type.ffiType->alignment);
 }
 
 int
@@ -231,8 +190,7 @@ rbffi_Type_Find(VALUE name)
     VALUE rbType = rbffi_Type_Lookup(name);
 
     if (!RTEST(rbType)) {
-        VALUE typeName = rb_funcall2(name, rb_intern("inspect"), 0, NULL);
-        rb_raise(rb_eTypeError, "Invalid type (%s)", RSTRING_PTR(typeName));
+        rb_raise(rb_eTypeError, "invalid type, %s", RSTRING_PTR(rb_inspect(name)));
     }
 
     return rbType;
@@ -243,7 +201,6 @@ rbffi_Type_Init(VALUE moduleFFI)
 {
     VALUE moduleNativeType;
     VALUE classType = rbffi_TypeClass = rb_define_class_under(moduleFFI, "Type", rb_cObject);
-    VALUE classEnum = rbffi_EnumTypeClass = rb_define_class_under(moduleFFI, "Enum", classType);
 
     rb_define_const(moduleFFI, "TypeDefs", typeMap = rb_hash_new());
     rb_define_const(moduleFFI, "SizeTypes", sizeMap = rb_hash_new());
@@ -270,9 +227,7 @@ rbffi_Type_Init(VALUE moduleFFI)
     // Make Type::Builtin non-allocatable
     rb_undef_method(CLASS_OF(classBuiltinType), "new");
     rb_define_method(classBuiltinType, "inspect", builtin_type_inspect, 0);
-
-    rb_define_alloc_func(classEnum, enum_allocate);
-
+    
     rb_global_variable(&rbffi_TypeClass);
     rb_global_variable(&classBuiltinType);
 
@@ -284,29 +239,45 @@ rbffi_Type_Init(VALUE moduleFFI)
         rb_define_const(moduleFFI, "TYPE_" #x, t); \
     } while(0)
 
+    #define A(old_type, new_type) do { \
+        VALUE t = rb_const_get(classType, rb_intern(#old_type)); \
+        rb_const_set(classType, rb_intern(#new_type), t); \
+    } while(0)
+
     T(VOID, &ffi_type_void);
     T(INT8, &ffi_type_sint8);
+    A(INT8, SCHAR);
+    A(INT8, CHAR);
     T(UINT8, &ffi_type_uint8);
+    A(UINT8, UCHAR);
+
     T(INT16, &ffi_type_sint16);
+    A(INT16, SHORT);
+    A(INT16, SSHORT);
     T(UINT16, &ffi_type_uint16);
+    A(UINT16, USHORT);
     T(INT32, &ffi_type_sint32);
+    A(INT32, INT);
+    A(INT32, SINT);
     T(UINT32, &ffi_type_uint32);
+    A(UINT32, UINT);
     T(INT64, &ffi_type_sint64);
+    A(INT64, LONG_LONG);
+    A(INT64, SLONG_LONG);
     T(UINT64, &ffi_type_uint64);
+    A(UINT64, ULONG_LONG);
     T(LONG, &ffi_type_slong);
+    A(LONG, SLONG);
     T(ULONG, &ffi_type_ulong);
     T(FLOAT32, &ffi_type_float);
+    A(FLOAT32, FLOAT);
     T(FLOAT64, &ffi_type_double);
+    A(FLOAT64, DOUBLE);
     T(POINTER, &ffi_type_pointer);
     T(STRING, &ffi_type_pointer);
-    T(RBXSTRING, &ffi_type_pointer);
     T(BUFFER_IN, &ffi_type_pointer);
     T(BUFFER_OUT, &ffi_type_pointer);
     T(BUFFER_INOUT, &ffi_type_pointer);
-    T(ENUM, &ffi_type_sint);
     T(BOOL, &ffi_type_uchar);
-
-
-    T(CHAR_ARRAY, &ffi_type_void);
     T(VARARGS, &ffi_type_void);
 }