Changeset 55 for NEWT0/trunk/contrib

Timestamp:

05/26/06 19:14:30 (3 years ago)

Author:

pguyot

Message:

Change in the APIs to be compatible with Relativity API.
(actually, use of :DefGlobalFn(symbol, spec) is discouraged in Relativity)

Location:

NEWT0/trunk/contrib/NativeCalls

Files:

• NativeCalls.c (modified) (12 diffs)
• native.newt (modified) (2 diffs)

NEWT0/trunk/contrib/NativeCalls/NativeCalls.c

@@ -495 +495 @@
             theResult = false;
         }
-    } else if (NewtSymbolEqual(inNSType, NSSYM(string))) {
+    } else if ((NewtSymbolEqual(inNSType, NSSYM(string)))
+        || (NewtSymbolEqual(inNSType, NSSYM(iostring)))) {
         *outFFIType = &ffi_type_pointer;
         if (NewtRefIsString(inNSValue))
@@ -505 +506 @@
             theResult = false;
         }
-    } else if (NewtSymbolEqual(inNSType, NSSYM(binary))) {
+    } else if ((NewtSymbolEqual(inNSType, NSSYM(binary)))
+        || (NewtSymbolEqual(inNSType, NSSYM(iobinary)))) {
         *outFFIType = &ffi_type_pointer;
         if (NewtRefIsBinary(inNSValue))
@@ -512 +514 @@
                 (void*) NewtRefToBinary(inNSValue);
         } else {
-            (void) NewtThrow(kNErrNotAString, inNSValue);
+            (void) NewtThrow(kNErrNotABinaryObject, inNSValue);
             theResult = false;
         }
@@ -736 +738 @@
 
 /**
- * Native function lib:DefineGlobalFn(specs)
+ * Native function lib:GetFunction(specs)
  *
  * specs is a frame defining the native function. It includes the following
@@ -742 +744 @@
  *
  * name         (string) name of the native function to call
- * symbol       (symbol) optional name of the global function to define. If not
- *              present (or nil), the global function will have the same name as
- *              the native function. Use this when names conflicts (e.g. strlen
- *              and StrLen)
  * args         (array of symbols) types of the arguments.
  * result       (symbol) type of the result.
@@ -767 +765 @@
  *  'longdouble real                ffi_type_longdouble
  *  'string     string              ffi_type_pointer
+ *  'iostring   string              ffi_type_pointer        not available for result
  *  'binary     binary              ffi_type_pointer        not available for result
+ *  'iobinary   binary              ffi_type_pointer        not available for result
  *  'pointer    int or binary       ffi_type_pointer
  *
  * Structures aren't supported yet.
- *
- * The symbol of the function is added to a list of the library object to allow
- * Close to undefine the function.
+ * string and iostring are identical (strings are I/O). Same with binary and
+ * iobinary. This may change in the future.
  *
  * @param inRcvr    self
@@ -780 +779 @@
  */
 newtRef
-DefineGlobalFn(
+GetFunction(
     newtRefArg inRcvr,
     newtRefArg inSpec)
@@ -787 +786 @@
     newtRefVar resultType;
     newtRefVar functionName;
-    newtRefVar functionSymbol;
     newtRefVar functionObject;
-    newtRefVar libList;
 
     /* check self */
@@ -820 +817 @@
     {
         return NewtThrow(kNErrNotAString, functionName);
-    }
-    functionSymbol = NcGetSlot(inSpec, NSSYM(symbol));
-    if (NewtRefIsNIL(functionSymbol))
-    {
-        functionSymbol = NewtMakeSymbol(NewtRefToString(functionName));
-    } else if (!NewtRefIsSymbol(functionSymbol)) {
-        return NewtThrow(kNErrNotASymbol, functionSymbol);
-    }
-    
-    /* check the function doesn't exist yet */
-    if (NewtHasGlobalFn(functionSymbol))
-    {
-        return NewtThrow(
-                kNErrNative,
-                NewtMakeString("Global function already exists", true));
     }
     
@@ -847 +829 @@
     NcSetSlot(functionObject, NSSYM(_argTypes), argTypes);
     
+    return functionObject;
+}
+
+/**
+ * Native function lib:DefGlobalFn(symbol, specs)
+ *
+ * symbol is the symbol of the function to define.
+ * specs is a frame defining the native function. It is passed to GetFunction.
+ *
+ * The symbol of the function is added to a list of the library object to allow
+ * Close to undefine the function.
+ *
+ * @param inRcvr    self
+ * @param inSymbol  function symbol
+ * @param inSpec    specification frame
+ * @return NIL
+ */
+newtRef
+DefGlobalFn(
+    newtRefArg inRcvr,
+    newtRefArg inSymbol,
+    newtRefArg inSpec)
+{
+    newtRefVar functionObject;
+    newtRefVar libList;
+    
+    /* check the function doesn't exist yet */
+    if (NewtHasGlobalFn(inSymbol))
+    {
+        return NewtThrow(
+                kNErrNative,
+                NewtMakeString("Global function already exists", true));
+    }
+    
+    /* Get the object */
+    functionObject = GetFunction(inRcvr, inSpec);
+    
     /* add the function to the list */
     libList = NcGetSlot(inRcvr, NSSYM(_globalFns));
@@ -854 +873 @@
         NcSetSlot(inRcvr, NSSYM(_globalFns), libList);
     }
