tools/debugserver/source/MacOSX/CFString.cpp

   1 //===-- CFString.cpp --------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  Created by Greg Clayton on 1/16/08.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "CFString.h"
  15 #include <glob.h>
  16 #include <string>
  17
  18 //----------------------------------------------------------------------
  19 // CFString constructor
  20 //----------------------------------------------------------------------
  21 CFString::CFString(CFStringRef s) : CFReleaser<CFStringRef>(s) {}
  22
  23 //----------------------------------------------------------------------
  24 // CFString copy constructor
  25 //----------------------------------------------------------------------
  26 CFString::CFString(const CFString &rhs) : CFReleaser<CFStringRef>(rhs) {}
  27
  28 //----------------------------------------------------------------------
  29 // CFString copy constructor
  30 //----------------------------------------------------------------------
  31 CFString &CFString::operator=(const CFString &rhs) {
  32   if (this != &rhs)
  33     *this = rhs;
  34   return *this;
  35 }
  36
  37 CFString::CFString(const char *cstr, CFStringEncoding cstr_encoding)
  38     : CFReleaser<CFStringRef>() {
  39   if (cstr && cstr[0]) {
  40     reset(
  41         ::CFStringCreateWithCString(kCFAllocatorDefault, cstr, cstr_encoding));
  42   }
  43 }
  44
  45 //----------------------------------------------------------------------
  46 // Destructor
  47 //----------------------------------------------------------------------
  48 CFString::~CFString() {}
  49
  50 const char *CFString::GetFileSystemRepresentation(std::string &s) {
  51   return CFString::FileSystemRepresentation(get(), s);
  52 }
  53
  54 CFStringRef CFString::SetFileSystemRepresentation(const char *path) {
  55   CFStringRef new_value = NULL;
  56   if (path && path[0])
  57     new_value =
  58         ::CFStringCreateWithFileSystemRepresentation(kCFAllocatorDefault, path);
  59   reset(new_value);
  60   return get();
  61 }
  62
  63 CFStringRef CFString::SetFileSystemRepresentationFromCFType(CFTypeRef cf_type) {
  64   CFStringRef new_value = NULL;
  65   if (cf_type != NULL) {
  66     CFTypeID cf_type_id = ::CFGetTypeID(cf_type);
  67
  68     if (cf_type_id == ::CFStringGetTypeID()) {
  69       // Retain since we are using the existing object
  70       new_value = (CFStringRef)::CFRetain(cf_type);
  71     } else if (cf_type_id == ::CFURLGetTypeID()) {
  72       new_value =
  73           ::CFURLCopyFileSystemPath((CFURLRef)cf_type, kCFURLPOSIXPathStyle);
  74     }
  75   }
  76   reset(new_value);
  77   return get();
  78 }
  79
  80 CFStringRef
  81 CFString::SetFileSystemRepresentationAndExpandTilde(const char *path) {
  82   std::string expanded_path;
  83   if (CFString::GlobPath(path, expanded_path))
  84     SetFileSystemRepresentation(expanded_path.c_str());
  85   else
  86     reset();
  87   return get();
  88 }
  89
  90 const char *CFString::UTF8(std::string &str) {
  91   return CFString::UTF8(get(), str);
  92 }
  93
  94 // Static function that puts a copy of the UTF8 contents of CF_STR into STR
  95 // and returns the C string pointer that is contained in STR when successful,
  96 // else
  97 // NULL is returned. This allows the std::string parameter to own the extracted
  98 // string,
  99 // and also allows that string to be returned as a C string pointer that can be
 100 // used.
 101
 102 const char *CFString::UTF8(CFStringRef cf_str, std::string &str) {
 103   if (cf_str) {
 104     const CFStringEncoding encoding = kCFStringEncodingUTF8;
 105     CFIndex max_utf8_str_len = CFStringGetLength(cf_str);
 106     max_utf8_str_len =
 107         CFStringGetMaximumSizeForEncoding(max_utf8_str_len, encoding);
 108     if (max_utf8_str_len > 0) {
 109       str.resize(max_utf8_str_len);
 110       if (!str.empty()) {
 111         if (CFStringGetCString(cf_str, &str[0], str.size(), encoding)) {
 112           str.resize(strlen(str.c_str()));
 113           return str.c_str();
 114         }
 115       }
 116     }
 117   }
 118   return NULL;
 119 }
 120
 121 // Static function that puts a copy of the file system representation of CF_STR
 122 // into STR and returns the C string pointer that is contained in STR when
 123 // successful, else NULL is returned. This allows the std::string parameter
 124 // to own the extracted string, and also allows that string to be returned as
 125 // a C string pointer that can be used.
 126
 127 const char *CFString::FileSystemRepresentation(CFStringRef cf_str,
 128                                                std::string &str) {
 129   if (cf_str) {
 130     CFIndex max_length =
 131         ::CFStringGetMaximumSizeOfFileSystemRepresentation(cf_str);
 132     if (max_length > 0) {
 133       str.resize(max_length);
 134       if (!str.empty()) {
 135         if (::CFStringGetFileSystemRepresentation(cf_str, &str[0],
 136                                                   str.size())) {
 137           str.erase(::strlen(str.c_str()));
 138           return str.c_str();
 139         }
 140       }
 141     }
 142   }
 143   str.erase();
 144   return NULL;
 145 }
 146
 147 CFIndex CFString::GetLength() const {
 148   CFStringRef str = get();
 149   if (str)
 150     return CFStringGetLength(str);
 151   return 0;
 152 }
 153
 154 const char *CFString::GlobPath(const char *path, std::string &expanded_path) {
 155   glob_t globbuf;
 156   if (::glob(path, GLOB_TILDE, NULL, &globbuf) == 0) {
 157     expanded_path = globbuf.gl_pathv[0];
 158     ::globfree(&globbuf);
 159   } else
 160     expanded_path.clear();
 161
 162   return expanded_path.c_str();
 163 }