static void Handle_allParameters
(
le_msg_MessageRef_t _msgRef
)
{
// Get the message buffer pointer
__attribute__((unused)) uint8_t* _msgBufPtr = ((_Message_t*)le_msg_GetPayloadPtr(_msgRef))->buffer;
// Unpack the input parameters from the message
common_EnumExample_t a;
_msgBufPtr = UnpackData( _msgBufPtr, &a, sizeof(common_EnumExample_t) );
size_t dataNumElements;
_msgBufPtr = UnpackData( _msgBufPtr, &dataNumElements, sizeof(size_t) );
uint32_t data[dataNumElements];
_msgBufPtr = UnpackData( _msgBufPtr, data, dataNumElements*sizeof(uint32_t) );
size_t outputNumElements;
_msgBufPtr = UnpackData( _msgBufPtr, &outputNumElements, sizeof(size_t) );
const char* label;
_msgBufPtr = UnpackString( _msgBufPtr, &label );
size_t responseNumElements;
_msgBufPtr = UnpackData( _msgBufPtr, &responseNumElements, sizeof(size_t) );
size_t moreNumElements;
_msgBufPtr = UnpackData( _msgBufPtr, &moreNumElements, sizeof(size_t) );
// Call the function
allParameters ( (ServerCmdRef_t)_msgRef, a, data, dataNumElements, outputNumElements, label, responseNumElements, moreNumElements );
}
value_t IOAction_LoadExternal_2( PREFUNC, value_t action )
{
assert( IsAnIOAction( action ) );
value_t library_path_obj = action->slots[ IOACTION_SLOT_COUNT + 0 ];
value_t function_name_obj = action->slots[ IOACTION_SLOT_COUNT + 1 ];
value_t exception = NULL;
const char *library_path = NULL;
const char *function_name = NULL;
library_path = UnpackString( zone, library_path_obj );
if (!library_path) {
exception = ThrowCStr( zone, "library path is not a string" );
goto error;
}
function_name = UnpackString( zone, function_name_obj );
if (!function_name) {
exception = ThrowCStr( zone, "symbol name is not a string" );
goto error;
}
void *library = dlopen( library_path, RTLD_NOW );
if (!library) {
exception = ThrowCStr( zone, "could not open the library" );
goto error;
}
void *funcptr = dlsym( library, function_name );
if (!funcptr) {
exception = ThrowCStr( zone, "could not load the symbol" );
goto error;
}
struct buffer *out = BUFALLOC( Pointer_function, sizeof(void*) );
memcpy( out->bytes, &funcptr, sizeof(void*) );
return (value_t)out;
error:
if (library_path) free( (void*)library_path );
if (function_name) free( (void*)function_name );
return exception;
}
std::string UnpackString(std::string &s){
int cur_repeat_len = 0;
int num_of_repeatitions = 0;
for(int i = 1; i <= s.size(); ++i){
if(s[i-1] == '{'){
std::string tmp = s.substr(i);
s.replace(i-1, s.size(), UnpackString(tmp));
} else if(s[i-1] == '}'){
num_of_repeatitions = atoi(&s[i]);
cur_repeat_len = i-1;
std::string repeat = RepeatString(s, cur_repeat_len, num_of_repeatitions);
s.replace(0, i+1, repeat);
return s;
}
}
return s;
}
OXSXDataSet
DataSetIO::LoadDataSet(const std::string& filename_){
// Get Data Set
H5::H5File file(filename_, H5F_ACC_RDONLY);
H5::DataSet dataSet = file.openDataSet("observations");
// read meta information
unsigned nObs = 0;
H5::Attribute nameAtt = dataSet.openAttribute("observed_quantities");
H5::Attribute countAtt = dataSet.openAttribute("n_observables");
H5std_string strreadbuf("");
nameAtt.read(nameAtt.getDataType(), strreadbuf);
countAtt.read(countAtt.getDataType(), &nObs);
// Read data out as 1D array
hsize_t nData = 0;
dataSet.getSpace().getSimpleExtentDims(&nData, NULL);
size_t nEntries = nData/nObs;
std::vector<double> flatData(nData, 0);
dataSet.read(&flatData.at(0), H5::PredType::NATIVE_DOUBLE);
assert(nData%nObs == 0); // logic error in writing file (this class!) if assert fails.
// Assemble into an OXSX data set
OXSXDataSet oxsxDataSet;
// Set the variable names
oxsxDataSet.SetObservableNames(UnpackString(strreadbuf, fDelimiter));
// then the data
std::vector<double> oneEventObs(nObs, 0);
for(size_t i = 0; i < nEntries; i++){
for(size_t j = 0; j < nObs; j++)
oneEventObs[j] = flatData.at(i * nObs + j);
oxsxDataSet.AddEntry(EventData(oneEventObs));
}
return oxsxDataSet;
}
int CCrashInfoReader::UnpackCrashDescription(CErrorReportInfo& eri)
{
// This method unpacks crash description data from shared memory.
if(memcmp(m_pCrashDesc->m_uchMagic, "CRD", 3)!=0)
return 1; // Invalid magic word
if(m_pCrashDesc->m_dwCrashRptVer!=CRASHRPT_VER)
return 2; // Invalid CrashRpt version
// Unpack process ID, thread ID and exception pointers address.
m_dwProcessId = m_pCrashDesc->m_dwProcessId;
m_dwThreadId = m_pCrashDesc->m_dwThreadId;
m_pExInfo = m_pCrashDesc->m_pExceptionPtrs;
m_bSendRecentReports = m_pCrashDesc->m_bSendRecentReports;
m_nExceptionType = m_pCrashDesc->m_nExceptionType;
if(m_nExceptionType==CR_SEH_EXCEPTION)
{
m_dwExceptionCode = m_pCrashDesc->m_dwExceptionCode;
}
else if(m_nExceptionType==CR_CPP_SIGFPE)
{
m_uFPESubcode = m_pCrashDesc->m_uFPESubcode;
}
else if(m_nExceptionType==CR_CPP_INVALID_PARAMETER)
{
UnpackString(m_pCrashDesc->m_dwInvParamExprOffs, m_sInvParamExpr);
UnpackString(m_pCrashDesc->m_dwInvParamFunctionOffs, m_sInvParamFunction);
UnpackString(m_pCrashDesc->m_dwInvParamFileOffs, m_sInvParamFile);
m_uInvParamLine = m_pCrashDesc->m_uInvParamLine;
}
// Unpack other info
UnpackString(m_pCrashDesc->m_dwAppNameOffs, eri.m_sAppName);
m_sAppName = eri.m_sAppName;
UnpackString(m_pCrashDesc->m_dwAppVersionOffs, eri.m_sAppVersion);
UnpackString(m_pCrashDesc->m_dwCrashGUIDOffs, eri.m_sCrashGUID);
UnpackString(m_pCrashDesc->m_dwImageNameOffs, eri.m_sImageName);
// Unpack install flags
DWORD dwInstallFlags = m_pCrashDesc->m_dwInstallFlags;
m_bSilentMode = (dwInstallFlags&CR_INST_NO_GUI)!=0;
m_bSendErrorReport = (dwInstallFlags&CR_INST_DONT_SEND_REPORT)==0;
m_bSendMandatory = (dwInstallFlags&CR_INST_SEND_MANDATORY)!=0;
m_bShowAdditionalInfoFields = (dwInstallFlags&CR_INST_SHOW_ADDITIONAL_INFO_FIELDS)!=0;
m_bAllowAttachMoreFiles = (dwInstallFlags&CR_INST_ALLOW_ATTACH_MORE_FILES)!=0;
m_bStoreZIPArchives = (dwInstallFlags&CR_INST_STORE_ZIP_ARCHIVES)!=0;
m_bAppRestart = (dwInstallFlags&CR_INST_APP_RESTART)!=0;
m_bGenerateMinidump = (dwInstallFlags&CR_INST_NO_MINIDUMP)==0;
m_bQueueEnabled = (dwInstallFlags&CR_INST_SEND_QUEUED_REPORTS)!=0;
m_MinidumpType = m_pCrashDesc->m_MinidumpType;
UnpackString(m_pCrashDesc->m_dwRestartCmdLineOffs, m_sRestartCmdLine);
UnpackString(m_pCrashDesc->m_dwUrlOffs, m_sUrl);
UnpackString(m_pCrashDesc->m_dwEmailToOffs, m_sEmailTo);
m_nSmtpPort = m_pCrashDesc->m_nSmtpPort;
UnpackString(m_pCrashDesc->m_dwSmtpProxyServerOffs, m_sSmtpProxyServer);
m_nSmtpProxyPort = m_pCrashDesc->m_nSmtpProxyPort;
UnpackString(m_pCrashDesc->m_dwEmailSubjectOffs, m_sEmailSubject);
UnpackString(m_pCrashDesc->m_dwEmailTextOffs, m_sEmailText);
memcpy(m_uPriorities, m_pCrashDesc->m_uPriorities, sizeof(UINT)*3);
UnpackString(m_pCrashDesc->m_dwPrivacyPolicyURLOffs, m_sPrivacyPolicyURL);
UnpackString(m_pCrashDesc->m_dwLangFileNameOffs, m_sLangFileName);
UnpackString(m_pCrashDesc->m_dwPathToDebugHelpDllOffs, m_sDbgHelpPath);
UnpackString(m_pCrashDesc->m_dwUnsentCrashReportsFolderOffs, m_sUnsentCrashReportsFolder);
m_bAddScreenshot = m_pCrashDesc->m_bAddScreenshot;
m_dwScreenshotFlags = m_pCrashDesc->m_dwScreenshotFlags;
m_nJpegQuality = m_pCrashDesc->m_nJpegQuality;
UnpackString(m_pCrashDesc->m_dwCustomSenderIconOffs, m_sCustomSenderIcon);
UnpackString(m_pCrashDesc->m_dwSmtpLoginOffs, m_sSmtpLogin);
UnpackString(m_pCrashDesc->m_dwSmtpPasswordOffs, m_sSmtpPassword);
m_bAddVideo = m_pCrashDesc->m_bAddVideo;
m_dwVideoFlags = m_pCrashDesc->m_dwVideoFlags;
m_nVideoDuration = m_pCrashDesc->m_nVideoDuration;
m_nVideoFrameInterval = m_pCrashDesc->m_nVideoFrameInterval;
m_DesiredFrameSize = m_pCrashDesc->m_DesiredFrameSize;
m_hWndVideoParent = m_pCrashDesc->m_hWndVideoParent;
m_bDetectDeadlocks = m_pCrashDesc->m_bDetectDeadlocks;
m_bClientAppCrashed = m_pCrashDesc->m_bClientAppCrashed;
DWORD dwOffs = m_pCrashDesc->m_wSize;
while(dwOffs<m_pCrashDesc->m_dwTotalSize)
{
LPBYTE pView = m_SharedMem.CreateView(dwOffs, sizeof(GENERIC_HEADER));
GENERIC_HEADER* pHeader = (GENERIC_HEADER*)pView;
if(memcmp(pHeader->m_uchMagic, "FIL", 3)==0)
{
// File item entry
FILE_ITEM* pFileItem = (FILE_ITEM*)m_SharedMem.CreateView(dwOffs, pHeader->m_wSize);
ERIFileItem fi;
UnpackString(pFileItem->m_dwSrcFilePathOffs, fi.m_sSrcFile);
UnpackString(pFileItem->m_dwDstFileNameOffs, fi.m_sDestFile);
UnpackString(pFileItem->m_dwDescriptionOffs, fi.m_sDesc);
fi.m_bMakeCopy = pFileItem->m_bMakeCopy;
fi.m_bAllowDelete = pFileItem->m_bAllowDelete;
eri.m_FileItems[fi.m_sDestFile] = fi;
m_SharedMem.DestroyView((LPBYTE)pFileItem);
}
else if(memcmp(pHeader->m_uchMagic, "CPR",3 )==0)
{
// Custom prop entry
CUSTOM_PROP* pProp = (CUSTOM_PROP*)m_SharedMem.CreateView(dwOffs, pHeader->m_wSize);
CString sName;
CString sValue;
UnpackString(pProp->m_dwNameOffs, sName);
UnpackString(pProp->m_dwValueOffs, sValue);
eri.m_Props[sName] = sValue;
m_SharedMem.DestroyView((LPBYTE)pProp);
}
else if(memcmp(pHeader->m_uchMagic, "REG", 3)==0)
{
// Reg key entry
REG_KEY* pKey = (REG_KEY*)m_SharedMem.CreateView(dwOffs, pHeader->m_wSize);
CString sKeyName;
CString sDstFile;
UnpackString(pKey->m_dwRegKeyNameOffs, sKeyName);
UnpackString(pKey->m_dwDstFileNameOffs, sDstFile);
eri.m_RegKeys[sKeyName] = sDstFile;
m_SharedMem.DestroyView((LPBYTE)pKey);
}
else if(memcmp(pHeader->m_uchMagic, "STR", 3)==0)
{
// Skip string
}
else
{
ATLASSERT(0); // Unknown header
return 1;
}
dwOffs += pHeader->m_wSize;
m_SharedMem.DestroyView(pView);
}
// Perform some integrity checks
if(m_pCrashDesc->m_uFileItems!=eri.m_FileItems.size())
{
ATLASSERT(0);
return 1;
}
if(m_pCrashDesc->m_uCustomProps!=eri.m_Props.size())
{
ATLASSERT(0);
return 1;
}
if(m_pCrashDesc->m_uRegKeyEntries!=eri.m_RegKeys.size())
{
ATLASSERT(0);
return 1;
}
// Success
return 0;
}
static void Handle_AddBugTestHandler
(
le_msg_MessageRef_t _msgRef
)
{
// Get the message buffer pointer
uint8_t* _msgBufPtr = ((_Message_t*)le_msg_GetPayloadPtr(_msgRef))->buffer;
// Needed if we are returning a result or output values
uint8_t* _msgBufStartPtr = _msgBufPtr;
// Unpack the input parameters from the message
char newPathPtr[513];
_msgBufPtr = UnpackString( _msgBufPtr, newPathPtr, 513 );
void* contextPtr;
_msgBufPtr = UnpackData( _msgBufPtr, &contextPtr, sizeof(void*) );
// Create a new server data object and fill it in
_ServerData_t* serverDataPtr = le_mem_ForceAlloc(_ServerDataPool);
serverDataPtr->clientSessionRef = le_msg_GetSession(_msgRef);
serverDataPtr->contextPtr = contextPtr;
serverDataPtr->handlerRef = NULL;
serverDataPtr->removeHandlerFunc = NULL;
contextPtr = serverDataPtr;
// Define storage for output parameters
// Call the function
BugTestHandlerRef_t _result;
_result = AddBugTestHandler ( newPathPtr, AsyncResponse_AddBugTestHandler, contextPtr );
// Put the handler reference result and a pointer to the associated remove function
// into the server data object. This function pointer is needed in case the client
// is closed and the handlers need to be removed.
serverDataPtr->handlerRef = (le_event_HandlerRef_t)_result;
serverDataPtr->removeHandlerFunc = (RemoveHandlerFunc_t)RemoveBugTestHandler;
// Return a safe reference to the server data object as the reference.
_LOCK
_result = le_ref_CreateRef(_HandlerRefMap, serverDataPtr);
_UNLOCK
// Re-use the message buffer for the response
_msgBufPtr = _msgBufStartPtr;
// Pack the result first
_msgBufPtr = PackData( _msgBufPtr, &_result, sizeof(_result) );
// Pack any "out" parameters
// Return the response
LE_DEBUG("Sending response to client session %p : %ti bytes sent",
le_msg_GetSession(_msgRef),
_msgBufPtr-_msgBufStartPtr);
le_msg_Respond(_msgRef);
}
static void Handle_allParameters
(
le_msg_MessageRef_t _msgRef
)
{
// Get the message buffer pointer
uint8_t* _msgBufPtr = ((_Message_t*)le_msg_GetPayloadPtr(_msgRef))->buffer;
// Needed if we are returning a result or output values
uint8_t* _msgBufStartPtr = _msgBufPtr;
// Unpack the input parameters from the message
common_EnumExample_t a;
_msgBufPtr = UnpackData( _msgBufPtr, &a, sizeof(common_EnumExample_t) );
size_t dataNumElements;
_msgBufPtr = UnpackData( _msgBufPtr, &dataNumElements, sizeof(size_t) );
uint32_t data[dataNumElements];
_msgBufPtr = UnpackData( _msgBufPtr, data, dataNumElements*sizeof(uint32_t) );
size_t outputNumElements;
_msgBufPtr = UnpackData( _msgBufPtr, &outputNumElements, sizeof(size_t) );
if ( outputNumElements > 10 )
{
LE_DEBUG("Adjusting outputNumElements from %zd to 10", outputNumElements);
outputNumElements = 10;
}
char label[21];
_msgBufPtr = UnpackString( _msgBufPtr, label, 21 );
size_t responseNumElements;
_msgBufPtr = UnpackData( _msgBufPtr, &responseNumElements, sizeof(size_t) );
size_t moreNumElements;
_msgBufPtr = UnpackData( _msgBufPtr, &moreNumElements, sizeof(size_t) );
// Define storage for output parameters
uint32_t b;
uint32_t output[outputNumElements];
char response[responseNumElements]; response[0]=0;
char more[moreNumElements]; more[0]=0;
// Call the function
allParameters ( a, &b, data, dataNumElements, output, &outputNumElements, label, response, responseNumElements, more, moreNumElements );
// Re-use the message buffer for the response
_msgBufPtr = _msgBufStartPtr;
// Pack any "out" parameters
_msgBufPtr = PackData( _msgBufPtr, &b, sizeof(uint32_t) );
_msgBufPtr = PackData( _msgBufPtr, &outputNumElements, sizeof(size_t) );
_msgBufPtr = PackData( _msgBufPtr, output, outputNumElements*sizeof(uint32_t) );
_msgBufPtr = PackString( _msgBufPtr, response );
_msgBufPtr = PackString( _msgBufPtr, more );
// Return the response
LE_DEBUG("Sending response to client session %p : %ti bytes sent",
le_msg_GetSession(_msgRef),
_msgBufPtr-_msgBufStartPtr);
le_msg_Respond(_msgRef);
}
/*ARGSUSED*/
void
_WSMUnpackReply(Display *dpy, int screen_num, MessageData data,
unsigned long len, WSMRequestType type, WSMReply *reply)
{
register int i;
reply->any.type = type; /* Save the type. */
reply->any.allocated = False;
switch (reply->any.type) {
case WSM_CONNECT:
if (data != NULL)
reply->connect.version = (short) UnpackCARD8(&data);
else
fprintf(stderr, "Error - Connection request reply data is empty!\n");
break;
case WSM_EXTENSIONS:
{
register int num;
register String *ptr;
num = reply->extensions.num_extensions = UnpackListNum(&data);
ptr = (String *) XtMalloc(sizeof(String) * num);
reply->extensions.allocated = True;
reply->extensions.extensions = ptr;
for (i = 0; i < num; i++, ptr++)
*ptr = UnpackString(&data);
}
break;
case WSM_CONFIG_FMT:
{
register int types;
WSMConfigFormatReply * config_format = &(reply->config_format);
WSMConfigFormatData *fmt;
WSMScreenInfo *scr_info = _WSMGetScreenInfo(dpy, screen_num);
config_format->accepts_diffs = UnpackBoolean(&data);
for (types = 0; types < 3; types++) {
switch(types) {
case WSM_GLOBAL_FMT:
fmt = &(scr_info->global);
break;
case WSM_WINDOW_FMT:
fmt = &(scr_info->window);
break;
case WSM_ICON_FMT:
fmt = &(scr_info->icon);
break;
}
fmt->num_attrs = UnpackListNum(&data);
fmt->attr_list = (WSMAttribute *)
XtMalloc(sizeof(WSMAttribute) * fmt->num_attrs);
for (i = 0; i < fmt->num_attrs; i++) {
String str = UnpackString(&data);
fmt->attr_list[i].nameq = XrmStringToQuark(str);
XtFree(str);
fmt->attr_list[i].size = UnpackCARD8(&data);
fmt->attr_list[i].is_list = UnpackCARD8(&data);
}
}
/*
* No need to allocate this, since they are just pointers
* back to global data.
*/
config_format->global_formats = scr_info->global.attr_list;
config_format->num_global_formats = scr_info->global.num_attrs;
config_format->window_formats = scr_info->window.attr_list;
config_format->num_window_formats = scr_info->window.num_attrs;
config_format->icon_formats = scr_info->icon.attr_list;
config_format->num_icon_formats = scr_info->icon.num_attrs;
}
break;
case WSM_GET_STATE:
{
int num =reply->get_state.num_win_info_list = UnpackListNum(&data);
reply->get_state.win_info_list =
(WSMWinInfo *) XtMalloc(sizeof(WSMWinInfo) * num);
reply->get_state.allocated = True;
for (i = 0; i < num; i++)
UnpackWinInfo(&data, dpy, screen_num,
reply->get_state.win_info_list + i);
}
break;
case WSM_SET_STATE:
break;
case WSM_REG_WINDOW:
if (data != NULL)
{
UnpackWinData(&data, dpy, screen_num, WSM_WINDOW_FMT,
&(reply->register_window.window_data),
&(reply->register_window.num_window_data));
reply->register_window.allocated = True;
}
else
fprintf(stderr, "Error - Register Window reply data is empty!\n");
break;
case WSM_WM_GET_BACKGROUND_WINDOW:
reply->get_background.window = UnpackWindow(&data);
break;
case WSM_WM_SET_BACKGROUND_WINDOW:
reply->set_background.window = UnpackWindow(&data);
break;
case WSM_WM_WINDOWS:
{
int num;
num = reply->wm_windows.num_win_entry_list = UnpackListNum(&data);
reply->wm_windows.win_entry_list =
(WSMWinEntry *) XtMalloc(sizeof(WSMWinEntry) * num);
reply->wm_windows.allocated = True;
for (i = 0; i < num; i++)
UnpackWinEntry(&data, dpy, screen_num,
reply->wm_windows.win_entry_list + i);
}
break;
case WSM_WM_FOCUS:
reply->wm_focus.window = UnpackWindow(&data);
break;
case WSM_WM_POINTER:
reply->wm_pointer.location_flag = UnpackCARD32(&data);
break;
default:
break;
}
} /* _WSMUnpackReply */
/*ARGSUSED*/
void
_WSMUnpackRequest(Display *dpy, int screen_num, MessageData data,
unsigned long len, WSMRequestType type, WSMRequest *request)
{
register int i;
request->any.type = type; /* Save the type. */
request->any.allocated = False;
switch (request->any.type) {
case WSM_CONNECT:
request->connect.num_versions = UnpackListNum(&data);
request->connect.known_versions =
(short *) XtMalloc(sizeof(short) * request->connect.num_versions);
request->connect.allocated = True;
for (i = 0; i < request->connect.num_versions; i++)
request->connect.known_versions[i] = (short) UnpackCARD8(&data);
break;
case WSM_EXTENSIONS:
{
register int num;
register String *ptr;
num = request->extensions.num_extensions = UnpackListNum(&data);
ptr = (String *) XtMalloc(sizeof(String) * num);
request->extensions.extension_suggestions = ptr;
request->extensions.allocated = True;
for (i = 0; i < num; i++, ptr++)
*ptr = UnpackString(&data);
}
break;
case WSM_CONFIG_FMT:
break;
case WSM_GET_STATE:
request->get_state.window = UnpackWindow(&data);
request->get_state.diffs_allowed = UnpackBoolean(&data);
break;
case WSM_SET_STATE:
{
int num = UnpackListNum(&data);
request->set_state.num_win_info_list = num;
request->set_state.win_info_list =
(WSMWinInfo *) XtMalloc(sizeof(WSMWinInfo) * num);
request->extensions.allocated = True;
for (i = 0; i < num; i++) {
UnpackWinInfo(&data, dpy, screen_num,
request->set_state.win_info_list + i);
}
}
break;
case WSM_REG_WINDOW:
request->register_window.window = UnpackWindow(&data);
break;
case WSM_WM_GET_BACKGROUND_WINDOW:
request->get_background.screen = (int)UnpackCARD16(&data);
break;
case WSM_WM_SET_BACKGROUND_WINDOW:
request->set_background.window = UnpackWindow(&data);
break;
case WSM_WM_WINDOWS:
{
int num, i, j;
request->extensions.allocated = True;
request->wm_windows.location_flag = UnpackCARD32(&data);
num = request->wm_windows.num_window_properties = UnpackListNum(&data);
request->wm_windows.window_properties =
(WindowProperty *) XtMalloc(sizeof(WindowProperty) * num);
for (i=0; i<num; i++)
request->wm_windows.window_properties[i] = UnpackProperty(&data);
num = request->wm_windows.num_match_attributes = UnpackListNum(&data);
request->wm_windows.match_attributes =
(AttributePair **) XtMalloc(sizeof(AttributePair*) * num);
for (i=0; i<request->wm_windows.num_match_attributes; i++)
{
num = UnpackListNum(&data);
request->wm_windows.match_attributes[i] = (AttributePair *)
XtMalloc(sizeof(AttributePair) * num * 2 + sizeof(int));
request->wm_windows.match_attributes[i]->num_attributes = num;
for (j=0; j<num; j++)
{
request->wm_windows.match_attributes[i]->allowed_attributes[j] =
UnpackProperty(&data);
}
for (j=0; j<num; j++)
{
request->wm_windows.match_attributes[i]->prohibited_attributes[j] =
UnpackProperty(&data);
}
}
}
break;
case WSM_WM_FOCUS:
break;
case WSM_WM_POINTER:
break;
default:
break;
}
} /* _WSMUnpackRequest */