-    NcAddArraySlot(libList, functionSymbol);
+    NcAddArraySlot(libList, inSymbol);
     
     /* define the global function */
-    NcDefGlobalFn(functionSymbol, functionObject);
-
-    return kNewtRefNIL;
+    NcDefGlobalFn(inSymbol, functionObject);
+    
+    return inSymbol;
 }
 
@@ -959 +978 @@
             Close, 0, "Close()"));
     NcSetSlot(magicPtr,
-        NSSYM(DefineGlobalFn),
+        NSSYM(GetFunction),
         NewtMakeNativeFunc(
-            DefineGlobalFn, 1, "DefineGlobalFn(specs)"));
+            GetFunction, 1, "GetFunction(spec)"));
+    NcSetSlot(magicPtr,
+        NSSYM(DefGlobalFn),
+        NewtMakeNativeFunc(
+            DefGlobalFn, 2, "DefGlobalFn(symbol, spec)"));
 
     NcDefMagicPointer(kLibParentMagicPtrKey, magicPtr);

NEWT0/trunk/contrib/NativeCalls/native.newt

@@ -12 +12 @@
 
     local libc := OpenNativeLibrary("libc");
-    libc:DefineGlobalFn({
-        name: "gethostname",
-        symbol: '|libc.gethostname|,
+    libc:DefGlobalFn(
+        '|libc.gethostname|,
+        {name: "gethostname",
         args: ['string, 'sint32],
         result: 'sint32});
-    libc:DefineGlobalFn({
-        name: "socket",
-        symbol: '|libc.socket|,
+    libc:DefGlobalFn(
+        '|libc.socket|,
+        {name: "socket",
         args: ['sint32, 'sint32, 'sint32],
         result: 'sint32});
-    libc:DefineGlobalFn({
-        name: "close",
-        symbol: '|libc.close|,
+    libc:DefGlobalFn(
+        '|libc.close|,
+        {name: "close",
+        args: ['sint32],
+        result: 'sint32});
+    libc:DefGlobalFn(
+        '|libc.popen|,
+        {name: "popen",
+        args: ['string, 'string],
+        result: 'sint32});
+    libc:DefGlobalFn(
+        '|libc.pclose|,
+        {name: "pclose",
         args: ['sint32],
         result: 'sint32});
 
     local libm := OpenNativeLibrary("libm");
-    libm:DefineGlobalFn({
-        name: "cos",
-        symbol: '|libm.cos|,
+    libm:DefGlobalFn(
+        '|libm.cos|,
+        {name: "cos",
         args: ['double],
         result: 'double});
 
     local libcurses := OpenNativeLibrary("libcurses");
-    libcurses:DefineGlobalFn({
-        name: "initscr",
-        symbol: '|libcurses.initscr|,
+    libcurses:DefGlobalFn(
+        '|libcurses.initscr|,
+        {name: "initscr",
         args: [],
         result: 'pointer});
-    libcurses:DefineGlobalFn({
-        name: "cbreak",
-        symbol: '|libcurses.cbreak|,
+    libcurses:DefGlobalFn(
+        '|libcurses.cbreak|,
+        {name: "cbreak",
         args: [],
         result: 'sint32});
-    libcurses:DefineGlobalFn({
-        name: "noecho",
-        symbol: '|libcurses.noecho|,
+    libcurses:DefGlobalFn(
+        '|libcurses.noecho|,
+        {name: "noecho",
         args: [],
         result: 'sint32});
-    libcurses:DefineGlobalFn({
-        name: "flash",
-        symbol: '|libcurses.flash|,
+    libcurses:DefGlobalFn(
+        '|libcurses.flash|,
+        {name: "flash",
         args: [],
         result: 'sint32});
-    libcurses:DefineGlobalFn({
-        name: "endwin",
-        symbol: '|libcurses.endwin|,
+    libcurses:DefGlobalFn(
+        '|libcurses.endwin|,
+        {name: "endwin",
         args: [],
         result: 'sint32});
@@ -111 +121 @@
     |libcurses.endwin|();
 
+    // call open(1)
+    local popenref := |libc.popen|("open /Applications/TextEdit.app/", "r");
+    |libc.pclose|(popenref);
+
     libm:Close();
     libc:Close();