int Check_Error (int error)
{
switch (error)
{
case HAPPY:
return HAPPY;
CASE_ERR (NODE_TYPE_NULL);
CASE_ERR (NODE_LEFT);
CASE_ERR (NODE_RIGHT);
CASE_ERR (NODE_PREV);
CASE_ERR (CLOSE_BRACKET_OUT);
CASE_ERR (OPEN_BRACKET_OUT);
CASE_ERR (CLOSE_BRACKET_IN);
CASE_ERR (OPEN_BRACKET_IN);
default:
fprintf (THE_LOG, "\n\nUnknown Error");
printf ("\n\nUnknown Error");
abort();
break;
}
return HAPPY;
}
clqmcStatus clqmcSetErrorString(cl_int err, const char* msg, ...)
{
char formatted[1024];
const char* base;
switch (err) {
CASE_ERR(SUCCESS);
CASE_ERR(OUT_OF_RESOURCES);
CASE_ERR(INVALID_VALUE);
CASE_ERR(INVALID_ENVIRONMENT);
CASE_ERR(NOT_IMPLEMENTED);
default: base = MSG_DEFAULT;
}
va_list args;
va_start(args, msg);
vsprintf(formatted, msg, args);
sprintf(clqmcErrorString, "[%s] %s", base, formatted);
va_end(args);
return (clqmcStatus) err;
}
char const* get_gl_err_msg(GLuint x) {
#define CASE_ERR(X) case X: return #X
switch(x) {
CASE_ERR(GL_NO_ERROR);
CASE_ERR(GL_INVALID_ENUM);
CASE_ERR(GL_INVALID_VALUE);
CASE_ERR(GL_INVALID_OPERATION);
CASE_ERR(GL_INVALID_FRAMEBUFFER_OPERATION);
CASE_ERR(GL_OUT_OF_MEMORY);
CASE_ERR(GL_STACK_UNDERFLOW);
CASE_ERR(GL_STACK_OVERFLOW);
}
#undef CASE_ERR
return "unknown opengl error code";
}
void CreateInst(HTREEITEM item, WCHAR *wszMachineName)
{
TVITEMW tvi;
HTREEITEM hCur;
TVINSERTSTRUCTW tvis;
WCHAR wszTitle[MAX_LOAD_STRING];
WCHAR wszMessage[MAX_LOAD_STRING];
WCHAR wszFlagName[MAX_LOAD_STRING];
WCHAR wszTreeName[MAX_LOAD_STRING];
WCHAR wszRegPath[MAX_LOAD_STRING];
const WCHAR wszFormat[] = { '\n','%','s',' ','(','$','%','x',')','\n','\0' };
CLSID clsid;
COSERVERINFO remoteInfo;
MULTI_QI qi;
IUnknown *obj, *unk;
HRESULT hRes;
memset(&tvi, 0, sizeof(TVITEMW));
tvi.mask = TVIF_TEXT;
tvi.hItem = item;
tvi.cchTextMax = MAX_LOAD_STRING;
tvi.pszText = wszTreeName;
memset(&tvis, 0, sizeof(TVINSERTSTRUCTW));
U(tvis).item.mask = TVIF_TEXT|TVIF_PARAM;
U(tvis).item.cchTextMax = MAX_LOAD_STRING;
tvis.hInsertAfter = TVI_FIRST;
U(tvis).item.pszText = tvi.pszText;
tvis.hParent = item;
tvis.hInsertAfter = TVI_LAST;
if (!SendMessageW(globals.hTree, TVM_GETITEMW, 0, (LPARAM)&tvi)) return;
if(!tvi.lParam || ((ITEM_INFO *)tvi.lParam)->loaded
|| !(((ITEM_INFO *)tvi.lParam)->cFlag&SHOWALL)) return;
if(FAILED(CLSIDFromString(((ITEM_INFO *)tvi.lParam)->clsid, &clsid))) return;
if(wszMachineName)
{
remoteInfo.dwReserved1 = 0;
remoteInfo.dwReserved2 = 0;
remoteInfo.pAuthInfo = NULL;
remoteInfo.pwszName = wszMachineName;
qi.pIID = &IID_IUnknown;
CoCreateInstanceEx(&clsid, NULL, globals.dwClsCtx|CLSCTX_REMOTE_SERVER,
&remoteInfo, 1, &qi);
hRes = qi.hr;
obj = qi.pItf;
}
else hRes = CoCreateInstance(&clsid, NULL, globals.dwClsCtx,
&IID_IUnknown, (void **)&obj);
if(FAILED(hRes))
{
LoadStringW(globals.hMainInst, IDS_CGCOFAIL, wszMessage,
sizeof(wszMessage)/sizeof(wszMessage[0]));
LoadStringW(globals.hMainInst, IDS_ABOUT, wszTitle,
sizeof(wszTitle)/sizeof(wszTitle[0]));
#define CASE_ERR(i) case i: \
MultiByteToWideChar(CP_ACP, 0, #i, -1, wszFlagName, MAX_LOAD_STRING); \
break
switch(hRes)
{
CASE_ERR(REGDB_E_CLASSNOTREG);
CASE_ERR(E_NOINTERFACE);
CASE_ERR(REGDB_E_READREGDB);
CASE_ERR(REGDB_E_KEYMISSING);
CASE_ERR(CO_E_DLLNOTFOUND);
CASE_ERR(CO_E_APPNOTFOUND);
CASE_ERR(E_ACCESSDENIED);
CASE_ERR(CO_E_ERRORINDLL);
CASE_ERR(CO_E_APPDIDNTREG);
CASE_ERR(CLASS_E_CLASSNOTAVAILABLE);
default:
LoadStringW(globals.hMainInst, IDS_ERROR_UNKN, wszFlagName, sizeof(wszFlagName)/sizeof(wszFlagName[0]));
}
wsprintfW(&wszMessage[lstrlenW(wszMessage)], wszFormat,
wszFlagName, (unsigned)hRes);
MessageBoxW(globals.hMainWnd, wszMessage, wszTitle, MB_OK|MB_ICONEXCLAMATION);
return;
}
((ITEM_INFO *)tvi.lParam)->loaded = 1;
((ITEM_INFO *)tvi.lParam)->pU = obj;
tvi.mask = TVIF_STATE;
tvi.state = TVIS_BOLD;
tvi.stateMask = TVIS_BOLD;
SendMessageW(globals.hTree, TVM_SETITEMW, 0, (LPARAM)&tvi);
tvi.mask = TVIF_TEXT;
hCur = (HTREEITEM)SendMessageW(globals.hTree, TVM_GETNEXTITEM,
TVGN_CHILD, (LPARAM)tree.hI);
while(hCur)
{
tvi.hItem = hCur;
if(!SendMessageW(globals.hTree, TVM_GETITEMW, 0, (LPARAM)&tvi) || !tvi.lParam)
{
hCur = (HTREEITEM)SendMessageW(globals.hTree, TVM_GETNEXTITEM,
TVGN_NEXT, (LPARAM)hCur);
continue;
}
CLSIDFromString(((ITEM_INFO *)tvi.lParam)->clsid, &clsid);
hRes = IUnknown_QueryInterface(obj, &clsid, (void *)&unk);
if(SUCCEEDED(hRes))
{
IUnknown_Release(unk);
lstrcpyW(wszRegPath, wszInterface);
lstrcpyW(&wszRegPath[lstrlenW(wszRegPath)], ((ITEM_INFO *)tvi.lParam)->clsid);
U(tvis).item.lParam = CreateITEM_INFO(REGTOP|INTERFACE|REGPATH,
wszRegPath, ((ITEM_INFO *)tvi.lParam)->clsid, NULL);
SendMessageW(globals.hTree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
}
hCur = (HTREEITEM)SendMessageW(globals.hTree, TVM_GETNEXTITEM,
TVGN_NEXT, (LPARAM)hCur);
}
RefreshMenu(item);
RefreshDetails(item);
}
const char * clUtilErrorString(cl_int error)
{
switch(error) {
CASE_ERR(CL_DEVICE_NOT_AVAILABLE);
CASE_ERR(CL_DEVICE_NOT_FOUND);
CASE_ERR(CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST);
CASE_ERR(CL_INVALID_ARG_INDEX);
CASE_ERR(CL_INVALID_ARG_SIZE);
CASE_ERR(CL_INVALID_ARG_VALUE);
CASE_ERR(CL_INVALID_BUFFER_SIZE);
CASE_ERR(CL_INVALID_COMMAND_QUEUE);
CASE_ERR(CL_INVALID_CONTEXT);
CASE_ERR(CL_INVALID_DEVICE);
CASE_ERR(CL_INVALID_DEVICE_TYPE);
CASE_ERR(CL_INVALID_EVENT_WAIT_LIST);
CASE_ERR(CL_INVALID_GLOBAL_OFFSET);
CASE_ERR(CL_INVALID_GLOBAL_WORK_SIZE);
CASE_ERR(CL_INVALID_HOST_PTR);
CASE_ERR(CL_INVALID_IMAGE_SIZE);
CASE_ERR(CL_INVALID_KERNEL);
CASE_ERR(CL_INVALID_KERNEL_ARGS);
CASE_ERR(CL_INVALID_KERNEL_DEFINITION);
CASE_ERR(CL_INVALID_KERNEL_NAME);
CASE_ERR(CL_INVALID_MEM_OBJECT);
CASE_ERR(CL_INVALID_OPERATION);
CASE_ERR(CL_INVALID_PLATFORM);
CASE_ERR(CL_INVALID_PROGRAM);
CASE_ERR(CL_INVALID_PROGRAM_EXECUTABLE);
CASE_ERR(CL_INVALID_PROPERTY);
CASE_ERR(CL_INVALID_SAMPLER);
CASE_ERR(CL_INVALID_VALUE);
CASE_ERR(CL_INVALID_WORK_DIMENSION);
CASE_ERR(CL_INVALID_WORK_GROUP_SIZE);
CASE_ERR(CL_INVALID_WORK_ITEM_SIZE);
CASE_ERR(CL_MEM_OBJECT_ALLOCATION_FAILURE);
CASE_ERR(CL_MISALIGNED_SUB_BUFFER_OFFSET);
CASE_ERR(CL_OUT_OF_HOST_MEMORY);
CASE_ERR(CL_OUT_OF_RESOURCES);
CASE_ERR(CL_SUCCESS);
}
}
