SString SharedUtil::GetSystemSystemPath ( void )
{
wchar_t szResult[MAX_PATH] = L"";
SHGetFolderPathW( NULL, CSIDL_SYSTEM, NULL, 0, szResult );
if ( IsShortPathName( szResult ) )
return GetSystemLongPathName( ToUTF8( szResult ) );
return ToUTF8( szResult );
}
SString SharedUtil::GetSystemCommonAppDataPath ( void )
{
wchar_t szResult[MAX_PATH] = L"";
SHGetFolderPathW( NULL, CSIDL_COMMON_APPDATA, NULL, 0, szResult );
if ( IsShortPathName( szResult ) )
return GetSystemLongPathName( ToUTF8( szResult ) );
return ToUTF8( szResult );
}
SString SharedUtil::GetSystemDllDirectory ( void )
{
wchar_t szResult [ 1024 ] = L"";
GetDllDirectoryW ( NUMELMS ( szResult ), szResult );
if ( IsShortPathName( szResult ) )
return GetSystemLongPathName( ToUTF8( szResult ) );
return ToUTF8( szResult );
}
SString SharedUtil::GetSystemTempPath ( void )
{
wchar_t szResult[4030] = L"";
GetTempPathW( 4000, szResult );
if ( IsShortPathName( szResult ) )
return GetSystemLongPathName( ToUTF8( szResult ) );
return ToUTF8( szResult );
}
void
CExampleDlg::OnBnClickedConnectButton()
{
WCHAR awcTempBuf[100];
const int kTempBufSize = sizeof(awcTempBuf) / sizeof(awcTempBuf[0]);
// Pull user input into our member variables
UpdateData(TRUE);
// Clear out the results list, in case this isn't the first time
// we've come in here.
ResultsList.ResetContent();
// Translate the Unicode text we get from the UI into the UTF-8 form
// that MySQL wants.
const int kInputBufSize = 100;
char acServerAddress[kInputBufSize];
char acUserName[kInputBufSize];
char acPassword[kInputBufSize];
ToUTF8(acServerAddress, kInputBufSize, sServerAddress);
ToUTF8(acUserName, kInputBufSize, sUserName);
ToUTF8(acPassword, kInputBufSize, sPassword);
// Connect to the sample database.
mysqlpp::Connection con(false);
if (!con.connect("mysql_cpp_data", acServerAddress, acUserName,
acPassword)) {
AddMessage(_T("Failed to connect to server:"));
if (ToUCS2(awcTempBuf, kTempBufSize, con.error())) {
AddMessage(awcTempBuf);
}
return;
}
// Retrieve a subset of the sample stock table set up by resetdb
mysqlpp::Query query = con.query();
query << "select item from stock";
mysqlpp::StoreQueryResult res = query.store();
if (res) {
// Display the result set
for (size_t i = 0; i < res.num_rows(); ++i) {
if (ToUCS2(awcTempBuf, kTempBufSize, res[i][0])) {
AddMessage(awcTempBuf);
}
}
// Retreive was successful, so save user inputs now
SaveInputs();
}
else {
// Retreive failed
AddMessage(_T("Failed to get item list:"));
if (ToUCS2(awcTempBuf, kTempBufSize, query.error())) {
AddMessage(awcTempBuf);
}
}
}
EPUB3_BEGIN_NAMESPACE
static string GetTempFilePath(const string& ext)
{
#if EPUB_PLATFORM(WIN)
TCHAR tmpPath[MAX_PATH];
TCHAR tmpFile[MAX_PATH];
DWORD pathLen = ::GetTempPath(MAX_PATH, tmpPath);
if ( pathLen == 0 || pathLen > MAX_PATH )
throw std::system_error(static_cast<int>(::GetLastError()), std::system_category());
UINT fileLen = ::GetTempFileName(tmpPath, TEXT("ZIP"), 0, tmpFile);
if ( fileLen == 0 )
throw std::system_error(static_cast<int>(::GetLastError()), std::system_category());
string r(tmpFile);
return r;
#elif EPUB_PLATFORM(WINRT)
using ToUTF8 = std::wstring_convert<std::codecvt_utf8<wchar_t>>;
auto tempFolder = ::Windows::Storage::ApplicationData::Current->TemporaryFolder;
std::wstring tempFolderPath(tempFolder->Path->Data(), tempFolder->Path->Length());
std::wstringstream ss;
ss << tempFolderPath;
ss << TEXT("\\epub3.");
ss << Windows::Security::Cryptography::CryptographicBuffer::GenerateRandomNumber();
ss << TEXT(".");
ss << ToUTF8().from_bytes(ext.stl_str());
return ToUTF8().to_bytes(ss.str());
#else
std::stringstream ss;
#if EPUB_OS(ANDROID)
ss << gAndroidCacheDir << "epub3.XXXXXX";
#else
ss << "/tmp/epub3.XXXXXX." << ext;
#endif
string path(ss.str());
char *buf = new char[path.length()];
std::char_traits<char>::copy(buf, ss.str().c_str(), sizeof(buf));
#if EPUB_OS(ANDROID)
int fd = ::mkstemp(buf);
#else
int fd = ::mkstemps(buf, static_cast<int>(ext.size()+1));
#endif
if ( fd == -1 )
throw std::runtime_error(std::string("mkstemp() failed: ") + strerror(errno));
::close(fd);
return string(buf);
#endif
}
RESULT cConnection::PostRequest(const std::string& sRelativeURI, const string_t& sUserName, const string_t& sPassword, const std::map<std::string, std::string>& _mValues)
{
std::map<std::string, std::string> mValues(_mValues);
mValues["version"] = "1";
mValues["user"] = ToUTF8(sUserName);
mValues["pass"] = ToUTF8(sPassword);
return _PostRequest(sRelativeURI, mValues);
}
// C:\Program Files\gta_sa.exe
SString SharedUtil::GetLaunchPathFilename( void )
{
static SString strLaunchPathFilename;
if ( strLaunchPathFilename.empty() )
{
wchar_t szBuffer[2048];
GetModuleFileNameW( NULL, szBuffer, NUMELMS(szBuffer) - 1 );
if ( IsShortPathName( szBuffer ) )
return GetSystemLongPathName( ToUTF8( szBuffer ) );
strLaunchPathFilename = ToUTF8( szBuffer );
}
return strLaunchPathFilename;
}
SString SharedUtil::GetSystemCurrentDirectory ( void )
{
#ifdef WIN32
wchar_t szResult [ 1024 ] = L"";
GetCurrentDirectoryW ( NUMELMS ( szResult ), szResult );
if ( IsShortPathName( szResult ) )
return GetSystemLongPathName( ToUTF8( szResult ) );
return ToUTF8( szResult );
#else
char szBuffer[ MAX_PATH ];
getcwd ( szBuffer, MAX_PATH - 1 );
return szBuffer;
#endif
}
RESULT cConnection::WatchingMovie(const string_t& sTitle, const cDuration& durationThroughMovie, const cDuration& durationOfMovie)
{
assert(IsOpen());
std::map<std::string, std::string> mValues;
mValues["action"] = "watching";
mValues["title"] = ToUTF8(sTitle);
mValues["position_seconds"] = ToUTF8(durationThroughMovie);
mValues["length_seconds"] = ToUTF8(durationOfMovie);
RESULT result = PostRequest("submit.php", sUserName, sPassword, mValues);
return result;
}
NS_IMETHODIMP
nsUTF8ConverterService::ConvertURISpecToUTF8(const nsACString &aSpec,
const char *aCharset,
nsACString &aUTF8Spec)
{
// assume UTF-8 if the spec contains unescaped non-ASCII characters.
// No valid spec in Mozilla would break this assumption.
if (!IsASCII(aSpec)) {
aUTF8Spec = aSpec;
return NS_OK;
}
aUTF8Spec.Truncate();
nsAutoCString unescapedSpec;
// NS_UnescapeURL does not fill up unescapedSpec unless there's at least
// one character to unescape.
bool written = NS_UnescapeURL(PromiseFlatCString(aSpec).get(), aSpec.Length(),
esc_OnlyNonASCII, unescapedSpec);
if (!written) {
aUTF8Spec = aSpec;
return NS_OK;
}
// return if ASCII only or escaped UTF-8
if (IsASCII(unescapedSpec) || IsUTF8(unescapedSpec)) {
aUTF8Spec = unescapedSpec;
return NS_OK;
}
return ToUTF8(unescapedSpec, aCharset, true, aUTF8Spec);
}
wstring MediaPlayers::GetTitleFromWinampAPI(HWND hwnd, bool use_unicode) {
if (IsWindow(hwnd)) {
if (SendMessage(hwnd, WM_USER, 0, IPC_ISPLAYING)) {
int list_index = SendMessage(hwnd, WM_USER, 0, IPC_GETLISTPOS);
int base_address = SendMessage(hwnd, WM_USER, list_index,
use_unicode ? IPC_GETPLAYLISTFILEW : IPC_GETPLAYLISTFILE);
if (base_address) {
DWORD process_id;
GetWindowThreadProcessId(hwnd, &process_id);
HANDLE hwnd_winamp = OpenProcess(PROCESS_VM_READ, FALSE, process_id);
if (hwnd_winamp) {
if (use_unicode) {
wchar_t file_name[MAX_PATH];
ReadProcessMemory(hwnd_winamp, reinterpret_cast<LPCVOID>(base_address),
file_name, MAX_PATH, NULL);
CloseHandle(hwnd_winamp);
return file_name;
} else {
char file_name[MAX_PATH];
ReadProcessMemory(hwnd_winamp, reinterpret_cast<LPCVOID>(base_address),
file_name, MAX_PATH, NULL);
CloseHandle(hwnd_winamp);
return ToUTF8(file_name);
}
}
}
}
}
return L"";
}
bool CLocalizeStrings::LoadXML(const CStdString &filename, CStdString &encoding, uint32_t offset /* = 0 */)
{
TiXmlDocument xmlDoc;
if (!xmlDoc.LoadFile(CSpecialProtocol::TranslatePathConvertCase(filename)))
{
CLog::Log(LOGDEBUG, "unable to load %s: %s at line %d", filename.c_str(), xmlDoc.ErrorDesc(), xmlDoc.ErrorRow());
return false;
}
XMLUtils::GetEncoding(&xmlDoc, encoding);
TiXmlElement* pRootElement = xmlDoc.RootElement();
if (!pRootElement || pRootElement->NoChildren() ||
pRootElement->ValueStr()!=CStdString("strings"))
{
CLog::Log(LOGERROR, "%s Doesn't contain <strings>", filename.c_str());
return false;
}
const TiXmlElement *pChild = pRootElement->FirstChildElement("string");
while (pChild)
{
// Load new style language file with id as attribute
const char* attrId=pChild->Attribute("id");
if (attrId && !pChild->NoChildren())
{
int id = atoi(attrId) + offset;
if (m_strings.find(id) == m_strings.end())
m_strings[id] = ToUTF8(encoding, pChild->FirstChild()->Value());
}
pChild = pChild->NextSiblingElement("string");
}
return true;
}
/*---------------------------------------------------------------------------*/
wxString wxSQLBook::GetSQLStatementAt(long start, long& end)
{
wxString Str, temp;
bool first = true;
long count = m_SQLEdit->GetLineCount();
end = -1;
for (long i = start; i < count; i++)
{
if (!first)
Str += ("\n");
else
first = false;
temp = m_SQLEdit->GetLine(i).Trim();
if ((temp.Last() == (';')) && !m_SQLEdit->EndLineIsComment(i)) // Arrêt au point virgule de fin de commande
// if (temp.IsEmpty()) // Arrêt à la première ligne vide
{
end = i;
Str += temp;
break;
}
Str += temp;
}
return ToUTF8(Str);
}
// we write str lines into the file
void WriteStrLine(std::string prefix, std::string linkedString, std::string encoding)
{
linkedString = ToUTF8(encoding, linkedString);
fprintf (pPOTFile, "%s", prefix.c_str());
fprintf (pPOTFile, "\"%s\"\n", linkedString.c_str());
return;
}
SString SharedUtil::GetSystemLongPathName( const SString& strPath )
{
wchar_t szBuffer[32000];
szBuffer[0] = 0;
GetLongPathNameW( FromUTF8( strPath ), szBuffer, NUMELMS( szBuffer ) - 1 );
return ToUTF8( szBuffer );
}
/*---------------------------------------------------------------------------*/
void wxBackupRestoreDbDlg::SetDatabase(wxSQLite3Database* db, const wxString& base)
{
wxSQLite3ResultSet dbQRY;
wxString alias;
m_Db = db;
if (!m_Db||!m_Db->IsOpen())
m_Db = NULL;
else
{
try
{
dbQRY = m_Db->ExecuteQuery(ToUTF8(("PRAGMA database_list;")));
while (dbQRY.NextRow())
{
alias = dbQRY.GetString(1);
m_Database->Append(alias);
}
m_Database->SetStringSelection(base);
}
catch(wxSQLite3Exception& ex)
{
wxGetApp().ShowError(("SetDatabase"), ex);
}
dbQRY.Finalize();
}
}
/*---------------------------------------------------------------------------*/
void wxCreateTriggerDialog::PopulateColumns()
{
wxString tablename, sql, basename;
wxSQLite3ResultSet clmnQRY;
if (m_Db == NULL)
return;
tablename = m_ObjName->GetStringSelection();
if (m_Base != wxEmptyString)
basename = m_Base;
else
basename = _T("main");
sql = wxString::Format(_T("PRAGMA %s.table_info(\"%s\");"),
basename.c_str(), tablename.c_str());
m_AvailableColumns->Clear();
m_SelectedColumns->Clear();
try
{
clmnQRY = m_Db->ExecuteQuery(ToUTF8(sql));
while (clmnQRY.NextRow())
m_AvailableColumns->Append(clmnQRY.GetString(1));
}
catch(wxSQLite3Exception& ex)
{
wxGetApp().ShowError(_T("PopulateColumns"), ex);
}
clmnQRY.Finalize();
}
NS_IMETHODIMP
nsUTF8ConverterService::ConvertStringToUTF8(const nsACString &aString,
const char *aCharset,
bool aSkipCheck,
bool aAllowSubstitution,
uint8_t aOptionalArgc,
nsACString &aUTF8String)
{
bool allowSubstitution = (aOptionalArgc == 1) ? aAllowSubstitution : true;
// return if ASCII only or valid UTF-8 providing that the ASCII/UTF-8
// check is requested. It may not be asked for if a caller suspects
// that the input is in non-ASCII 7bit charset (ISO-2022-xx, HZ) or
// it's in a charset other than UTF-8 that can be mistaken for UTF-8.
if (!aSkipCheck && (IsASCII(aString) || IsUTF8(aString))) {
aUTF8String = aString;
return NS_OK;
}
aUTF8String.Truncate();
nsresult rv = ToUTF8(aString, aCharset, allowSubstitution, aUTF8String);
// additional protection for cases where check is skipped and the input
// is actually in UTF-8 as opposed to aCharset. (i.e. caller's hunch
// was wrong.) We don't check ASCIIness assuming there's no charset
// incompatible with ASCII (we don't support EBCDIC).
if (aSkipCheck && NS_FAILED(rv) && IsUTF8(aString)) {
aUTF8String = aString;
return NS_OK;
}
return rv;
}
wstring MediaPlayers::GetTitleFromSpecialMessage(HWND hwnd, const wstring& class_name) {
// BS.Player
if (class_name == BSP_CLASS) {
if (IsWindow(hwnd)) {
COPYDATASTRUCT cds;
char file_name[MAX_PATH];
void* data = &file_name;
cds.dwData = BSP_GETFILENAME;
cds.lpData = &data;
cds.cbData = 4;
SendMessage(hwnd, WM_COPYDATA, reinterpret_cast<WPARAM>(g_hMain),
reinterpret_cast<LPARAM>(&cds));
return ToUTF8(file_name);
}
// JetAudio
} else if (class_name == JETAUDIO_MAINCLASS) {
HWND hwnd_remote = FindWindow(JETAUDIO_REMOTECLASS, JETAUDIO_WINDOW);
if (IsWindow(hwnd_remote)) {
if (SendMessage(hwnd_remote, WM_REMOCON_GETSTATUS, 0, GET_STATUS_STATUS) != MCI_MODE_STOP) {
if (SendMessage(hwnd_remote, WM_REMOCON_GETSTATUS,
reinterpret_cast<WPARAM>(g_hMain), GET_STATUS_TRACK_FILENAME)) {
return new_title;
}
}
}
}
return L"";
}
SString SharedUtil::GetSystemShortPathName(const SString& strPath)
{
wchar_t szBuffer[32000];
szBuffer[0] = 0;
if (!GetShortPathNameW(FromUTF8(strPath), szBuffer, NUMELMS(szBuffer) - 1))
return strPath;
return ToUTF8(szBuffer);
}
// Get drive root from path
SString SharedUtil::GetPathDriveName( const SString& strPath )
{
wchar_t szDrive[4] = L"";
int iDriveNumber = PathGetDriveNumberW( FromUTF8( strPath ) );
if ( iDriveNumber > -1 )
PathBuildRootW( szDrive, iDriveNumber );
return ToUTF8( szDrive );
}
LRESULT Skype::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam) {
if (uMsg == WM_COPYDATA) {
if (hwnd_skype == nullptr ||
hwnd_skype != reinterpret_cast<HWND>(wParam))
return FALSE;
auto pCDS = reinterpret_cast<PCOPYDATASTRUCT>(lParam);
wstring command = ToUTF8(reinterpret_cast<LPCSTR>(pCDS->lpData));
LOG(LevelDebug, L"Received WM_COPYDATA: " + command);
wstring profile_command = L"PROFILE RICH_MOOD_TEXT ";
if (StartsWith(command, profile_command)) {
wstring mood = command.substr(profile_command.length());
if (mood != current_mood && mood != previous_mood) {
LOG(LevelDebug, L"Saved previous mood message: " + mood);
previous_mood = mood;
}
}
return TRUE;
} else if (uMsg == wm_attach) {
hwnd_skype = nullptr;
switch (lParam) {
case SKYPECONTROLAPI_ATTACH_SUCCESS:
LOG(LevelDebug, L"Attach succeeded.");
hwnd_skype = reinterpret_cast<HWND>(wParam);
GetMoodText();
if (!current_mood.empty())
SetMoodText(current_mood);
break;
case SKYPECONTROLAPI_ATTACH_PENDING_AUTHORIZATION:
LOG(LevelDebug, L"Waiting for user confirmation...");
break;
case SKYPECONTROLAPI_ATTACH_REFUSED:
LOG(LevelError, L"User denied access to client.");
break;
case SKYPECONTROLAPI_ATTACH_NOT_AVAILABLE:
LOG(LevelError, L"API is not available.");
break;
case SKYPECONTROLAPI_ATTACH_API_AVAILABLE:
LOG(LevelDebug, L"API is now available.");
Discover();
break;
default:
LOG(LevelDebug, L"Received unknown message.");
break;
}
return TRUE;
} else if (uMsg == wm_discover) {
LOG(LevelDebug, L"Received SkypeControlAPIDiscover message.");
}
return FALSE;
}
RESULT cConnection::WatchedMovie(const string_t& sTitle)
{
assert(IsOpen());
std::map<std::string, std::string> mValues;
mValues["action"] = "watched";
mValues["title"] = ToUTF8(sTitle);
RESULT result = PostRequest("submit.php", sUserName, sPassword, mValues);
return result;
}
///////////////////////////////////////////////////////////////
//
// FindFiles
//
// Find all files or directories at a path
// If sorted by date, returns last modified last
//
///////////////////////////////////////////////////////////////
std::vector < SString > SharedUtil::FindFiles ( const SString& strInMatch, bool bFiles, bool bDirectories, bool bSortByDate )
{
std::vector < SString > strResult;
std::multimap < uint64, SString > sortMap;
SString strMatch = PathConform ( strInMatch );
if ( strMatch.Right ( 1 ) == PATH_SEPERATOR )
strMatch += "*";
WIN32_FIND_DATAW findData;
HANDLE hFind = FindFirstFileW ( FromUTF8( strMatch ), &findData );
if( hFind != INVALID_HANDLE_VALUE )
{
do
{
if ( ( findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) ? bDirectories : bFiles )
if ( wcscmp ( findData.cFileName, L"." ) && wcscmp ( findData.cFileName, L".." ) )
{
if ( bSortByDate )
MapInsert( sortMap, (uint64&)findData.ftLastWriteTime, ToUTF8( findData.cFileName ) );
else
strResult.push_back ( ToUTF8( findData.cFileName ) );
}
}
while( FindNextFileW( hFind, &findData ) );
FindClose( hFind );
}
// Resolve sorted map if required
if ( !sortMap.empty() )
{
for ( std::multimap < uint64, SString >::iterator iter = sortMap.begin() ; iter != sortMap.end() ; ++iter )
strResult.push_back ( iter->second );
}
return strResult;
}
// C:\Program Files\gta_sa.exe
SString SharedUtil::GetLaunchPathFilename(void)
{
static SString strLaunchPathFilename;
if (strLaunchPathFilename.empty())
{
wchar_t szBuffer[2048];
GetModuleFileNameW(NULL, szBuffer, NUMELMS(szBuffer) - 1);
wchar_t fullPath[MAX_PATH];
GetFullPathNameW(szBuffer, MAX_PATH, fullPath, nullptr);
strLaunchPathFilename = ToUTF8(fullPath);
}
return strLaunchPathFilename;
}
bool TerminateProcessFromPathFilename ( const SString& strPathFilename )
{
DWORD dwProcessIDs[250];
DWORD pBytesReturned = 0;
if ( EnumProcesses ( dwProcessIDs, 250 * sizeof(DWORD), &pBytesReturned ) )
{
DWORD id1 = GetCurrentProcessId();
for ( unsigned int i = 0; i < pBytesReturned / sizeof ( DWORD ); i++ )
{
DWORD id2 = dwProcessIDs[i];
if ( id2 == id1 )
continue;
// Skip 64 bit processes to avoid errors
if ( !Is32bitProcess ( dwProcessIDs[i] ) )
continue;
// Open the process
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, 0, dwProcessIDs[i]);
if ( hProcess )
{
HMODULE pModule;
DWORD cbNeeded;
if ( EnumProcessModules ( hProcess, &pModule, sizeof ( HMODULE ), &cbNeeded ) )
{
WCHAR szModuleName[MAX_PATH*2] = L"";
if ( GetModuleFileNameExW( hProcess, pModule, szModuleName, NUMELMS(szModuleName) ) )
{
SString strModuleName = ToUTF8( szModuleName );
if ( stricmp ( strModuleName, strPathFilename ) == 0 )
{
TerminateProcess ( hProcess, 0 );
CloseHandle ( hProcess );
return true;
}
}
}
// Close the process
CloseHandle ( hProcess );
}
}
}
return false;
}
static void UTF16_to_UTF8 ( const UTF16Unit * utf16Ptr, size_t utf16Len, bool bigEndian, std::string * outStr )
{
UTF16_to_UTF8_Proc ToUTF8 = 0;
if ( bigEndian ) {
ToUTF8 = UTF16BE_to_UTF8;
} else {
ToUTF8 = UTF16LE_to_UTF8;
}
UTF8Unit buffer [1000];
size_t inCount, outCount;
outStr->erase();
outStr->reserve ( utf16Len * 2 ); // As good a guess as any.
while ( utf16Len > 0 ) {
ToUTF8 ( utf16Ptr, utf16Len, buffer, sizeof(buffer), &inCount, &outCount );
outStr->append ( (XMP_StringPtr)buffer, outCount );
utf16Ptr += inCount;
utf16Len -= inCount;
}
} // UTF16_to_UTF8
void Parser::Next() {
doc_comment_.clear();
bool seen_newline = false;
for (;;) {
char c = *cursor_++;
token_ = c;
switch (c) {
case '\0': cursor_--; token_ = kTokenEof; return;
case ' ': case '\r': case '\t': break;
case '\n': line_++; seen_newline = true; break;
case '{': case '}': case '(': case ')': case '[': case ']': return;
case ',': case ':': case ';': case '=': return;
case '.':
if(!isdigit(*cursor_)) return;
Error("floating point constant can\'t start with \".\"");
break;
case '\"':
attribute_ = "";
while (*cursor_ != '\"') {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits"
if (*cursor_ < ' ' && *cursor_ >= 0)
Error("illegal character in string constant");
#pragma GCC diagnostic pop
if (*cursor_ == '\\') {
cursor_++;
switch (*cursor_) {
case 'n': attribute_ += '\n'; cursor_++; break;
case 't': attribute_ += '\t'; cursor_++; break;
case 'r': attribute_ += '\r'; cursor_++; break;
case 'b': attribute_ += '\b'; cursor_++; break;
case 'f': attribute_ += '\f'; cursor_++; break;
case '\"': attribute_ += '\"'; cursor_++; break;
case '\\': attribute_ += '\\'; cursor_++; break;
case '/': attribute_ += '/'; cursor_++; break;
case 'x': { // Not in the JSON standard
cursor_++;
attribute_ += static_cast<char>(ParseHexNum(2));
break;
}
case 'u': {
cursor_++;
ToUTF8(static_cast<int>(ParseHexNum(4)), &attribute_);
break;
}
default: Error("unknown escape code in string constant"); break;
}
} else { // printable chars + UTF-8 bytes
attribute_ += *cursor_++;
}
}
cursor_++;
token_ = kTokenStringConstant;
return;
case '/':
if (*cursor_ == '/') {
const char *start = ++cursor_;
while (*cursor_ && *cursor_ != '\n') cursor_++;
if (*start == '/') { // documentation comment
if (cursor_ != source_ && !seen_newline)
Error("a documentation comment should be on a line on its own");
doc_comment_.push_back(std::string(start + 1, cursor_));
}
break;
}
// fall thru
default:
if (isalpha(static_cast<unsigned char>(c))) {
// Collect all chars of an identifier:
const char *start = cursor_ - 1;
while (isalnum(static_cast<unsigned char>(*cursor_)) ||
*cursor_ == '_')
cursor_++;
attribute_.clear();
attribute_.append(start, cursor_);
// First, see if it is a type keyword from the table of types:
#define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE) \
if (attribute_ == IDLTYPE) { \
token_ = kToken ## ENUM; \
return; \
}
FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
#undef FLATBUFFERS_TD
// If it's a boolean constant keyword, turn those into integers,
// which simplifies our logic downstream.
if (attribute_ == "true" || attribute_ == "false") {
attribute_ = NumToString(attribute_ == "true");
token_ = kTokenIntegerConstant;
return;
}
// Check for declaration keywords:
if (attribute_ == "table") { token_ = kTokenTable; return; }
if (attribute_ == "struct") { token_ = kTokenStruct; return; }
if (attribute_ == "enum") { token_ = kTokenEnum; return; }
if (attribute_ == "union") { token_ = kTokenUnion; return; }
if (attribute_ == "namespace") { token_ = kTokenNameSpace; return; }
if (attribute_ == "root_type") { token_ = kTokenRootType; return; }
if (attribute_ == "include") { token_ = kTokenInclude; return; }
if (attribute_ == "attribute") { token_ = kTokenAttribute; return; }
if (attribute_ == "file_identifier") {
token_ = kTokenFileIdentifier;
return;
}
if (attribute_ == "file_extension") {
token_ = kTokenFileExtension;
return;
}
// If not, it is a user-defined identifier:
token_ = kTokenIdentifier;
return;
} else if (isdigit(static_cast<unsigned char>(c)) || c == '-') {
const char *start = cursor_ - 1;
while (isdigit(static_cast<unsigned char>(*cursor_))) cursor_++;
if (*cursor_ == '.') {
cursor_++;
while (isdigit(static_cast<unsigned char>(*cursor_))) cursor_++;
// See if this float has a scientific notation suffix. Both JSON
// and C++ (through strtod() we use) have the same format:
if (*cursor_ == 'e' || *cursor_ == 'E') {
cursor_++;
if (*cursor_ == '+' || *cursor_ == '-') cursor_++;
while (isdigit(static_cast<unsigned char>(*cursor_))) cursor_++;
}
token_ = kTokenFloatConstant;
} else {
token_ = kTokenIntegerConstant;
}
attribute_.clear();
attribute_.append(start, cursor_);
return;
}
std::string ch;
ch = c;
if (c < ' ' || c > '~') ch = "code: " + NumToString(c);
Error("illegal character: " + ch);
break;
}
}
double const ToDouble(std::wstring const &content) {
return ToDouble(ToUTF8(content));
}
