1 /*

     2  * Copyright (c) 2014, 2018, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 #ifndef PLATFORMSTRING_H

    27 #define PLATFORMSTRING_H

    28 

    29 

    30 #include <string>

    31 #include <list>

    32 #include <stdio.h>

    33 #include <stdlib.h>

    34 

    35 #include "jni.h"

    36 #include "Platform.h"

    37 

    38 

    39 struct WideString {

    40     size_t length;

    41     wchar_t* data;

    42 

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

    44 };

    45 

    46 struct MultibyteString {

    47     size_t length;

    48     char* data;

    49 

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

    51 };

    52 

    53 

    54 template <typename T>

    55 class DynamicBuffer {

    56 private:

    57     T* FData;

    58     size_t FSize;

    59 

    60 public:

    61     DynamicBuffer(size_t Size) {

    62         FSize = 0;

    63         FData = NULL;

    64         Resize(Size);

    65     }

    66 

    67     ~DynamicBuffer() {

    68         delete[] FData;

    69     }

    70 

    71     T* GetData() { return FData; }

    72     size_t GetSize() { return FSize; }

    73 

    74     bool Resize(size_t Size) {

    75         FSize = Size;

    76 

    77         if (FData != NULL) {

    78             delete[] FData;

    79             FData = NULL;

    80         }

    81 

    82         if (FSize != 0) {

    83             FData = new T[FSize];

    84             if (FData != NULL) {

    85                 Zero();

    86             } else {

    87                 return false;

    88             }

    89         }

    90 

    91         return true;

    92     }

    93 

    94     void Zero() {

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

    96     }

    97 

    98     T& operator[](size_t index) {

    99         return FData[index];

   100     }

   101 };

   102 

   103 

   104 #ifdef MAC

   105 // StringToFileSystemString is a stack object. It's usage is

   106 // simply inline to convert a

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

   108 //

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

   110 //

   111 class StringToFileSystemString {

   112     // Prohibit Heap-Based StringToFileSystemString

   113 private:

   114     static void *operator new(size_t size);

   115     static void operator delete(void *ptr);

   116 

   117 private:

   118     TCHAR* FData;

   119     bool FRelease;

   120 

   121 public:

   122     StringToFileSystemString(const TString &value);

   123     ~StringToFileSystemString();

   124 

   125     operator TCHAR* ();

   126 };

   127 

   128 

   129 // FileSystemStringToString is a stack object. It's usage is

   130 // 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,

   169             size_t NumberOfElements, const char *Source);

   170 

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

   172     static void CopyString(wchar_t *Destination,

   173             size_t NumberOfElements, const wchar_t *Source);

   174 

   175     static WideString MultibyteStringToWideString(const char* value);

   176     static MultibyteString WideStringToMultibyteString(const wchar_t* value);

   177 

   178 // Prohibit Heap-Based PlatformStrings

   179 private:

   180     static void *operator new(size_t size);

   181     static void operator delete(void *ptr);

   182 

   183 public:

   184     PlatformString(void);

   185     PlatformString(const PlatformString &value);

   186     PlatformString(const char* value);

   187     PlatformString(const wchar_t* value);

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

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

   190     PlatformString(JNIEnv *env, jstring value);

   191     PlatformString(size_t Value);

   192 

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

   194 

   195     ~PlatformString(void);

   196 

   197     size_t length();

   198 

   199     char* c_str();

   200     char* toMultibyte();

   201     wchar_t* toWideString();

   202     std::wstring toUnicodeString();

   203     std::string toStdString();

   204     jstring toJString(JNIEnv *env);

   205     TCHAR* toPlatformString();

   206     TString toString();

   207 

   208     operator char* ();

   209     operator wchar_t* ();

   210     operator std::wstring ();

   211 

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

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

   214 

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

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

   217 };

   218 

   219 

   220 #endif // PLATFORMSTRING_H