int main () { string s="你好"; wstring ws=L"你好"; cout<<s<<endl; cout<<wstringtostring(ws)<<endl; cout<<narrow(ws)<<endl; wcout.imbue(locale(locale(), "", LC_CTYPE)); // wcout.imbue(locale("")); // wcout.imbue(locale_platform); wcout<<ws<<endl; wcout<<stringtowstring(s)<<endl; wcout<<widen(s)<<endl; wofstream fout("fout.txt"); fout.imbue(locale_platform); fout<<ws<<endl; fout<<stringtowstring(s)<<endl; fout<<widen(s)<<endl; // string in; // copy(utf8in(s.begin()), utf8in(s.end()), back_inserter(in)); // cout<<in<<endl; // copy(utf8in(s.begin()), utf8in(s.end()), back_inserter(wvect)); // cout<<string(utf8in(s.begin()), utf8in(s.end()))<<endl; }
bool init_sentinel() { // create synchronization event g_crash_event = CreateEventW(NULL, FALSE, FALSE, widen(crash_id).c_str()); if (!g_crash_event) { std::cerr << "Could not initialize crash event object." << std::endl; } // create shared memory (through MMF) auto map_file = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, BUF_SIZE, widen(mmf_name).c_str()); if (!map_file) { std::cerr << "Could not open MMF (" << crash_id << ")" << std::endl; std::cerr << "GetLastError(): " << GetLastError() << std::endl; return false; } g_mmf = reinterpret_cast<char *>( MapViewOfFile(map_file, FILE_MAP_ALL_ACCESS, 0, 0, BUF_SIZE)); // start sentinel.exe STARTUPINFOW info = {sizeof(info)}; PROCESS_INFORMATION processInfo; std::stringstream ss; ss << "sentinel.exe " << crash_id << " " << mmf_name; if (CreateProcessW(widen("sentinel.exe").c_str(), const_cast<wchar_t *>(widen(ss.str()).c_str()), NULL, NULL, TRUE, CREATE_NEW_CONSOLE, NULL, NULL, &info, &processInfo) == 0) { return false; } SetUnhandledExceptionFilter(unhandled_filter); return true; }
StartupInfoEx( LPSTARTUPINFOA si, StringSaver<wchar_t> & s, WideConverter & c ) { static_cast<STARTUPINFOW &>( *this ) = *reinterpret_cast<LPSTARTUPINFOW>( si ); this->lpReserved = widen( s, c, si->lpReserved ); this->lpDesktop = widen( s, c, si->lpDesktop ); this->lpTitle = widen( s, c, si->lpTitle ); }
void execute_shell(std::string fname, std::string args) { WCHAR cDir[MAX_PATH]; GetCurrentDirectoryW(MAX_PATH, cDir); tstring tstr_fname = widen(fname); tstring tstr_args = widen(args); ShellExecuteW(enigma::hWnd, NULL, tstr_fname.c_str(), tstr_args.c_str(), cDir, SW_SHOW); }
bool create_snapshot(std::string snapshot_src, std::string snapshot_dst) { #ifdef _WIN32 return CopyFolder(widen(snapshot_src), widen(snapshot_dst)); #else int rc=system((btrfs_cmd+" subvolume snapshot \""+snapshot_src+"\" \""+snapshot_dst+"\"").c_str()); system(("chown urbackup:urbackup \""+snapshot_dst+"\"").c_str()); return rc==0; #endif }
int response_type7(int id,int major,int minor,int num,char** buf,int bufsize) { canna_server* svr = &server[id]; canna_response_type7 res; int total,sub,size,offset; int i; reset(svr); if (num == -1) { res.maj = major; res.min = minor; res.size = htons(2); res.num = htons(-1); if (emit(svr,&res.maj,1)) return -1; if (emit(svr,&res.min,1)) return -1; if (emit(svr,&res.size,2)) return -1; if (emit(svr,&res.num,2)) return -1; } else { total = 0; for (i = 0; i < bufsize; i++) { sub = widen(0,0,buf[i],strlen(buf[i])+1); if (sub == -1) return -1; total += sub; } size = total * 2; res.maj = major; res.min = minor; res.size = htons(2+size); res.num = htons(num); res.data = malloc(size); offset = 0; for (i = 0; i < bufsize; i++) { sub = widen(((uint16_t*)res.data) + offset, total - offset,buf[i],strlen(buf[i]) + 1); if (sub == -1) break; offset += sub; } if (emit(svr,&res.maj,1)) return -1; if (emit(svr,&res.min,1)) return -1; if (emit(svr,&res.size,2)) return -1; if (emit(svr,&res.num,2)) return -1; if (emit(svr,res.data,size)) return -1; free(res.data); } return flush(svr); }
unsigned long long disk_size(std::string drive) { DWORD sectorsPerCluster, bytesPerSector, totalClusters, freeClusters; tstring tstr_drive = widen(drive); tstring tstr_colonslash = widen(":\\"); tstring tstr_empty = widen(""); if (tstr_drive.length() == 1) tstr_drive += tstr_colonslash; if (!GetDiskFreeSpaceW((tstr_drive == tstr_empty) ? NULL : tstr_drive.c_str(), §orsPerCluster, &bytesPerSector, &freeClusters, &totalClusters)) return 0; return (unsigned long long)(totalClusters * sectorsPerCluster) * (unsigned long long)bytesPerSector; }
void MidiService::play(string file, int volume) { // Предварительно закрываем предыдущий файл. // В один момент времени может проигрываться только один файл MIDI. close(true, ""); // Открываем файл. string command = "open \"" + file + "\" type sequencer alias MidiFile"; wstring wCommand = widen(command); LPCWSTR pCommand = wCommand.c_str(); MCIERROR err = mciSendString(pCommand, NULL, 0, NULL); if (err != 0) { showError("Не удалось открыть MIDI-файл: " + file); return; } // Запускаем проигрывание. err = mciSendString(L"play MidiFile from 0", NULL, 0, NULL); if (err != 0) { showError("Не удалось запустить MIDI-файл: " + file); return; } // Устанавливаем громкость проигрываемого файла. setVolume(volume); // Сохраняем имя файла. midiFile = file; }
std::string environment_get_variable(std::string name) { WCHAR buffer[1024]; tstring tstr_name = widen(name); GetEnvironmentVariableW(tstr_name.c_str(), (LPWSTR)&buffer, 1024); return shorten(buffer); }
Logger &Logger::operator<<(std::string &val) { #ifndef _SIMPLE_NO_DEBUG m_stream << widen(val); #endif return *this; }
bool c_preprocess_none( const std::string &file, std::ostream &outstream, message_handlert &message_handler) { #ifdef _MSC_VER std::ifstream infile(widen(file).c_str()); #else std::ifstream infile(file.c_str()); #endif if(!infile) { message_streamt message_stream(message_handler); message_stream.error("failed to open `"+file+"'"); return true; } if(config.ansi_c.mode==configt::ansi_ct::MODE_CODEWARRIOR_C_CPP) { // special treatment for "/* #line" postprocess_codewarrior(infile, outstream); } else { char ch; while(infile.read(&ch, 1)) outstream << ch; } return false; }
void basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb) { this->rdbuf(__sb); this->imbue(locale()); this->tie(0); this->_M_set_exception_mask(ios_base::goodbit); /* this->_M_clear_nothrow(__sb != 0 ? ios_base::goodbit : ios_base::badbit); The ternary expression above, throws an undefined reference link error (for goodbit and badbit) when compiled with GCCE 4.3.2. Replacing ternary statement with an if-else block fixes this. */ if(__sb != 0) { this->_M_clear_nothrow(ios_base::goodbit); } else { this->_M_clear_nothrow(ios_base::badbit); } ios_base::flags(ios_base::skipws | ios_base::dec); ios_base::width(0); ios_base::precision(6); this->fill(widen(' ')); // We don't need to worry about any of the three arrays: they are // initialized correctly in ios_base's constructor. }
void print_response(HttpResponse& response, TcpClientSocket& socket) { std::cout << narrow(widen(response.getStatusLine(), CP_UTF8), CP_OEMCP) << std::endl; auto headers = response.getHeaders(); for (auto it = std::begin(headers), eit = std::end(headers); it != eit; ++it) { for (auto vit = std::begin(it->second), veit = std::end(it->second); vit != veit; ++vit) { std::cout << it->first << ": " << *vit << std::endl; } } std::cout << "======END OF HEADERS======" << std::endl; auto& buffer = response.getBuffer(); if (response.getIsChunked()) { std::cout << "[[CHUNKED ENCODING]]" << std::endl; for (auto chunk = buffer.getchunk(); !chunk.empty(); chunk = buffer.getchunk()) { std::cout << chunk; } std::cout << "[[TRAILING HEADERS]]" << std::endl; for (auto th = buffer.getline(); !th.empty(); th = buffer.getline()) { std::cout << th << std::endl; } } else if (HttpResponse::nlen != response.getContentLength()) { std::cout << "[[EXACTLY " << response.getContentLength() << " BYTES]]" << std::endl; std::cout << buffer.getcount(response.getContentLength()) << std::endl; } else { std::vector<BYTE> buff(8 * 1024, 0); for (auto last = socket.recv_upto(std::begin(buff), std::end(buff)); last != std::begin(buff); last = socket.recv_upto(std::begin(buff), std::end(buff))) { std::cout << std::string(std::begin(buff), last); } } std::cout << std::endl << "======END OF RESPONSE======" << std::endl; }
bool XmlSettingsStore::Save() { if (!modified_) { return true; } try { modified_ = false; std::ofstream out; out.open(widen(filename_), std::ios::out | std::ios::trunc); out << "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n"; out << "<settings>\n"; for (const auto& p : long_settings_) { out << "<long name=\"" << p.first << "\" value=\"" << p.second << "\"/>\n"; } for (const auto& p : boolean_settings_) { std::string value = p.second ? "True" : "False"; out << "<bool name=\"" << p.first << "\" value=\"" << value << "\"/>\n"; } for (const auto& p : string_settings_) { std::string attribute = p.second; XML_Escape(attribute, true /* attribute */); out << "<string name=\"" << p.first << "\" value=\"" << attribute << "\"/>\n"; } out << "</settings>\n"; out.close(); } catch (...) { // TODO(localize). m_pMsgs->Message("Failed to save the settings", true /* interrupt */); return false; } return true; }
void WrappedID3D11DeviceContext::AddEvent(D3D11ChunkType type, string description, ResourceId ctx) { if(ctx == ResourceId()) ctx = m_pDevice->GetResourceManager()->GetOriginalID(m_ResourceID); if(GetType() == D3D11_DEVICE_CONTEXT_DEFERRED) { m_pDevice->GetImmediateContext()->AddEvent(type, description, ctx); return; } FetchAPIEvent apievent; apievent.context = ctx; apievent.fileOffset = m_CurChunkOffset; apievent.eventID = m_CurEventID; apievent.eventDesc = widen(description); Callstack::Stackwalk *stack = m_pSerialiser->GetLastCallstack(); if(stack) { create_array(apievent.callstack, stack->NumLevels()); memcpy(apievent.callstack.elems, stack->GetAddrs(), sizeof(uint64_t)*stack->NumLevels()); } m_CurEvents.push_back(apievent); if(m_State == READING) m_Events.push_back(apievent); }
int directory_exists(std::string dname) { DWORD file_attr; tstring tstr_dname = widen(dname); file_attr = GetFileAttributesW(tstr_dname.c_str()); return (file_attr != INVALID_FILE_ATTRIBUTES && (file_attr & FILE_ATTRIBUTE_DIRECTORY)); }
implementation(size_t output_channels, size_t input_channels, size_t output_sample_rate, size_t input_sample_rate, AVSampleFormat output_sample_format, AVSampleFormat input_sample_format) : output_channels_(output_channels) , output_sample_format_(output_sample_format) , input_channels_(input_channels) , input_sample_format_(input_sample_format) { if(input_channels != output_channels || input_sample_rate != output_sample_rate || input_sample_format != output_sample_format) { auto resampler = av_audio_resample_init(output_channels, input_channels, output_sample_rate, input_sample_rate, output_sample_format, input_sample_format, 16, 10, 0, 0.8); buffer2_.resize(AVCODEC_MAX_AUDIO_FRAME_SIZE*2); char sample_fmt_string[200]; av_get_sample_fmt_string(sample_fmt_string, 200, input_sample_format); CASPAR_LOG(warning) << L"[audio-resampler]" << L" sample-rate: " << input_sample_rate << L" channels: " << input_channels << L" sample-fmt: " << widen(sample_fmt_string); if(resampler) resampler_.reset(resampler, audio_resample_close); else BOOST_THROW_EXCEPTION(caspar_exception()); } }
bool WrappedOpenGL::Serialise_glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) { SERIALISE_ELEMENT(GLenum, buf, buffer); SERIALISE_ELEMENT(int32_t, draw, drawbuffer); SERIALISE_ELEMENT(float, d, depth); SERIALISE_ELEMENT(int32_t, s, stencil); if(m_State <= EXECUTING) m_Real.glClearBufferfi(buf, draw, d, s); const string desc = m_pSerialiser->GetDebugStr(); if(m_State == READING) { AddEvent(CLEARBUFFERFI, desc); string name = "glClearBufferfi(" + ToStr::Get(buf) + ", " + ToStr::Get(draw) + ")"; FetchDrawcall draw; draw.name = widen(name); draw.flags |= eDraw_Clear; AddDrawcall(draw, true); } return true; }
ResourceId ReplayRenderer::BuildCustomShader(const wchar_t *entry, const wchar_t *source, const uint32_t compileFlags, ShaderStageType type, rdctype::wstr *errors) { ResourceId id; string errs; switch(type) { case eShaderStage_Vertex: case eShaderStage_Hull: case eShaderStage_Domain: case eShaderStage_Geometry: case eShaderStage_Pixel: case eShaderStage_Compute: break; default: RDCERR("Unexpected type in BuildShader!"); return ResourceId(); } m_pDevice->BuildCustomShader(narrow(source), narrow(entry), compileFlags, type, &id, &errs); if(id != ResourceId()) m_CustomShaders.insert(id); if(errors) *errors = widen(errs); return id; }
bool WrappedOpenGL::Serialise_glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value) { SERIALISE_ELEMENT(GLenum, buf, buffer); SERIALISE_ELEMENT(int32_t, draw, drawbuffer); { uint32_t v[4]; if(value) memcpy(v, value, sizeof(v)); m_pSerialiser->Serialise<4>("value", v); if(m_State <= EXECUTING) m_Real.glClearBufferuiv(buf, draw, v); } const string desc = m_pSerialiser->GetDebugStr(); if(m_State == READING) { AddEvent(CLEARBUFFERUI, desc); string name = "glClearBufferuiv(" + ToStr::Get(buf) + ", " + ToStr::Get(draw) + ")"; FetchDrawcall draw; draw.name = widen(name); draw.flags |= eDraw_Clear; AddDrawcall(draw, true); } return true; }
void console_message_handlert::print( unsigned level, const std::string &message) { if(verbosity<level) return; #ifdef _WIN32 HANDLE out_handle= GetStdHandle((level>1)?STD_OUTPUT_HANDLE:STD_ERROR_HANDLE); // We use UTF16 when we write to the console, // but we write UTF8 otherwise. DWORD consoleMode; if(GetConsoleMode(out_handle, &consoleMode)) { // writing to the console std::wstring wide_message=widen(message); DWORD number_written; WriteConsoleW( out_handle, wide_message.c_str(), (DWORD)wide_message.size(), &number_written, NULL); WriteConsoleW(out_handle, L"\r\n", 2, &number_written, NULL); } else { // writing to a file if(level>=4) { std::cout << message << '\n'; if(level<=6) std::cout << std::flush; } else std::cerr << message << '\n' << std::flush; } #else // We flush after messages of level 6 or lower. // We don't for messages of level 7 or higher to improve performance, // in particular when writing to NFS. // Messages level 3 or lower go to cerr, messages level 4 or // above go to cout. if(level>=4) { std::cout << message << '\n'; if(level<=6) std::cout << std::flush; } else std::cerr << message << '\n' << std::flush; #endif }
result_type operator()(From const &from, Traits const &tr) const { widen_fun<Traits> widen(tr); To to( boost::make_transform_iterator(detail::data_begin(from), widen) , boost::make_transform_iterator(detail::data_end(from), widen) ); return to; }
bool remove_subvolume(std::string subvolume_folder) { #ifdef _WIN32 return os_remove_nonempty_dir(widen(subvolume_folder)); #else int rc=system((btrfs_cmd+" subvolume delete \""+subvolume_folder+"\"").c_str()); return rc==0; #endif }
CreateProcessParams( char const * appName, char * commandLine, LPSECURITY_ATTRIBUTES procAttr, LPSECURITY_ATTRIBUTES threadAttr, BOOL inherit, DWORD flags, void * env, char const * curDir, LPSTARTUPINFOA pStartupInfo ) : stringSaver_( new StringSaver<wchar_t>() ), lpApplicationName( widen( appName ) ), lpCommandLine( widen( commandLine ) ), lpProcessAttributes( procAttr ), lpThreadAttributes( threadAttr ), bInheritHandles( inherit ), dwCreationFlags( flags ), environment( env, ( flags & CREATE_UNICODE_ENVIRONMENT ) != 0 ), lpCurrentDirectory( widen( curDir ) ), startupInfo( pStartupInfo, *stringSaver_, converter_ ) { postProcessArgs(); }
void serialize(std::vector<byte> & v) const { insert_obj(v, sizeof(WORD), _pt_size); auto font_name = widen(_name); insert_data(v, 1, (byte *) font_name.c_str(), (byte *) (font_name.c_str() + font_name.size() + 1)); }
BOOL LASwriterTXT::open(const CHAR* file_name, const LASheader* header, const CHAR* parse_string, const CHAR* separator) { if (file_name == 0) { fprintf(stderr,"ERROR: file name pointer is zero\n"); return FALSE; } file = fopen(widen(file_name).c_str(), widen("w").c_str()); if (file == 0) { fprintf(stderr, "ERROR: cannot open file '%s'\n", file_name); return FALSE; } close_file = TRUE; return open(file, header, parse_string, separator); }
std::wstring WMessageResourceBundle::getValue(const WMessage& message) { std::wstring result; for (unsigned i = 0; i < messageResources_.size(); ++i) { if (messageResources_[i]->getValue(message, result)) return result; } return L"??" + widen(message.key()) + L"??"; }
bool create_snapshot(int mode, std::string snapshot_src, std::string snapshot_dst) { #ifdef _WIN32 return CopyFolder(widen(snapshot_src), widen(snapshot_dst)); #else if(mode==mode_btrfs) { int rc=exec_wait(find_btrfs_cmd(), true, "subvolume", "snapshot", snapshot_src.c_str(), snapshot_dst.c_str(), NULL); chown_dir(snapshot_dst); return rc==0; } else if(mode==mode_zfs) { zfs_elevate(); int rc=exec_wait(find_zfs_cmd(), true, "clone", (snapshot_src+"@ro").c_str(), snapshot_dst.c_str(), NULL); chown_dir(snapshot_dst); return rc==0; } return false; #endif }
std::string toUTF8(const std::string& s) { #ifndef WT_NO_STD_WSTRING return toUTF8(widen(s)); #else // You may want to rewrite this for your system std::string retval = s; for(std::size_t i = 0; i < retval.size(); ++i) if (retval[i] > 127) retval[i] = '?'; return s; #endif }
bool set_working_directory(string dname) { tstring tstr_dname = widen(dname); replace(tstr_dname.begin(), tstr_dname.end(), '/', '\\'); if (SetCurrentDirectoryW(tstr_dname.c_str()) != 0) { WCHAR wstr_buffer[MAX_PATH + 1]; if (GetCurrentDirectoryW(MAX_PATH + 1, wstr_buffer) != 0) { working_directory = add_slash(shorten(wstr_buffer)); return true; } } return false; }