(posix_pathname_to_fsspec, fsspec_to_posix_pathname): Add

prototypes.  Make static.
(mac_aedesc_to_lisp): Initialize err to noErr.
(mac_coerce_file_name_ptr, mac_coerce_file_name_desc)
(init_coercion_handler): New functions.
(Fmac_coerce_ae_data): Use coercion of Apple event data for
translation from/to file names.

1 files changed, 280 insertions, 78 deletions

diff --git a/src/mac.c b/src/mac.c
index 0e2eac877da..7c3e495f3a9 100644
--- a/src/mac.c
+++ b/src/mac.c
@@ -79,6 +79,8 @@ static ComponentInstance as_scripting_component;
 /* The single script context used for all script executions.  */
 static OSAID as_script_context;
 
+static OSErr posix_pathname_to_fsspec P_ ((const char *, FSSpec *));
+static OSErr fsspec_to_posix_pathname P_ ((const FSSpec *, char *, int));
 
 /* When converting from Mac to Unix pathnames, /'s in folder names are
    converted to :'s.  This function, used in copying folder names,
@@ -333,7 +335,7 @@ Lisp_Object
 mac_aedesc_to_lisp (desc)
      AEDesc *desc;
 {
-  OSErr err;
+  OSErr err = noErr;
   DescType desc_type = desc->descriptorType;
   Lisp_Object result;
 
@@ -397,6 +399,277 @@ mac_aedesc_to_lisp (desc)
   return Fcons (make_unibyte_string ((char *) &desc_type, 4), result);
 }
 
+static pascal OSErr
+mac_coerce_file_name_ptr (type_code, data_ptr, data_size,
+                          to_type, handler_refcon, result)
+     DescType type_code;
+     const void *data_ptr;
+     Size data_size;
+     DescType to_type;
+     long handler_refcon;
+     AEDesc *result;
+{
+  OSErr err;
+
+  if (type_code == TYPE_FILE_NAME)
+    /* Coercion from undecoded file name.  */
+    switch (to_type)
+      {
+      case typeAlias:
+      case typeFSS:
+      case typeFSRef:
+#ifdef MAC_OSX
+      case typeFileURL:
+#endif
+        {
+#ifdef MAC_OSX
+          CFStringRef str;
+          CFURLRef url = NULL;
+          CFDataRef data = NULL;
+
+          str = CFStringCreateWithBytes (NULL, data_ptr, data_size,
+                                         kCFStringEncodingUTF8, false);
+          if (str)
+            {
+              url = CFURLCreateWithFileSystemPath (NULL, str,
+                                                   kCFURLPOSIXPathStyle, false);
+              CFRelease (str);
+            }
+          if (url)
+            {
+              data = CFURLCreateData (NULL, url, kCFStringEncodingUTF8, true);
+              CFRelease (url);
+            }
+          if (data)
+            {
+              err = AECoercePtr (typeFileURL, CFDataGetBytePtr (data),
+                                 CFDataGetLength (data), to_type, result);
+              CFRelease (data);
+            }
+        else
+          err = memFullErr;
+#else
+          FSSpec fs;
+          char *buf;
+
+          buf = xmalloc (data_size + 1);
+          if (buf)
+            {
+              memcpy (buf, data_ptr, data_size);
+              buf[data_size] = '\0';
+              err = posix_pathname_to_fsspec (buf, &fs);
+              xfree (buf);
+            }
+          else
+            err = memFullErr;
+          if (err == noErr)
+            err = AECoercePtr (typeFSS, &fs, sizeof (FSSpec),
+                               to_type, result);
+#endif
+        }
+        break;
+
+      case TYPE_FILE_NAME:
+      case typeWildCard:
+        err = AECreateDesc (TYPE_FILE_NAME, data_ptr, data_size, result);
+        break;
+
+      default:
+        err = errAECoercionFail;
+        break;
+      }
+  else if (to_type == TYPE_FILE_NAME)
+    /* Coercion to undecoded file name.  */
+    switch (type_code)
+      {
+      case typeAlias:
+      case typeFSS:
+      case typeFSRef:
+#ifdef MAC_OSX
+      case typeFileURL:
+#endif
+        {
+          AEDesc desc;
+#ifdef MAC_OSX
+          Size size;
+          char *buf;
+          CFURLRef url = NULL;
+          CFStringRef str = NULL;
+          CFDataRef data = NULL;
+
+          err = AECoercePtr (type_code, data_ptr, data_size,
+                             typeFileURL, &desc);
+          if (err == noErr)
+            {
+              size = AEGetDescDataSize (&desc);
+              buf = xmalloc (size);
+              if (buf)
+                {
+                  err = AEGetDescData (&desc, buf, size);
+                  if (err == noErr)
+                    url = CFURLCreateWithBytes (NULL, buf, size,
+                                                kCFStringEncodingUTF8, NULL);
+                  xfree (buf);
+                }
+              AEDisposeDesc (&desc);
+            }
+          if (url)
+            {
+              str = CFURLCopyFileSystemPath (url, kCFURLPOSIXPathStyle);
+              CFRelease (url);
+            }
+          if (str)
+            {
+              data =
+                CFStringCreateExternalRepresentation (NULL, str,
+                                                      kCFStringEncodingUTF8,
+                                                      '\0');
+              CFRelease (str);
+            }
+          if (data)
+            {
+              err = AECreateDesc (TYPE_FILE_NAME, CFDataGetBytePtr (data),
+                                  CFDataGetLength (data), result);
+              CFRelease (data);
+            }
+          else
+            err = memFullErr;
+#else
+          FSSpec fs;
+          char file_name[MAXPATHLEN];
+
+          err = AECoercePtr (type_code, data_ptr, data_size,
+                             typeFSS, &desc);
+          if (err == noErr)
+            {
+#if TARGET_API_MAC_CARBON
+              err = AEGetDescData (&desc, &fs, sizeof (FSSpec));
+#else
+              fs = *(FSSpec *)(*(desc.dataHandle));
+#endif
+              if (err == noErr)
+                err = fsspec_to_posix_pathname (&fs, file_name,
+                                                sizeof (file_name) - 1);
+              if (err == noErr)
+                err = AECreateDesc (TYPE_FILE_NAME, file_name,
+                                    strlen (file_name), result);
+              AEDisposeDesc (&desc);
+            }
+#endif
+        }
+        break;
+
+      default:
+        err = errAECoercionFail;
+        break;
+      }
+  else
+    abort ();
+
+  if (err != noErr)
+    return errAECoercionFail;
+  return noErr;
+}
+
+static pascal OSErr
+mac_coerce_file_name_desc (from_desc, to_type, handler_refcon, result)
+     const AEDesc *from_desc;
+     DescType to_type;
+     long handler_refcon;
+     AEDesc *result;
+{
+  OSErr err = noErr;
+  DescType from_type = from_desc->descriptorType;
+
+  if (from_type == TYPE_FILE_NAME)
+    {
+      if (to_type != TYPE_FILE_NAME && to_type != typeWildCard
+          && to_type != typeAlias && to_type != typeFSS
+          && to_type != typeFSRef
+#ifdef MAC_OSX
+          && to_type != typeFileURL
+#endif
+          )
+        return errAECoercionFail;
+    }
+  else if (to_type == TYPE_FILE_NAME)
+    {
+      if (from_type != typeAlias && from_type != typeFSS
+          && from_type != typeFSRef
+#ifdef MAC_OSX
+          && from_type != typeFileURL
+#endif
+          )
+        return errAECoercionFail;
+    }
+  else
+    abort ();
+
+  if (from_type == to_type || to_type == typeWildCard)
+    err = AEDuplicateDesc (from_desc, result);
+  else
+    {
+      char *data_ptr;
+      Size data_size;
+
+#if TARGET_API_MAC_CARBON
+      data_size = AEGetDescDataSize (from_desc);
+#else
+      data_size = GetHandleSize (from_desc->dataHandle);
+#endif
+      data_ptr = xmalloc (data_size);
+      if (data_ptr)
+        {
+#if TARGET_API_MAC_CARBON
+          err = AEGetDescData (from_desc, data_ptr, data_size);
+#else
+          memcpy (data_ptr, *(from_desc->dataHandle), data_size);
+#endif
+          if (err == noErr)
+            err = mac_coerce_file_name_ptr (from_type, data_ptr,
+                                            data_size, to_type,
+                                            handler_refcon, result);
+          xfree (data_ptr);
+        }
+      else
+        err = memFullErr;
+    }
+
+  if (err != noErr)
+    return errAECoercionFail;
+  return noErr;
+}
+
+OSErr
+init_coercion_handler ()
+{
+  OSErr err;
+
+  static AECoercePtrUPP coerce_file_name_ptrUPP = NULL;
+  static AECoerceDescUPP coerce_file_name_descUPP = NULL;
+
+  if (coerce_file_name_ptrUPP == NULL)
+    {
+      coerce_file_name_ptrUPP = NewAECoercePtrUPP (mac_coerce_file_name_ptr);
+      coerce_file_name_descUPP = NewAECoerceDescUPP (mac_coerce_file_name_desc);
+    }
+
+  err = AEInstallCoercionHandler (TYPE_FILE_NAME, typeWildCard,
+                                  (AECoercionHandlerUPP)
+                                  coerce_file_name_ptrUPP, 0, false, false);
+  if (err == noErr)
+    err = AEInstallCoercionHandler (typeWildCard, TYPE_FILE_NAME,
+                                    (AECoercionHandlerUPP)
+                                    coerce_file_name_ptrUPP, 0, false, false);
+  if (err == noErr)
+    err = AEInstallCoercionHandler (TYPE_FILE_NAME, typeWildCard,
+                                    coerce_file_name_descUPP, 0, true, false);
+  if (err == noErr)
+    err = AEInstallCoercionHandler (typeWildCard, TYPE_FILE_NAME,
+                                    coerce_file_name_descUPP, 0, true, false);
+  return err;
+}
+
 #if TARGET_API_MAC_CARBON
 OSErr
 create_apple_event_from_event_ref (event, num_params, names, types, result)
