Changeset 70

Timestamp:

01/20/07 10:41:16 (22 months ago)

Author:

pguyot

Message:

Update to makefiles for portability.
NativeCalls: support for structure (see the sample code connecting to google.com).

Location:

NEWT0/trunk/contrib

Files:

• NativeCalls/Makefile (modified) (2 diffs)
• NativeCalls/NativeCalls.c (modified) (22 diffs)
• NativeCalls/native.newt (modified) (3 diffs)
• NewtObjC/Makefile (modified) (2 diffs)

NEWT0/trunk/contrib/NativeCalls/Makefile

@@ -5 +5 @@
 core = $(srcdir)/newt_core
 
-LIBFFI_PREFIX = /opt/local
+prefix = /opt/local
+exec_prefix = ${prefix}
+sitedir = ${prefix}/lib/newt0
+libffidir = ${prefix}
 
-DEBUG = # -g
-INCS = -I$(srcdir) -I$(core)/incs -I$(LIBFFI_PREFIX)/include
+CC = gcc
+AR = ar
+RANLIB = ranlib
+YACC = bison -y -d
+LEX = flex
+DEFS = -DHAVE_CONFIG_H
+LIBS = 
+DLEXT = dylib
+EXEEXT = 
+LDIMPORT = 
+DEBUG = -g
+LDFLAGS = $(DEBUG) -O2  
+LDSHARED = $(CC) -dynamic -bundle -undefined suppress -flat_namespace
+
+INCS = -I$(srcdir) -I$(core)/incs -I$(libffidir)/include
 EXTLIBS = 
 
-
-include $(proj)/platform/$(shell uname)
-
-LIBFFI = $(LIBFFI_PREFIX)/lib/libffi.a
+LIBFFI = $(libffidir)/lib/libffi.a
 
 NEWTLIBNAME = NativeCalls
-NEWTEXLIB   = $(build)/$(NEWTLIBNAME).$(NEWTLIBSUFFIX)
+NEWTEXLIB   = $(build)/$(NEWTLIBNAME).$(DLEXT)
 
 LIBOBJ      = $(build)/$(NEWTLIBNAME).o
-CFLAGS      += -Wall -DDYLIBSUFFIX='"$(NEWTLIBSUFFIX)"'
+CFLAGS      += $(DEBUG) -Wall -DDYLIBSUFFIX='"$(DLEXT)"'
 
 .c.o:
@@ -37 +50 @@
     $(CC) $(CFLAGS) $(INCS) -c $< -o $@
 
+install::
+    install -d -m 755 $(DESTDIR)$(sitedir)
+    install -m 644 $(NEWTEXLIB) $(DESTDIR)$(sitedir)
+
 clean:
     rm -rf $(NEWTEXLIB)

NEWT0/trunk/contrib/NativeCalls/NativeCalls.c

@@ -62 +62 @@
     void*       fPointer;
 } SStorage;
