1 /*

     2  * Copyright (c) 2014, 2015, Oracle and/or its affiliates.

     3  * All rights reserved. Use is subject to license terms.

     4  *

     5  * This file is available and licensed under the following license:

     6  *

     7  * Redistribution and use in source and binary forms, with or without

     8  * modification, are permitted provided that the following conditions

     9  * are met:

    10  *

    11  *  - Redistributions of source code must retain the above copyright

    12  *    notice, this list of conditions and the following disclaimer.

    13  *  - Redistributions in binary form must reproduce the above copyright

    14  *    notice, this list of conditions and the following disclaimer in

    15  *    the documentation and/or other materials provided with the distribution.

    16  *  - Neither the name of Oracle Corporation nor the names of its

    17  *    contributors may be used to endorse or promote products derived

    18  *    from this software without specific prior written permission.

    19  *

    20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

    21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

    22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

    23  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

    24  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

    25  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

    26  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

    27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

    28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    30  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    31  */

    32 

    33 

    34 #ifndef PLATFORMSTRING_H

    35 #define PLATFORMSTRING_H

    36 

    37 

    38 #include <string>

    39 #include <list>

    40 #include <stdio.h>

    41 #include <stdlib.h>

    42 

    43 #include "jni.h"

    44 #include "Platform.h"

    45 

    46 

    47 struct WideString {

    48     size_t length;

    49     wchar_t* data;

    50 

    51     WideString() { length = 0; data = NULL; }

    52 };

    53 

    54 struct MultibyteString {

    55     size_t length;

    56     char* data;

    57 

    58     MultibyteString() { length = 0; data = NULL; }

    59 };

    60 

    61 

    62 template <typename T>

    63 class DynamicBuffer {

    64 private:

    65     T* FData;

    66     size_t FSize;

    67 

    68 public:

    69     DynamicBuffer(size_t Size) {

    70         FSize = 0;

    71         FData = NULL;

    72         Resize(Size);

    73     }

    74 

    75     ~DynamicBuffer() {

    76         delete[] FData;

    77     }

    78 

    79     T* GetData() { return FData; }

    80     size_t GetSize() { return FSize; }

    81 

    82     void Resize(size_t Size) {

    83         FSize = Size;

    84 

    85         if (FData != NULL) {

    86             delete[] FData;

    87             FData = NULL;

    88         }

    89 

    90         if (FSize != 0) {

    91             FData = new T[FSize];

    92             Zero();

    93         }

    94     }

    95 

    96     void Zero() {

    97         memset(FData, 0, FSize * sizeof(T));

    98     }

    99 

   100     T& operator[](size_t index) {

   101         return FData[index];

   102     }

   103 };

   104 

   105 

   106 #ifdef MAC

   107 // StringToFileSystemString is a stack object. It's usage is simply inline to convert a

   108 // TString to a file system string. Example:

   109 //

   110 // return dlopen(StringToFileSystemString(FileName), RTLD_LAZY);

   111 //

   112 class StringToFileSystemString {

   113     // Prohibit Heap-Based StringToFileSystemString

   114 private:

   115     static void *operator new(size_t size);

   116     static void operator delete(void *ptr);

   117 

   118 private:

   119     TCHAR* FData;

   120     bool FRelease;

   121 

   122 public:

   123     StringToFileSystemString(const TString &value);

   124     ~StringToFileSystemString();

   125 

   126     operator TCHAR* ();

   127 };

   128 

   129 

   130 // FileSystemStringToString is a stack object. It's usage is simply inline to convert a

   131 // file system string to a TString. Example:

   132 //

   133 // DynamicBuffer<TCHAR> buffer(MAX_PATH);

   134 // if (readlink("/proc/self/exe", buffer.GetData(), MAX_PATH) != -1)

   135 //    result = FileSystemStringToString(buffer.GetData());

   136 //

   137 class FileSystemStringToString {

   138     // Prohibit Heap-Based FileSystemStringToString

   139 private:

   140     static void *operator new(size_t size);

   141     static void operator delete(void *ptr);

   142 

   143 private:

   144     TString FData;

   145 

   146 public:

   147     FileSystemStringToString(const TCHAR* value);

   148 

   149     operator TString ();

   150 };

   151 #endif //MAC

   152 

   153 #ifdef LINUX

   154 #define StringToFileSystemString PlatformString

   155 #define FileSystemStringToString PlatformString

   156 #endif //LINUX

   157 

   158 

   159 class PlatformString {

   160 private:

   161     char* FData; // Stored as UTF-8

   162     size_t FLength;

   163     wchar_t* FWideTStringToFree;

   164 

   165     void initialize();

   166 

   167     // Caller must free result using delete[].

   168     static void CopyString(char *Destination, size_t NumberOfElements, const char *Source);

   169 

   170     // Caller must free result using delete[].

   171     static void CopyString(wchar_t *Destination, size_t NumberOfElements, const wchar_t *Source);

   172 

   173     static WideString MultibyteStringToWideString(const char* value);

   174     static MultibyteString WideStringToMultibyteString(const wchar_t* value);

   175 

   176 // Prohibit Heap-Based PlatformStrings

   177 private:

   178     static void *operator new(size_t size);

   179     static void operator delete(void *ptr);

   180 

   181 public:

   182     PlatformString(void);

   183     PlatformString(const PlatformString &value);

   184     PlatformString(const char* value);

   185     PlatformString(const wchar_t* value);

   186     PlatformString(const std::string &value);

   187     PlatformString(const std::wstring &value);

   188     PlatformString(JNIEnv *env, jstring value);

   189     PlatformString(size_t Value);

   190 

   191     static TString Format(const TString value, ...);

   192 

   193     ~PlatformString(void);

   194 

   195     size_t length();

   196 

   197     char* c_str();

   198     char* toMultibyte();

   199     wchar_t* toWideString();

   200     std::wstring toUnicodeString();

   201     std::string toStdString();

   202     jstring toJString(JNIEnv *env);

   203     TCHAR* toPlatformString();

   204     TString toString();

   205 

   206     operator char* ();

   207     operator wchar_t* ();

   208     operator std::wstring ();

   209 

   210     // Caller must free result using delete[].

   211     static char* duplicate(const char* Value);

   212 

   213     // Caller must free result using delete[].

   214     static wchar_t* duplicate(const wchar_t* Value);

   215 };

   216 

   217 

   218 #endif //PLATFORMSTRING_H