@@ -2602,7 +2875,7 @@ path_from_vol_dir_name (char *path, int man_path_len, short vol_ref_num,
 }
 
 
-OSErr
+static OSErr
 posix_pathname_to_fsspec (ufn, fs)
      const char *ufn;
      FSSpec *fs;
@@ -2618,7 +2891,7 @@ posix_pathname_to_fsspec (ufn, fs)
     }
 }
 
-OSErr
+static OSErr
 fsspec_to_posix_pathname (fs, ufn, ufnbuflen)
      const FSSpec *fs;
      char *ufn;
@@ -4072,92 +4345,21 @@ Each type should be a string of length 4 or the symbol
 
   CHECK_STRING (src_data);
   if (EQ (src_type, Qundecoded_file_name))
-    {
-#ifdef MAC_OSX
-      src_desc_type = typeFileURL;
-#else
-      src_desc_type = typeFSS;
-#endif
-    }
+    src_desc_type = TYPE_FILE_NAME;
   else
     src_desc_type = mac_get_code_from_arg (src_type, 0);
 
   if (EQ (dst_type, Qundecoded_file_name))
-    {
-#ifdef MAC_OSX
-    dst_desc_type = typeFSRef;
-#else
-    dst_desc_type = typeFSS;
-#endif
-    }
+    dst_desc_type = TYPE_FILE_NAME;
   else
     dst_desc_type = mac_get_code_from_arg (dst_type, 0);
 
   BLOCK_INPUT;