+
+typedef struct SBufferZone {
+    int         fNumberBuffers;
+    void**      fBufferTable;
+} SBufferZone;
+
+/**
+ * Allocate an empty storage buffer.
+ *
+ * @param outBuffer on output, allocated buffer.
+ */
+void
+AllocateBuffer(SBufferZone* outBuffer)
+{
+    outBuffer->fNumberBuffers = 0;
+    outBuffer->fBufferTable = (void**) malloc(0);
+}
+
+/**
+ * Release a storage buffer.
+ *
+ * @param ioBuffer  buffer to release.
+ */
+void
+ReleaseBuffer(SBufferZone* ioBuffer)
+{
+    /* Iterate on all buffers */
+    int indexBuffers;
+    int nbBuffers = ioBuffer->fNumberBuffers;
+    void** cursor = ioBuffer->fBufferTable;
+    
+    for (indexBuffers = 0; indexBuffers < nbBuffers; indexBuffers++)
+    {
+        free(*cursor);
+        *cursor++;
+    }
+    
+    free(ioBuffer->fBufferTable);
+    ioBuffer->fNumberBuffers = 0;
+    ioBuffer->fBufferTable = NULL;
+}
+
+/**
+ * Allocate a segment in a buffer.
+ *
+ * @param ioBuffer  buffer in which to allocate the segment.
+ * @param inSize    segment size.
+ */
+void*
+AllocateBufferSegment(SBufferZone* ioBuffer, int inSize)
+{
+    void* theResult = malloc(inSize);
+    int newBufferCount = ++ioBuffer->fNumberBuffers;
+    ioBuffer->fBufferTable =
+        realloc(ioBuffer->fBufferTable, newBufferCount * sizeof(void*));
+    ioBuffer->fBufferTable[newBufferCount - 1] = theResult;
+    
+    return theResult;
+}
 
 /**
@@ -304 +363 @@
         theResult = NewtMakeReal( inValue->fLongDouble );
     } else if (NewtSymbolEqual(inNSType, NSSYM(string))) {
-        theResult = NewtMakeString((char*) inValue->fPointer, false);
+        if (inValue->fPointer) {
+            theResult = NewtMakeString((char*) inValue->fPointer, false);
+        } else {
+            theResult = kNewtRefNIL;
+        }
     } else if (NewtSymbolEqual(inNSType, NSSYM(pointer))) {
-        theResult = PointerToBinary(inValue->fPointer);
+        if (inValue->fPointer) {
+            theResult = PointerToBinary(inValue->fPointer);
+        } else {
+            theResult = kNewtRefNIL;
+        }
     } else {
         theResult = kNewtRefNIL;
@@ -364 +431 @@
 }
 
-/**
- * From a type (in NS format), and a value, set the ffi type and cast the
- * value.
- *
- * @param inNSType      ns type.
- * @param inNSValue     ns value.
- * @param outFFIType    ffi type.
- * @param outFFIValue   ffi value.
- * @return \c true if the type and value were cast, \c false otherwise, if
- * there was a typing error (the exception would have already been thrown then).
- */
+/* forward declaration */
 bool
 CastTypeAndValue(
@@ -380 +437 @@
             newtRefArg inNSValue,
             ffi_type** outFFIType,
-            SStorage* outFFIValue)
-{
+            void* outFFIValue,
+            size_t* outValueSize,
+            SBufferZone* ioStorage);
+
+/**
+ * From an array of types (in NS format), and an array of values, set the ffi
+ * types and cast the values.
+ *
+ * @param inNbArgs      number of args.
+ * @param inNSTypes     ns types.
+ * @param inNSValues    ns values.
+ * @param outFFITypes   ffi types (allocated in the buffer).
+ * @param outFFIValues  ffi values (allocated in the buffer).
+ * @param ioStorage     storage buffer.
+ * @return \c true if the type and value were cast, \c false otherwise, if
+ * there was a typing error (the exception would have already been thrown then).
+ */
+bool
+CastTypesAndValues(
+        int inNbArgs,
+        newtRefVar inNSTypes,
+        newtRefVar inNSValues,
+        ffi_type*** outFFITypes,
+        void*** outFFIValues,
+        void** outStorage,
+        SBufferZone* ioStorage)
+{
+    ffi_type**  ffiArgsTypes;
+    void**      argsValues;
+    SStorage*   argsStorage;
+    void*       cursorStorage;
+    int         indexArgs;
+    int         ffitypes_size = (inNbArgs + 1) * sizeof(ffi_type*);
+    int         storage_size = inNbArgs * sizeof(SStorage);
+    bool        typeError = false;  
+
+    /* build the ffi lists */
+    ffiArgsTypes = (ffi_type**) AllocateBufferSegment(ioStorage, ffitypes_size);
+    bzero(ffiArgsTypes, ffitypes_size);
+    argsValues = (void**) AllocateBufferSegment(ioStorage, sizeof(void*) * inNbArgs);
+    argsStorage = (SStorage*) AllocateBufferSegment(ioStorage, storage_size);
+    bzero(argsStorage, storage_size);
+    cursorStorage = argsStorage;
+    
+    for (indexArgs = 0; indexArgs < inNbArgs; indexArgs++)
+    {
+        newtRefVar theType, theValue;
+        size_t theSize;
+        
+        theType = NewtGetArraySlot(inNSTypes, indexArgs);
+        theValue = NewtGetArraySlot(inNSValues, indexArgs);
+        /* use the storage */
+        argsValues[indexArgs] = cursorStorage;
+        if (!CastTypeAndValue(
+                    theType,
+                    theValue,
+                    &ffiArgsTypes[indexArgs],
+                    cursorStorage,
+                    &theSize,
+                    ioStorage))
+        {
+            typeError = true;
+            break;
+        }
+        cursorStorage = (void*) (((char*) cursorStorage) + theSize);
+    }
+    
+    *outFFITypes = ffiArgsTypes;
+    if (outFFIValues)
+    {
+        *outFFIValues = argsValues;
+    }
+    if (outStorage)
+    {
+        *outStorage = argsStorage;
+    }
+
+    return !typeError;
+}
+
+/**
+ * From a type (in NS format), and a value, set the ffi type and cast the
+ * value.
+ *
+ * @param inNSType      ns type.
+ * @param inNSValue     ns value.
+ * @param outFFIType    ffi type.
+ * @param outFFIValue   ffi value.
+ * @param ioStorage     storage buffer.
+ * @return \c true if the type and value were cast, \c false otherwise, if
+ * there was a typing error (the exception would have already been thrown then).
+ */
+bool
+CastTypeAndValue(
+            newtRefArg inNSType,
+            newtRefArg inNSValue,
+            ffi_type** outFFIType,
+            void* outFFIValue,
+            size_t* outValueSize,
+            SBufferZone* ioStorage)
+{
+    size_t theSize = 0;
     bool theResult = true;
     
-    if (NewtSymbolEqual(inNSType, NSSYM(uint8)))
-    {
+    if (NewtRefIsArray(inNSType))
+    {
+        // Structure.
+        int nbVals = NewtArrayLength(inNSType);
+        if (nbVals != NewtArrayLength(inNSValue))
+        {
+            theResult = false;
+        } else {
+            ffi_type** theTypes;
+            void* theValues;
+            theResult = CastTypesAndValues(
+                nbVals,
+                inNSType,
+                inNSValue,
+                &theTypes,
+                NULL,
+                &theValues,
+                ioStorage);
+            if (theResult) {
+                // Make the record.
+                ffi_type* theType = (ffi_type*)
+                    AllocateBufferSegment(ioStorage, sizeof(ffi_type));
+                *outFFIType = theType;
+                theType->size = 0;
+                theType->alignment = 0;
+                theType->type = FFI_TYPE_STRUCT;
+                theType->elements = theTypes;
+                *((void**) outFFIValue) = theValues;
+                theSize = sizeof(void*);
+            }
+        }
+    } else if (NewtSymbolEqual(inNSType, NSSYM(uint8))) {
         *outFFIType = &ffi_type_uint8;
         if (NewtRefIsInteger(inNSValue))
         {
-            outFFIValue->fInt8 =
+            *((uint8_t*) outFFIValue) =
                 (uint8_t) NewtRefToInteger(inNSValue);
+            theSize = sizeof(uint8_t);
         } else {
             (void) NewtThrow(kNErrNotAnInteger, inNSValue);
@@ -399 +587 @@
         if (NewtRefIsInteger(inNSValue))
         {
-            outFFIValue->fInt8 =
+            *((uint8_t*) outFFIValue) =
                 (uint8_t) (int8_t) NewtRefToInteger(inNSValue);
+            theSize = sizeof(uint8_t);
         } else {
             (void) NewtThrow(kNErrNotAnInteger, inNSValue);
@@ -409 +598 @@
         if (NewtRefIsInteger(inNSValue))
         {
-            outFFIValue->fInt16 =
+            *((uint16_t*) outFFIValue) =
                 (uint16_t) NewtRefToInteger(inNSValue);
+            theSize = sizeof(uint16_t);
         } else {
             (void) NewtThrow(kNErrNotAnInteger, inNSValue);
@@ -419 +609 @@
         if (NewtRefIsInteger(inNSValue))
         {
-            outFFIValue->fInt16 =
+            *((uint16_t*) outFFIValue) =
                 (uint16_t) (int16_t) NewtRefToInteger(inNSValue);
+            theSize = sizeof(uint16_t);
         } else {
             (void) NewtThrow(kNErrNotAnInteger, inNSValue);
@@ -429 +620 @@
         if (NewtRefIsInteger(inNSValue))
         {
-            outFFIValue->fInt32 =
+            *((uint32_t*) outFFIValue) =
                 (uint32_t) NewtRefToInteger(inNSValue);
+            theSize = sizeof(uint32_t);
         } else {
             (void) NewtThrow(kNErrNotAnInteger, inNSValue);
@@ -439 +631 @@
         if (NewtRefIsInteger(inNSValue))
         {
-            outFFIValue->fInt32 =
+            *((uint32_t*) outFFIValue) =
                 (uint32_t) (int32_t) NewtRefToInteger(inNSValue);
+            theSize = sizeof(uint32_t);
         } else {
             (void) NewtThrow(kNErrNotAnInteger, inNSValue);
@@ -449 +642 @@
         if (NewtRefIsInteger(inNSValue))
         {
-            outFFIValue->fInt64 =
+            *((uint64_t*) outFFIValue) =
                 (uint64_t) NewtRefToInteger(inNSValue);
+            theSize = sizeof(uint64_t);
         } else {
             (void) NewtThrow(kNErrNotAnInteger, inNSValue);
@@ -459 +653 @@
         if (NewtRefIsInteger(inNSValue))
         {
-            outFFIValue->fInt64 =
+            *((uint64_t*) outFFIValue) =
                 (uint64_t) (int64_t) NewtRefToInteger(inNSValue);
+            theSize = sizeof(uint64_t);
         } else {
             (void) NewtThrow(kNErrNotAnInteger, inNSValue);
@@ -469 +664 @@
         if (NewtRefIsReal(inNSValue))
         {
-            outFFIValue->fFloat =
+            *((float*) outFFIValue) =
                 (float) NewtRefToReal(inNSValue);
+            theSize = sizeof(float);
         } else {
             (void) NewtThrow(kNErrNotAReal, inNSValue);
@@ -479 +675 @@
         if (NewtRefIsReal(inNSValue))
         {
-            outFFIValue->fDouble =
+            *((double*) outFFIValue) =
                 (double) NewtRefToReal(inNSValue);
+            theSize = sizeof(double);
         } else {
             (void) NewtThrow(kNErrNotAReal, inNSValue);
@@ -489 +686 @@
         if (NewtRefIsReal(inNSValue))
         {
-            outFFIValue->fLongDouble =
+            *((long double*) outFFIValue) =
                 (long double) NewtRefToReal(inNSValue);
+            theSize = sizeof(long double);
         } else {
             (void) NewtThrow(kNErrNotAReal, inNSValue);
@@ -500 +698 @@
         if (NewtRefIsString(inNSValue))
         {
-            outFFIValue->fPointer =
+            *((void**) outFFIValue) =
                 (void*) NewtRefToString(inNSValue);
+            theSize = sizeof(void*);
         } else {
             (void) NewtThrow(kNErrNotAString, inNSValue);
@@ -511 +710 @@
         if (NewtRefIsBinary(inNSValue))
         {
-            outFFIValue->fPointer =
+            *((void**) outFFIValue) =
                 (void*) NewtRefToBinary(inNSValue);
+            theSize = sizeof(void*);
         } else {
             (void) NewtThrow(kNErrNotABinaryObject, inNSValue);
@@ -521 +721 @@
         if (NewtRefIsInteger(inNSValue))
         {
-            outFFIValue->fPointer =
+            *((void**) outFFIValue) =
                 (void*) NewtRefToInteger(inNSValue);
+            theSize = sizeof(void*);
         } else if (NewtRefIsBinary(inNSValue)) {
-            outFFIValue->fPointer =
+            *((void**) outFFIValue) =
                 BinaryToPointer(inNSValue);
+            theSize = sizeof(void*);
         } else {
             (void) NewtThrow(kNErrNotABinaryObject, inNSValue);
@@ -535 +737 @@
     }
     
+    if (outValueSize)
+    {
+        *outValueSize = theSize;
+    }
+    
     return theResult;
-}
-
-/**
- * Provided with an array of FFI types, frees it recursively, handling
- * structures in it. Last item in the array should be NULL. The pointer is
- * freed as well. This function is recursive.
- *
- * @param inTypes   types array to free.
- */
-void
-FreeFFITypes(ffi_type** inTypes)
-{
-    ffi_type** cursor = inTypes;
-    while (*cursor)
-    {
-        if ((*cursor)->type == FFI_TYPE_STRUCT)
-        {
-            /* Iterate recursively in this structure. */
-            ffi_type** elements = (*cursor)->elements;
-            if (elements)
-            {
-                FreeFFITypes(elements);
-            }
-        }
-        
-        cursor++;
-    }
-    
-    /* free the array */
-    free( inTypes );
 }
 
@@ -577 +754 @@
     ffi_type**  ffiArgsTypes;
     void**      argsValues;
-    SStorage*   argsStorage;
-    int         indexArgs;
+    SBufferZone storage;
     int         nbArgs;
     SStorage    result;
@@ -641 +817 @@
 
     /* build the ffi lists */
-    ffiArgsTypes = (ffi_type**) calloc( (nbArgs + 1), sizeof(ffi_type*)  );
-    argsValues = (void**) malloc( sizeof(void*) * nbArgs );
-    argsStorage = (SStorage*) malloc( sizeof(SStorage) * nbArgs );
-    
-    for (indexArgs = 0; indexArgs < nbArgs; indexArgs++)
-    {
-        newtRefVar theType, theValue;
-        
-        theType = NewtGetArraySlot(argTypes, indexArgs);
-        theValue = NewtGetArraySlot(inArgs, indexArgs);
-        /* use the storage */
-        argsValues[indexArgs] = &argsStorage[indexArgs];
-        if (!CastTypeAndValue(
-                    theType,
-                    theValue,
-                    &ffiArgsTypes[indexArgs],
-                    &argsStorage[indexArgs]))
-        {
-            typeError = true;
-            break;
-        }
-    }
+    AllocateBuffer(&storage);
+    CastTypesAndValues(nbArgs, argTypes, inArgs, &ffiArgsTypes, &argsValues, NULL, &storage);
     
     if (!typeError)
@@ -689 +845 @@
     }
 
-    FreeFFITypes(ffiArgsTypes);
-    free(argsValues);
-    free(argsStorage);
+    ReleaseBuffer(&storage);
 
     return resultRef;
@@ -769 +923 @@
  *  'iobinary   binary              ffi_type_pointer        not available for result
  *  'pointer    int or binary       ffi_type_pointer
- *
- * Structures aren't supported yet.
+ *  [array]     array               ffi_type_struct         not available for result
+ *
  * string and iostring are identical (strings are I/O). Same with binary and
  * iobinary. This may change in the future.

NEWT0/trunk/contrib/NativeCalls/native.newt

@@ -21 +21 @@
         {name: "socket",
         args: ['sint32, 'sint32, 'sint32],
+        result: 'sint32});
+/*
+-- This is on BSD systems. On some systems, there is no sin_len field.
+struct sockaddr_in {
+  uint8_t         sin_len;      // length of structure (16)
+  sa_family_t     sin_family;   // AF_INET
+  in_port_t       sin_port;     // 16-bit TCP or UDP port number
+                                // network byte ordered
+  struct in_addr  sin_addr;     // 32-bit IPv4 address
+                                // network byte ordered
+  char            sin_zero[8];  // unused
+};
+*/
+    libc:DefGlobalFn(
+        '|libc.bind_ipv4|,
+        {name: "bind",
+        args: ['sint32, ['uint8, 'uint8, 'uint16, 'uint8, 'uint8, 'uint8, 'uint8, 'uint8, 'uint8, 'uint8, 'uint8, 'uint8, 'uint8, 'uint8, 'uint8], 'sint32],
+        result: 'sint32});
+    libc:DefGlobalFn(
+        '|libc.connect_ipv4|,
+        {name: "connect",
+        args: ['sint32, ['uint8, 'uint8, 'uint16, 'uint8, 'uint8, 'uint8, 'uint8, 'uint8, 'uint8, 'uint8, 'uint8, 'uint8, 'uint8, 'uint8, 'uint8], 'sint32],
+        result: 'sint32});
+    libc:DefGlobalFn(
+        '|libc.write|,
+        {name: "write",
+        args: ['sint32, 'string, 'sint32],
+        result: 'sint32});
+    libc:DefGlobalFn(
+        '|libc.read|,
+        {name: "read",
+        args: ['sint32, 'string, 'sint32],
         result: 'sint32});
     libc:DefGlobalFn(
@@ -93 +125 @@
         Print("socket returned an error (" & GetErrno() & ")\n");
     end else begin
-        // To bind the socket, I need to support structures.
-        // ...
-        Print("socket fd: " & socket & "\n");
+        try
+            Print("socket fd: " & socket & "\n");
+            
+            result := |libc.bind_ipv4|(socket, [
+                16 /* length */,
+                AF_INET,
+                0, /* port: any */
+                0, 0, 0, 0, /* address: any */
+                0, 0, 0, 0, /* zero */
+                0, 0, 0, 0  /* zero */], 16);
+    
+            if (result < 0) then
+            begin
+                Throw('|evt.native-errno;type.ref.string|, "bind");
+            end;
+    
+            result := |libc.connect_ipv4|(socket, [
+                16 /* length */,
+                AF_INET,
+                80,
+                66, 249, 89, 104, /* address */ // Google.
+                0, 0, 0, 0, /* zero */
+                0, 0, 0, 0 /* zero */], 16);
+    
+            if (result < 0) then
+            begin
+                Throw('|evt.native-errno;type.ref.string|, "connect");
+            end;
+
+            result := |libc.write|(socket, "GET / HTTP/1.0\n\n", 16);
+    
+            if (result < 0) then
+            begin
+                Throw('|evt.native-errno;type.ref.string|, "write");
+            end;
+
+            local data := MakeBinary(512, 'string);
+            result := |libc.read|(socket, data, 512);
+            P(data);
+    
+            if (result < 0) then
+            begin
+                Throw('|evt.native-errno;type.ref.string|, "read");
+            end;
+            
+        onexception |evt.native-errno| do
+        begin
+            Print("An error occurred with function " &
+                CurrentException().data & " (" &
+                GetErrno() & ")\n");
+        end;
 
         // Close the socket.
@@ -102 +182 @@
         if (result < 0) then
         begin
-            Print("close returned an error (" & errno & ")\n");
+            Print("close returned an error (" & GetErrno() & ")\n");
         end;
     end;

NEWT0/trunk/contrib/NewtObjC/Makefile

@@ -5 +5 @@
 core = $(srcdir)/newt_core
 
+prefix = /opt/local
+exec_prefix = ${prefix}
+sitedir = ${prefix}/lib/newt0
+libffidir = ${prefix}
+
+CC = gcc
+AR = ar
+RANLIB = ranlib
+YACC = bison -y -d
+LEX = flex
+DEFS = -DHAVE_CONFIG_H
+LIBS = 
+DLEXT = dylib
+EXEEXT = 
+LDIMPORT =