37 

    38 #ifdef __linux__

    39 #include <dlfcn.h>

    40 

    41 

    42 void* GetProcAddress(HINSTANCE aHandle, const char* aSymbol)

    43 	{

    44 	return dlsym(aHandle, aSymbol);

    45 	}

    46 

    47 HINSTANCE LoadLibraryA(const char* aLibraryName)

    48 	{

    49 	HINSTANCE handleUsingDefaultSearchPath = dlopen(aLibraryName, RTLD_LAZY);

    50 

    51 	if( handleUsingDefaultSearchPath == NULL )

    52 	{

    53 		// Once the dlopen() fails by not finding the aLibraryName in the default

    54 		// path specified by LD_LIBRARY_PATH, we will look in the epoc32/tools 

    55 		// path as the second option.

    56 

    57 		const char* epocRoot = getenv("EPOCROOT");		

    58 		if(NULL == epocRoot)

    59 			{

    60 			throw CException("EPOCROOT environment variable not specified.", ExceptionCodes::EEnvNotSpecified);

    61 			}

    62 		std::string epocRootStr(epocRoot); 

    63 

    64 		std::string absPathToLibrary = epocRootStr + std::string("epoc32/tools/") + std::string(aLibraryName);

    65 		HINSTANCE handleUsingAbsSearchPath = dlopen(absPathToLibrary.c_str(), RTLD_LAZY);

    66 

    67 		return handleUsingAbsSearchPath;

    68 	}

    69 

    70 	return handleUsingDefaultSearchPath;

    71 	}

    72 

    73 int FreeLibrary(HINSTANCE aHandle)

    74 	{

    75 	// FreeLibrary returns non-zero value on success whereas

    76 	// dlcose returns zero on success.

    77 	return (dlclose(aHandle) == 0)? true: false;

    78 	}

    79 

    80 std::string GetErrorMessage()

    81 	{

    82 	return dlerror();

    83 	}

    84 

    85 static utf16WString utf32WString2utf16WString(std::wstring& aParameter)

    86 {

    87 	int strLen = aParameter.length();

    88 	const wchar_t * source = aParameter.c_str();

    89 	unsigned short int* buffer = new unsigned short int[(strLen + 1) * 2];

    90 

    91 	// Using a temp variable in place of buffer as ConvertUTF32toUTF16 modifies the source pointer passed.

    92 	unsigned short int* temp = buffer;

    93 

    94 	ConvertUTF32toUTF16(&source, source + strLen, &temp,  temp + strLen, lenientConversion);

    95 

    96 	// Appending NUL to the converted buffer.

    97 	*temp = 0;

    98 

    99 	utf16WString utf16Ws;

   100 	utf16Ws.resize(strLen);

   101 

   102 	// The built-in basic_string template class copy operation

   103 	// truncates when a NUL is encountered when a c_str() is

   104 	// used to construct the required string.

   105 	// So, if aParameter is any hashable string having the

   106 	// syntax : swtypeName + L'\0' + someId then, we will end

   107 	// up returning only part of the converted UTF-16 string.

   108 	// Hence, we resort to the explicit copy operation with

   109 	// two bytes at a time.

   110 	while( strLen-- )

   111 	{

   112 		utf16Ws[ strLen ] = buffer[ strLen ];

   113 	}

   114 

   115 	delete[] buffer;

   116 

   117 	return utf16Ws;

   118 }

   119 

   120 static std::wstring utf16WString2utf32WString(utf16WString& aParameter)

   121 {	

   122 	int strLen = aParameter.length();

   123 	const unsigned short int* source = aParameter.c_str();

   124 	wchar_t* buffer = new wchar_t[ strLen + 1 ];

   125 

   126 	// Using a temp variable in place of buffer as ConvertUTF16toUCS4 modifies the source pointer passed.

   127 	wchar_t* temp = buffer;

   128 

   129 	ConvertUTF16toUCS4(&source, source + strLen, &temp, temp + strLen);

   130 

   131 	// Appending NUL to the converted buffer.

   132 	*temp = 0;

   133 

   134 	std::wstring utf32Ws(buffer);

   135 

   136 	delete[] buffer;

   137 

   138 	return utf32Ws;

   139 }

   140 

   141 #else

   142 std::string GetErrorMessage()

   143 	{

   144 	LPCVOID lpMsgBuf;

   145 		

   146 	DWORD err = GetLastError();

   147 	FormatMessage	(	FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |

   148 						FORMAT_MESSAGE_IGNORE_INSERTS, NULL, err,

   149 						MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf,

   150 						0, NULL 

   151 					);

   152 	std::wstring wErrMsg((wchar_t*)lpMsgBuf);

   153 	return wstring2string(wErrMsg);

   154 	}

   155 #endif // __linux__

   465 

   466 #ifdef __TOOLS2_LINUX__

   467 void CStatement::BindStr(TInt aParameterIndex, const std::wstring &aParameterStr, int aConvertSlash=allowSlashConversion)

   468 #else

   504 	#endif

   512 	// The fifth argument has the value SQLITE_TRANSIENT, it means that SQLite makes its own private copy of the data immediately

   513 	CheckSqlErrCode(err);

   514 	}

   515 

   516 void CStatement::BindBinary(TInt aParameterIndex, const std::wstring &aParameterStr)

   517 	{

   518 	#ifdef __LINUX__

   519 	// To maintain consistency of the binary equivalent of the wstring

   520 	// being binded, we convert the wstring with UTF-32 encoding under LINUX

   521 	// to UTF-16 encoding which is same as that of wstring under WINDOWS.

   522 	

   523 	std::wstring temp = aParameterStr;

   524 	utf16WString utf16s = utf32WString2utf16WString(temp);

   525 

   526 	TInt err = iLibraryHandler.sqlite3_bind_blob(iStmtHandle, aParameterIndex, utf16s.c_str(), aParameterStr.size()*2, SQLITE_TRANSIENT);

   527 	#else

   528 	TInt err = iLibraryHandler.sqlite3_bind_blob(iStmtHandle, aParameterIndex, aParameterStr.c_str(), aParameterStr.size()*2, SQLITE_TRANSIENT);

   529 	#endif

   530