/*********************************************************************** * start_dos_exe */ static void start_dos_exe( LPCSTR filename, LPCSTR cmdline ) { MEMORY_BASIC_INFORMATION mem_info; const char *reason; if (VirtualQuery( NULL, &mem_info, sizeof(mem_info) ) && mem_info.State != MEM_FREE) { __wine_load_dos_exe( filename, cmdline ); if (GetLastError() == ERROR_NOT_SUPPORTED) reason = "because vm86 mode is not supported on this platform"; else reason = wine_dbg_sprintf( "It failed with error code %u", GetLastError() ); } else reason = "because the DOS memory range is unavailable"; start_dosbox( filename, cmdline ); WINE_MESSAGE( "winevdm: Cannot start DOS application %s\n", filename ); WINE_MESSAGE( " %s.\n", reason ); WINE_MESSAGE( " Try running this application with DOSBox.\n" ); ExitProcess(1); }
static const char * getControlType(DWORD dwControlType) { #define TYPE_TO_STR(x) case x: return #x; switch (dwControlType) { TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_CUSTOM); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BOOLEANMETER); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_SIGNEDMETER); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_PEAKMETER); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_UNSIGNEDMETER); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BOOLEAN); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_ONOFF); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MUTE); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MONO); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_LOUDNESS); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_STEREOENH); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BASS_BOOST); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BUTTON); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_DECIBELS); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_SIGNED); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_UNSIGNED); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_PERCENT); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_SLIDER); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_PAN); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_QSOUNDPAN); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_FADER); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_VOLUME); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_BASS); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_TREBLE); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_EQUALIZER); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_SINGLESELECT); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MUX); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MIXER); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MICROTIME); TYPE_TO_STR(MIXERCONTROL_CONTROLTYPE_MILLITIME); } #undef TYPE_TO_STR return wine_dbg_sprintf("UNKNOWN(%08x)", dwControlType); }
/****************************************************************** * WINMM_ErrorToString */ const char* WINMM_ErrorToString(MMRESULT error) { #define ERR_TO_STR(dev) case dev: return #dev switch (error) { ERR_TO_STR(MMSYSERR_NOERROR); ERR_TO_STR(MMSYSERR_ERROR); ERR_TO_STR(MMSYSERR_BADDEVICEID); ERR_TO_STR(MMSYSERR_NOTENABLED); ERR_TO_STR(MMSYSERR_ALLOCATED); ERR_TO_STR(MMSYSERR_INVALHANDLE); ERR_TO_STR(MMSYSERR_NODRIVER); ERR_TO_STR(MMSYSERR_NOMEM); ERR_TO_STR(MMSYSERR_NOTSUPPORTED); ERR_TO_STR(MMSYSERR_BADERRNUM); ERR_TO_STR(MMSYSERR_INVALFLAG); ERR_TO_STR(MMSYSERR_INVALPARAM); ERR_TO_STR(MMSYSERR_HANDLEBUSY); ERR_TO_STR(MMSYSERR_INVALIDALIAS); ERR_TO_STR(MMSYSERR_BADDB); ERR_TO_STR(MMSYSERR_KEYNOTFOUND); ERR_TO_STR(MMSYSERR_READERROR); ERR_TO_STR(MMSYSERR_WRITEERROR); ERR_TO_STR(MMSYSERR_DELETEERROR); ERR_TO_STR(MMSYSERR_VALNOTFOUND); ERR_TO_STR(MMSYSERR_NODRIVERCB); ERR_TO_STR(WAVERR_BADFORMAT); ERR_TO_STR(WAVERR_STILLPLAYING); ERR_TO_STR(WAVERR_UNPREPARED); ERR_TO_STR(WAVERR_SYNC); ERR_TO_STR(MIDIERR_INVALIDSETUP); ERR_TO_STR(MIDIERR_NODEVICE); ERR_TO_STR(MIDIERR_STILLPLAYING); ERR_TO_STR(MIDIERR_UNPREPARED); } #undef ERR_TO_STR return wine_dbg_sprintf("Unknown(0x%08x)", error); }
const char *debugstr_variant(const VARIANT *v) { if(!v) return "(null)"; switch(V_VT(v)) { case VT_EMPTY: return "{VT_EMPTY}"; case VT_NULL: return "{VT_NULL}"; case VT_I4: return wine_dbg_sprintf("{VT_I4: %d}", V_I4(v)); case VT_R8: return wine_dbg_sprintf("{VT_R8: %lf}", V_R8(v)); case VT_BSTR: return wine_dbg_sprintf("{VT_BSTR: %s}", debugstr_w(V_BSTR(v))); case VT_DISPATCH: return wine_dbg_sprintf("{VT_DISPATCH: %p}", V_DISPATCH(v)); case VT_BOOL: return wine_dbg_sprintf("{VT_BOOL: %x}", V_BOOL(v)); default: return wine_dbg_sprintf("{vt %d}", V_VT(v)); } }
const char *debugstr_bindstatus(ULONG status) { switch(status) { #define X(x) case x: return #x X(BINDSTATUS_FINDINGRESOURCE); X(BINDSTATUS_CONNECTING); X(BINDSTATUS_REDIRECTING); X(BINDSTATUS_BEGINDOWNLOADDATA); X(BINDSTATUS_DOWNLOADINGDATA); X(BINDSTATUS_ENDDOWNLOADDATA); X(BINDSTATUS_BEGINDOWNLOADCOMPONENTS); X(BINDSTATUS_INSTALLINGCOMPONENTS); X(BINDSTATUS_ENDDOWNLOADCOMPONENTS); X(BINDSTATUS_USINGCACHEDCOPY); X(BINDSTATUS_SENDINGREQUEST); X(BINDSTATUS_CLASSIDAVAILABLE); X(BINDSTATUS_MIMETYPEAVAILABLE); X(BINDSTATUS_CACHEFILENAMEAVAILABLE); X(BINDSTATUS_BEGINSYNCOPERATION); X(BINDSTATUS_ENDSYNCOPERATION); X(BINDSTATUS_BEGINUPLOADDATA); X(BINDSTATUS_UPLOADINGDATA); X(BINDSTATUS_ENDUPLOADINGDATA); X(BINDSTATUS_PROTOCOLCLASSID); X(BINDSTATUS_ENCODING); X(BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE); X(BINDSTATUS_CLASSINSTALLLOCATION); X(BINDSTATUS_DECODING); X(BINDSTATUS_LOADINGMIMEHANDLER); X(BINDSTATUS_CONTENTDISPOSITIONATTACH); X(BINDSTATUS_FILTERREPORTMIMETYPE); X(BINDSTATUS_CLSIDCANINSTANTIATE); X(BINDSTATUS_IUNKNOWNAVAILABLE); X(BINDSTATUS_DIRECTBIND); X(BINDSTATUS_RAWMIMETYPE); X(BINDSTATUS_PROXYDETECTING); X(BINDSTATUS_ACCEPTRANGES); X(BINDSTATUS_COOKIE_SENT); X(BINDSTATUS_COMPACT_POLICY_RECEIVED); X(BINDSTATUS_COOKIE_SUPPRESSED); X(BINDSTATUS_COOKIE_STATE_UNKNOWN); X(BINDSTATUS_COOKIE_STATE_ACCEPT); X(BINDSTATUS_COOKIE_STATE_REJECT); X(BINDSTATUS_COOKIE_STATE_PROMPT); X(BINDSTATUS_COOKIE_STATE_LEASH); X(BINDSTATUS_COOKIE_STATE_DOWNGRADE); X(BINDSTATUS_POLICY_HREF); X(BINDSTATUS_P3P_HEADER); X(BINDSTATUS_SESSION_COOKIE_RECEIVED); X(BINDSTATUS_PERSISTENT_COOKIE_RECEIVED); X(BINDSTATUS_SESSION_COOKIES_ALLOWED); X(BINDSTATUS_CACHECONTROL); X(BINDSTATUS_CONTENTDISPOSITIONFILENAME); X(BINDSTATUS_MIMETEXTPLAINMISMATCH); X(BINDSTATUS_PUBLISHERAVAILABLE); X(BINDSTATUS_DISPLAYNAMEAVAILABLE); #undef X default: return wine_dbg_sprintf("(invalid status %u)", status); } }
const char *debugstr_variant(const VARIANT *v) { if(!v) return "(null)"; switch(V_VT(v)) { case VT_EMPTY: return "{VT_EMPTY}"; case VT_NULL: return "{VT_NULL}"; case VT_I1: return wine_dbg_sprintf("{VT_I1: %d}", V_I1(v)); case VT_I2: return wine_dbg_sprintf("{VT_I2: %d}", V_I2(v)); case VT_I4: return wine_dbg_sprintf("{VT_I4: %d}", V_I4(v)); case VT_INT: return wine_dbg_sprintf("{VT_INT: %d}", V_INT(v)); case VT_R8: return wine_dbg_sprintf("{VT_R8: %lf}", V_R8(v)); case VT_BSTR: return wine_dbg_sprintf("{VT_BSTR: %s}", debugstr_w(V_BSTR(v))); case VT_DISPATCH: return wine_dbg_sprintf("{VT_DISPATCH: %p}", V_DISPATCH(v)); case VT_BOOL: return wine_dbg_sprintf("{VT_BOOL: %x}", V_BOOL(v)); case VT_UNKNOWN: return wine_dbg_sprintf("{VT_UNKNOWN: %p}", V_UNKNOWN(v)); case VT_UINT: return wine_dbg_sprintf("{VT_UINT: %u}", V_UINT(v)); case VT_BSTR|VT_BYREF: return wine_dbg_sprintf("{VT_BSTR|VT_BYREF: ptr %p, data %s}", V_BSTRREF(v), debugstr_w(V_BSTRREF(v) ? *V_BSTRREF(v) : NULL)); case VT_ERROR: return wine_dbg_sprintf("{VT_ERROR: 0x%08x}", V_ERROR(v)); case VT_VARIANT|VT_BYREF: return wine_dbg_sprintf("{VT_VARIANT|VT_BYREF: %s}", debugstr_variant(V_VARIANTREF(v))); case VT_UI1|VT_ARRAY: return "{VT_UI1|VT_ARRAY}"; default: return wine_dbg_sprintf("{vt %d}", V_VT(v)); } }
static inline const char *wine_dbgstr_fcc( DWORD fcc ) { return wine_dbg_sprintf("%c%c%c%c", LOBYTE(LOWORD(fcc)), HIBYTE(LOWORD(fcc)), LOBYTE(HIWORD(fcc)), HIBYTE(HIWORD(fcc))); }
const char *debugstr_jsstr(jsstr_t *str) { return jsstr_is_inline(str) ? debugstr_wn(jsstr_as_inline(str)->buf, jsstr_length(str)) : jsstr_is_heap(str) ? debugstr_wn(jsstr_as_heap(str)->buf, jsstr_length(str)) : wine_dbg_sprintf("%s...", debugstr_jsstr(jsstr_as_rope(str)->left)); }
static const char* debugstr_element(IOHIDElementRef element) { return wine_dbg_sprintf("<IOHIDElement %p type %d usage %u/%u device %p>", element, IOHIDElementGetType(element), IOHIDElementGetUsagePage(element), IOHIDElementGetUsage(element), IOHIDElementGetDevice(element)); }
static const char* debugstr_device(IOHIDDeviceRef device) { return wine_dbg_sprintf("<IOHIDDevice %p product %s>", device, debugstr_cf(IOHIDDeviceGetProperty(device, CFSTR(kIOHIDProductKey)))); }
static void ff_dump_effect(struct ff_effect *effect) { const char *type = "(Unknown)", *length = "INFINITE"; struct ff_envelope *env = NULL; double angle; #define FE(x) case x: type = #x; break switch (effect->type) { FE(FF_RUMBLE); FE(FF_PERIODIC); FE(FF_CONSTANT); FE(FF_SPRING); FE(FF_FRICTION); FE(FF_DAMPER); FE(FF_INERTIA); FE(FF_RAMP); } #undef FE /* rotate so 0 points right */ angle = 360 - ff_effect_direction_to_rad(effect->direction + 0xc000) * 180 / M_PI; if (effect->replay.length) length = wine_dbg_sprintf("%u ms", effect->replay.length); TRACE("type 0x%x %s, id %d, direction 0x%x (source angle %.2f), time length %s, start delay %u ms\n", effect->type, type, effect->id, effect->direction, angle, length, effect->replay.delay); if (effect->trigger.button || effect->trigger.interval) TRACE(" -> trigger button %u, re-trigger interval %u ms\n", effect->trigger.button, effect->trigger.interval); if (effect->type == FF_PERIODIC) { struct ff_periodic_effect *per = &effect->u.periodic; const char *wave = "(Unknown)"; #define FE(x) case x: wave = #x; break switch (per->waveform) { FE(FF_SQUARE); FE(FF_TRIANGLE); FE(FF_SINE); FE(FF_SAW_UP); FE(FF_SAW_DOWN); FE(FF_CUSTOM); } #undef FE angle = ff_effect_direction_to_rad(per->phase) * 180 / M_PI; TRACE(" -> waveform 0x%x %s, period %u ms, magnitude %d, offset %d, phase 0x%x (angle %.2f), custom len %d\n", per->waveform, wave, per->period, per->magnitude, per->offset, per->phase, angle, per->custom_len); env = &per->envelope; } else if (effect->type == FF_CONSTANT) { struct ff_constant_effect *cons = &effect->u.constant; TRACE(" -> level %d\n", cons->level); env = &cons->envelope; } else if (effect->type == FF_RAMP) { struct ff_ramp_effect *ramp = &effect->u.ramp; TRACE(" -> start/end level %d/%d\n", ramp->start_level, ramp->end_level); env = &ramp->envelope; } else if (effect->type == FF_RUMBLE) { struct ff_rumble_effect *rumble = &effect->u.rumble; TRACE(" -> strong/weak magnitude %u/%u\n", rumble->strong_magnitude, rumble->weak_magnitude); } else if (effect->type == FF_SPRING || effect->type == FF_FRICTION || effect->type == FF_DAMPER || effect->type == FF_INERTIA) { struct ff_condition_effect *cond = effect->u.condition; int i; for (i = 0; i < 2; i++) { /* format numbers here to make them align correctly */ TRACE(" -> [%d] right/left saturation %5u/%5u, right/left coefficient %5d/%5d," " deadband %5u, center %5d\n", i, cond[i].right_saturation, cond[i].left_saturation, cond[i].right_coeff, cond[i].left_coeff, cond[i].deadband, cond[i].center); } } if (env) TRACE(" -> envelope attack length(ms)/level %u/%u, fade length(ms)/level %u/%u\n", env->attack_length, env->attack_level, env->fade_length, env->fade_level); }