-  if (EQ (src_type, Qundecoded_file_name))
-    {
-#ifdef MAC_OSX
-      CFStringRef str;
-      CFURLRef url = NULL;
-      CFDataRef data = NULL;
-
-      str = cfstring_create_with_utf8_cstring (SDATA (src_data));
-      if (str)
-        {
-          url = CFURLCreateWithFileSystemPath (NULL, str,
-                                               kCFURLPOSIXPathStyle, false);
-          CFRelease (str);
-        }
-      if (url)
-        {
-          data = CFURLCreateData (NULL, url, kCFStringEncodingUTF8, true);
-          CFRelease (url);
-        }
-      if (data)
-        {
-          err = AECoercePtr (src_desc_type, CFDataGetBytePtr (data),
-                             CFDataGetLength (data),
-                             dst_desc_type, &dst_desc);
-          CFRelease (data);
-        }
-      else
-        err = memFullErr;
-#else
-      err = posix_pathname_to_fsspec (SDATA (src_data), &fs);
-      if (err == noErr)
-        AECoercePtr (src_desc_type, &fs, sizeof (FSSpec),
+  err = AECoercePtr (src_desc_type, SDATA (src_data), SBYTES (src_data),
                      dst_desc_type, &dst_desc);
-#endif
-    }
-  else
-    err = AECoercePtr (src_desc_type, SDATA (src_data), SBYTES (src_data),
-                       dst_desc_type, &dst_desc);
-
   if (err == noErr)
     {
-      if (EQ (dst_type, Qundecoded_file_name))
-        {
-          char file_name[MAXPATHLEN];
-
-#ifdef MAC_OSX
-          err = AEGetDescData (&dst_desc, &fref, sizeof (FSRef));
-          if (err == noErr)
-            err = FSRefMakePath (&fref, file_name, sizeof (file_name));
-#else
-#if TARGET_API_MAC_CARBON
-          err = AEGetDescData (&dst_desc, &fs, sizeof (FSSpec));
-#else
-          memcpy (&fs, *(dst_desc.dataHandle), sizeof (FSSpec));
-#endif
-          if (err == noErr)
-            err = fsspec_to_posix_pathname (&fs, file_name,
-                                            sizeof (file_name) - 1);
-#endif
-          if (err == noErr)
-            result = make_unibyte_string (file_name, strlen (file_name));
-        }
-      else
-        result = Fcdr (mac_aedesc_to_lisp (&dst_desc));
+      result = Fcdr (mac_aedesc_to_lisp (&dst_desc));
       AEDisposeDesc (&dst_desc);
     }
   UNBLOCK_INPUT;