static void mpSubdivide( mpPriorityQueue* pq, mpSweepEvent* a1, mpSweepEvent* a2, const mpPoint* intersection ) { printf("Subdivide\n"); // Creating segment a1 <-> intersectionPoint mpSweepEvent* interEvent = (mpSweepEvent*)malloc(sizeof(mpSweepEvent)); interEvent->m_Point = *intersection; interEvent->m_Other = a1; interEvent->m_Left = 0; interEvent->m_Polygon = a1->m_Polygon; a1->m_Other = interEvent; mpPushPQ(pq,interEvent); printf("---\n"); PrintEvent(a1); PrintEvent(interEvent); printf("---\n"); // Creating segment intersectionPoint <-> a2 interEvent = (mpSweepEvent*)malloc(sizeof(mpSweepEvent)); interEvent->m_Point = *intersection; interEvent->m_Other = a2; interEvent->m_Left = 1; interEvent->m_Polygon = a2->m_Polygon; a2->m_Other = interEvent; mpPushPQ(pq,interEvent); printf("---\n"); PrintEvent(interEvent); PrintEvent(a2); printf("---\n"); }
int getJavaStartCommand(char *scriptFile) { HANDLE hChildStdoutRd, hChildStdoutWr, hChildStdoutRdDup; SECURITY_ATTRIBUTES saAttr; BOOL fSuccess; //DebugBreak(); // Set the bInheritHandle flag so pipe handles are inherited. saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); saAttr.bInheritHandle = TRUE; saAttr.lpSecurityDescriptor = NULL; // The steps for redirecting child process's STDOUT: // 1. Create anonymous pipe to be STDOUT for child process. // 2. Create a noninheritable duplicate of the read handle and // close the inheritable read handle. // 3. Set STDOUT for child process // Create a pipe to be used for the child process's STDOUT. if (! CreatePipe(&hChildStdoutRd, &hChildStdoutWr, &saAttr, 0)) errorExit("Stdout pipe creation failed"); // Create noninheritable read handle and close the inheritable read // handle. fSuccess = DuplicateHandle(GetCurrentProcess(), hChildStdoutRd, GetCurrentProcess(), &hChildStdoutRdDup , 0, FALSE, DUPLICATE_SAME_ACCESS); if(!fSuccess) { PrintEvent(_T("DuplicateHandle failed")); errorExit("DuplicateHandle failed"); } CloseHandle(hChildStdoutRd); // // Now create the child process. fSuccess = createChildProcess(scriptFile, hChildStdoutWr); if (!fSuccess) { PrintEvent(_T("Could not create process!!")); errorExit("Create process failed"); } //PrintEvent(_T("Created Child Process Successfully")); // Close the write end of the pipe before reading from the // read end of the pipe. if (!CloseHandle(hChildStdoutWr)) errorExit("Closing handle failed"); // Read from pipe that is the standard output for child process. readFromPipe(hChildStdoutRdDup); return 0; }
void CommonEvent(CommonState * state, SDL_Event * event, int *done) { if (state->verbose & VERBOSE_EVENT) { PrintEvent(event); } switch (event->type) { case SDL_WINDOWEVENT: switch (event->window.event) { case SDL_WINDOWEVENT_CLOSE: *done = 1; break; } break; case SDL_KEYDOWN: switch (event->key.keysym.sym) { /* Add hotkeys here */ case SDLK_g: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-G toggle grab */ } break; case SDLK_ESCAPE: *done = 1; break; default: break; } break; case SDL_QUIT: *done = 1; break; } }
void CEventLog::FireGameEvent( IGameEvent *event ) { if ( !g_bIsLogging ) return; PrintEvent ( event ); }
BOOL createChildProcess(char *scriptFile, HANDLE *hChildStdoutWr) { PROCESS_INFORMATION piProcInfo; STARTUPINFO siStartInfo; BOOL bFuncRetn = FALSE; //DebugBreak(); // Set up members of the PROCESS_INFORMATION structure. ZeroMemory( &piProcInfo, sizeof(PROCESS_INFORMATION) ); // Set up members of the STARTUPINFO structure. ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) ); siStartInfo.cb = sizeof(STARTUPINFO); siStartInfo.dwFlags = STARTF_USESTDHANDLES; siStartInfo.hStdInput = 0; siStartInfo.hStdOutput = hChildStdoutWr; siStartInfo.hStdError = hChildStdoutWr; PrintEvent(_T(scriptFile)); // Create the child process. bFuncRetn = CreateProcess(NULL, scriptFile, // command line NULL, // process security attributes NULL, // primary thread security attributes TRUE, // handles are inherited 0, // no creation flags NULL, // use parent's environment NULL, // use parent's current directory &siStartInfo, // STARTUPINFO pointer &piProcInfo); // receives PROCESS_INFORMATION if (bFuncRetn == 0) { ErrorPrinter(_T("Could Not Create Process"), GetLastError()); errorExit("CreateProcess failed"); return 0; } else { CloseHandle(piProcInfo.hProcess); CloseHandle(piProcInfo.hThread); return bFuncRetn; } }
void OSWindow::pushEvent(Event event) { switch (event.Type) { case Event::EVENT_MOVED: mX = event.Move.X; mY = event.Move.Y; break; case Event::EVENT_RESIZED: mWidth = event.Size.Width; mHeight = event.Size.Height; break; default: break; } mEvents.push_back(event); #if DEBUG_EVENTS PrintEvent(event); #endif }
/** * @brief Enumerate all the events in the result set. * @param results The handle to a query or subscription result set that * the EvtQuery function or the EvtSubscribe function returns. * * @return returns Status code. */ DWORD EventLogReader::PrintResults(EVT_HANDLE results) { DWORD status = ERROR_SUCCESS; static const int ArraySize = 10; DWORD returned = 0; EVT_HANDLE events[ArraySize] = { 0 }; bool run = true; while (run) { // Get a block of events from the result set. if (!EvtNext(results, ArraySize, events, INFINITE, 0, &returned)) break; // For each event, call the PrintEvent function which renders the // event for display. PrintEvent is shown in RenderingEvents. for (DWORD i = 0; i < returned; i++) { _position++; status = PrintEvent(events[i]); if (status == ERROR_SUCCESS) { EvtClose(events[i]); events[i] = nullptr; } else { run = false; break; } } } for (DWORD i = 0; i < returned; i++) { if (events[i] != nullptr) EvtClose(events[i]); } return status; }
static void mpSubdivide3( mpPriorityQueue* pq, mpSweepEvent* a1, mpSweepEvent* a2, mpSweepEvent* b1, mpSweepEvent* b2 ) { printf("Subdivide in 3\n"); // Creating segment a1 <-> intersectionPoint mpSweepEvent* interEvent = (mpSweepEvent*)malloc(sizeof(mpSweepEvent)); interEvent->m_Point = b1->m_Point; interEvent->m_Other = a1; interEvent->m_Left = 0; interEvent->m_Polygon = a1->m_Polygon; a1->m_Other = interEvent; mpPushPQ(pq,interEvent); printf("---\n"); PrintEvent(a1); PrintEvent(interEvent); printf("---\n"); // Creating segment b1 <-> a2 b1->m_Other = a2; a2->m_Other = b1; a2->m_Polygon = b1->m_Polygon; printf("---\n"); PrintEvent(b1); PrintEvent(a2); printf("---\n"); // Creating segment intersectionPoint <-> b2 interEvent = (mpSweepEvent*)malloc(sizeof(mpSweepEvent)); interEvent->m_Point = a2->m_Point; interEvent->m_Other = b2; interEvent->m_Left = 1; interEvent->m_Polygon = b2->m_Polygon; b2->m_Other = interEvent; mpPushPQ(pq,interEvent); printf("---\n"); PrintEvent(interEvent); PrintEvent(b2); printf("---\n"); }
void CommonEvent(CommonState * state, SDL_Event * event, int *done) { int i; if (state->verbose & VERBOSE_EVENT) { PrintEvent(event); } switch (event->type) { case SDL_WINDOWEVENT: switch (event->window.event) { case SDL_WINDOWEVENT_CLOSE: { SDL_Window *window = SDL_GetWindowFromID(event->window.windowID); if (window) { SDL_DestroyWindow(window); } } break; } break; case SDL_KEYDOWN: switch (event->key.keysym.sym) { /* Add hotkeys here */ case SDLK_PRINTSCREEN: { SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { for (i = 0; i < state->num_windows; ++i) { if (window == state->windows[i]) { ScreenShot(state->renderers[i]); } } } } break; case SDLK_c: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-C copy awesome text! */ SDL_SetClipboardText("SDL rocks!\nYou know it!"); printf("Copied text to clipboard\n"); } break; case SDLK_v: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-V paste awesome text! */ char *text = SDL_GetClipboardText(); if (*text) { printf("Clipboard: %s\n", text); } else { printf("Clipboard is empty\n"); } SDL_free(text); } break; case SDLK_g: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-G toggle grab */ SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { SDL_SetWindowGrab(window, !SDL_GetWindowGrab(window)); } } break; case SDLK_m: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-M maximize */ SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { Uint32 flags = SDL_GetWindowFlags(window); if (flags & SDL_WINDOW_MAXIMIZED) { SDL_RestoreWindow(window); } else { SDL_MaximizeWindow(window); } } } break; case SDLK_r: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-R toggle mouse relative mode */ SDL_SetRelativeMouseMode(!SDL_GetRelativeMouseMode()); } break; case SDLK_z: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-Z minimize */ SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { SDL_MinimizeWindow(window); } } break; case SDLK_RETURN: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-Enter toggle fullscreen */ SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); if (window) { Uint32 flags = SDL_GetWindowFlags(window); if (flags & SDL_WINDOW_FULLSCREEN) { SDL_SetWindowFullscreen(window, SDL_FALSE); } else { SDL_SetWindowFullscreen(window, SDL_TRUE); } } } break; case SDLK_ESCAPE: *done = 1; break; default: break; } break; case SDL_QUIT: *done = 1; break; } }
void CEventLog::FireGameEvent( IGameEvent *event ) { PrintEvent ( event ); }
/* Function:Link Server CallBack; INPUT: Upnp_EventType -- EventType; Event -- void*; Cookie -- void*; SUCCESS:1; ERROR:0; */ int SA_CallbackEventHandler( Upnp_EventType EventType, void *Event, void *Cookie ) { PrintEvent( EventType, Event ); switch ( EventType ) { case UPNP_DISCOVERY_ADVERTISEMENT_ALIVE: break; case UPNP_DISCOVERY_SEARCH_RESULT: { struct Upnp_Discovery *d_event = ( struct Upnp_Discovery * )Event; IXML_Document *DescDoc = NULL; int ret; if( d_event->ErrCode != UPNP_E_SUCCESS ) { SA_Print( "Error in Discovery Callback -- %d", d_event->ErrCode ); } if( ( ret = UpnpDownloadXmlDoc( d_event->Location, &DescDoc ) ) != UPNP_E_SUCCESS ) { SA_Print ( "Error obtaining device description from %s -- error = %d", d_event->Location, ret ); } else { DevCtrlPoint_AddDevice( DescDoc, d_event->Location, d_event->Expires ); } if( DescDoc ) ixmlDocument_free( DescDoc ); DevCtrlPoint_PrintList(); break; } case UPNP_DISCOVERY_SEARCH_TIMEOUT: break; case UPNP_DISCOVERY_ADVERTISEMENT_BYEBYE: { struct Upnp_Discovery *d_event = ( struct Upnp_Discovery * )Event; if( d_event->ErrCode != UPNP_E_SUCCESS ) { SA_Print ( "Error in Discovery ByeBye Callback -- %d", d_event->ErrCode ); } SA_Print( "Received ByeBye for Device: %s", d_event->DeviceId ); DevCtrlPoint_RemoveDevice( d_event->DeviceId ); SA_Print( "After byebye:" ); DevCtrlPoint_PrintList(); break; } case UPNP_CONTROL_ACTION_COMPLETE: { struct Upnp_Action_Complete *a_event = ( struct Upnp_Action_Complete * )Event; if( a_event->ErrCode != UPNP_E_SUCCESS ) { SA_Print ( "Error in Action Complete Callback -- %d", a_event->ErrCode ); } break; } case UPNP_EVENT_RECEIVED: { break; } case UPNP_EVENT_SUBSCRIBE_COMPLETE: case UPNP_EVENT_UNSUBSCRIBE_COMPLETE: case UPNP_EVENT_RENEWAL_COMPLETE: { struct Upnp_Event_Subscribe *es_event = ( struct Upnp_Event_Subscribe * )Event; if( es_event->ErrCode != UPNP_E_SUCCESS ) { SA_Print ( "Error in Event Subscribe Callback -- %d", es_event->ErrCode ); } else { DevCtrlPoint_HandleSubscribeUpdate( es_event-> PublisherUrl, es_event->Sid, es_event->TimeOut ); } break; } case UPNP_EVENT_AUTORENEWAL_FAILED: case UPNP_EVENT_SUBSCRIPTION_EXPIRED: { int TimeOut = default_timeout; Upnp_SID newSID; int ret; struct Upnp_Event_Subscribe *es_event = ( struct Upnp_Event_Subscribe * )Event; ret = UpnpSubscribe( ctrlpt_handle, es_event->PublisherUrl, &TimeOut, newSID ); if( ret == UPNP_E_SUCCESS ) { SA_Print( "Subscribed to EventURL with SID=%s", newSID ); DevCtrlPoint_HandleSubscribeUpdate( es_event-> PublisherUrl, newSID, TimeOut ); } else { SA_Print ( "Error Subscribing to EventURL -- %d", ret ); } break; } case UPNP_EVENT_SUBSCRIPTION_REQUEST: case UPNP_CONTROL_ACTION_REQUEST: break; default: break; } return 0; }
void CommonEvent(CommonState * state, SDL_Event * event, int *done) { int i; if (state->verbose & VERBOSE_EVENT) { PrintEvent(event); } switch (event->type) { case SDL_WINDOWEVENT: switch (event->window.event) { case SDL_WINDOWEVENT_CLOSE: *done = 1; break; } break; case SDL_KEYDOWN: switch (event->key.keysym.sym) { /* Add hotkeys here */ case SDLK_c: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-C copy awesome text! */ SDL_SetClipboardText("SDL rocks!\nYou know it!"); printf("Copied text to clipboard\n"); } break; case SDLK_v: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-V paste awesome text! */ char *text = SDL_GetClipboardText(); if (*text) { printf("Clipboard: %s\n", text); } else { printf("Clipboard is empty\n"); } SDL_free(text); } break; case SDLK_g: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-G toggle grab */ } break; case SDLK_m: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-M maximize */ /* FIXME: Which window has focus for this keyboard? */ for (i = 0; i < state->num_windows; ++i) { if (SDL_GetWindowFlags(state->windows[i]) & SDL_WINDOW_MAXIMIZED) { SDL_RestoreWindow(state->windows[i]); } else { SDL_MaximizeWindow(state->windows[i]); } } } break; case SDLK_z: if (event->key.keysym.mod & KMOD_CTRL) { /* Ctrl-Z minimize */ /* FIXME: Which window has focus for this keyboard? */ for (i = 0; i < state->num_windows; ++i) { SDL_MinimizeWindow(state->windows[i]); } } break; case SDLK_ESCAPE: *done = 1; break; default: break; } break; case SDL_QUIT: *done = 1; break; } }
/* FIXME: Add a structured comment for the man page generate to * create the basic documentation on this routine, particularly * since this routine only prints a subset of information by default */ int main(int argc, char *argv[]) { RLOG_IOStruct *pInput; RLOG_FILE_HEADER header; int num_levels; int num_states; int num_arrows; int num_events; int total_num_events = 0; int i, j, k; unsigned int nMask = 0; int bSummary = 1; RLOG_STATE state; RLOG_EVENT event, lastevent; RLOG_ARROW arrow, lastarrow; int bFindEvent = 0; double dFindTime = 0.0; int bValidate = 0; int bValidateArrows = 0; int bOrder = 0; int bJumpCheck = 0; double dJump = 0.0; /* FIXME: This should also check for the GNU-standard --help, --usage, * and -h options. */ if (argc < 2) { /* FIXME: What is the default behavior with just an rlogfile? */ printf("printrlog rlogfile [EVENTS | STATES | ARROWS | HEADER | COMM | ALL | SUMMARY ]\n"); printf("printrlog rlogfile find endtime\n"); printf("printrlog rlogfile validate\n"); printf("printrlog rlogfile order\n"); printf("printrlog rlogfile arroworder\n"); return -1; } if (argc > 2) { nMask = 0; bSummary = 0; for (i=2; i<argc; i++) { if (strcmp(argv[i], "EVENTS") == 0) nMask |= EVENT_BIT; if (strcmp(argv[i], "STATES") == 0) nMask |= STATE_BIT; if (strcmp(argv[i], "ARROWS") == 0) nMask |= ARROW_BIT; if (strcmp(argv[i], "HEADER") == 0) nMask |= HEADER_BIT; if (strcmp(argv[i], "COMM") == 0) nMask |= COMM_BIT; if (strcmp(argv[i], "ALL") == 0) nMask = HEADER_BIT | STATE_BIT | COMM_BIT | ARROW_BIT | EVENT_BIT; if (strcmp(argv[i], "SUMMARY") == 0) { bSummary = 1; nMask = 0; } if (strcmp(argv[i], "find") == 0) { bFindEvent = 1; dFindTime = atof(argv[i+1]); } if (strcmp(argv[i], "validate") == 0) { bValidate = 1; } if (strcmp(argv[i], "order") == 0) { bOrder = 1; } if (strcmp(argv[i], "arroworder") == 0) { bValidateArrows = 1; } if (strcmp(argv[i], "jump") == 0) { bJumpCheck = 1; if (argv[i+1]) dJump = atof(argv[i+1]); } } } pInput = RLOG_CreateInputStruct(argv[1]); if (pInput == NULL) { printf("Error opening '%s'\n", argv[1]); return -1; } if (bValidateArrows) { num_arrows = RLOG_GetNumArrows(pInput); if (num_arrows) { printf("num arrows: %d\n", num_arrows); RLOG_GetNextArrow(pInput, &lastarrow); if (lastarrow.start_time > lastarrow.end_time) printf("start > end: %g > %g\n", lastarrow.start_time, lastarrow.end_time); while (RLOG_GetNextArrow(pInput, &arrow) == 0) { if (arrow.start_time > arrow.end_time) printf("start > end: %g > %g\n", arrow.start_time, arrow.end_time); if (arrow.end_time < lastarrow.end_time) printf("arrows out of order: %d < %d\n", arrow.end_time, lastarrow.end_time); lastarrow = arrow; } } RLOG_CloseInputStruct(&pInput); return 0; } if (bValidate) { num_arrows = RLOG_GetNumArrows(pInput); if (num_arrows) { printf("num arrows: %d\n", num_arrows); RLOG_GetNextArrow(pInput, &lastarrow); if (lastarrow.start_time > lastarrow.end_time) { printf("Error, arrows endtime before starttime: %g < %g\n", lastarrow.end_time, lastarrow.start_time); PrintArrow(&arrow); } while (RLOG_GetNextArrow(pInput, &arrow) == 0) { if (lastarrow.end_time > arrow.end_time) { printf("Error, arrows out of order: %g > %g\n", lastarrow.end_time, arrow.end_time); PrintArrow(&lastarrow); PrintArrow(&arrow); } if (arrow.start_time > arrow.end_time) { printf("Error, arrows endtime before starttime: %g < %g\n", arrow.end_time, arrow.start_time); PrintArrow(&arrow); } lastarrow = arrow; } } for (j=pInput->header.nMinRank; j<=pInput->header.nMaxRank; j++) { num_levels = RLOG_GetNumEventRecursions(pInput, j); for (i=0; i<num_levels; i++) { printf("Validating events in level %d:%d\n", j, i); if (RLOG_GetNextEvent(pInput, j, i, &event) == 0) { if (event.end_time < event.start_time) { printf("Error, event endtime before starttime: %g < %g\n", event.end_time, event.start_time); } lastevent = event; while (RLOG_GetNextEvent(pInput, j, i, &event) == 0) { if (lastevent.start_time > event.start_time) { printf("Error, events out of order: %g > %g\n", lastevent.start_time, event.start_time); PrintEvent(&lastevent); PrintEvent(&event); } else if (lastevent.end_time > event.start_time) { printf("Error, starttime before previous endtime: %g > %g\n", lastevent.end_time, event.start_time); PrintEvent(&lastevent); PrintEvent(&event); } if (event.end_time < event.start_time) { printf("Error, event endtime before starttime: %g < %g\n", event.end_time, event.start_time); PrintEvent(&event); } lastevent = event; } } } } RLOG_CloseInputStruct(&pInput); return 0; } if (bOrder) { int count = 0; if (RLOG_GetNextGlobalEvent(pInput, &event) != 0) { RLOG_CloseInputStruct(&pInput); return 0; } count++; lastevent = event; PrintEvent(&event); while (RLOG_GetNextGlobalEvent(pInput, &event) == 0) { if (lastevent.start_time > event.start_time) { printf("Error, events out of order: %g > %g\n", lastevent.start_time, event.start_time); PrintEvent(&lastevent); PrintEvent(&event); } if (event.end_time < event.start_time) { printf("Error, event endtime before starttime: %g < %g\n", event.end_time, event.start_time); PrintEvent(&event); } lastevent = event; PrintEvent(&event); count++; } RLOG_CloseInputStruct(&pInput); printf("%d events traversed\n", count); return 0; } if (bFindEvent) { for (j=pInput->header.nMinRank; j<=pInput->header.nMaxRank; j++) { printf("rank %d\n", j); num_levels = RLOG_GetNumEventRecursions(pInput, j); for (i=0; i<num_levels; i++) { RLOG_FindEventBeforeTimestamp(pInput, j, i, dFindTime, &event, &k); PrintEventAndIndex(&event, k); } } RLOG_CloseInputStruct(&pInput); return 0; } if (bJumpCheck) { printf("Start:\n"); RLOG_FindGlobalEventBeforeTimestamp(pInput, dJump, &event); PrintEvent(&event); /*RLOG_PrintGlobalState(pInput);*/ printf("Previous 10:\n"); for (i=0; i<10; i++) { RLOG_GetPreviousGlobalEvent(pInput, &event); PrintEvent(&event); } printf("Start:\n"); RLOG_FindGlobalEventBeforeTimestamp(pInput, dJump, &event); PrintEvent(&event); printf("Next 10:\n"); for (i=0; i<10; i++) { RLOG_GetNextGlobalEvent(pInput, &event); PrintEvent(&event); } return 0; } if (RLOG_GetFileHeader(pInput, &header)) { printf("unable to read the file header\n"); RLOG_CloseInputStruct(&pInput); return -1; } if (nMask & HEADER_BIT || bSummary) { printf("min rank: %d\n", header.nMinRank); printf("max rank: %d\n", header.nMaxRank); } if (nMask & STATE_BIT || bSummary) { num_states = RLOG_GetNumStates(pInput); if (num_states) { printf("num states: %d\n", num_states); if (nMask & STATE_BIT) { for (i=0; i<num_states; i++) { RLOG_GetNextState(pInput, &state); PrintState(&state); } } } } if (nMask & ARROW_BIT || bSummary) { num_arrows = RLOG_GetNumArrows(pInput); if (num_arrows) { printf("num arrows: %d\n", num_arrows); if (nMask & ARROW_BIT) { for (i=0; i<num_arrows; i++) { RLOG_GetNextArrow(pInput, &arrow); PrintArrow(&arrow); } } } } if (nMask & EVENT_BIT || bSummary) { for (k=pInput->header.nMinRank; k<=pInput->header.nMaxRank; k++) { total_num_events = 0; num_levels = RLOG_GetNumEventRecursions(pInput, k); if (num_levels > 0) { printf("rank %d\n", k); printf("num event recursions: %d\n", num_levels); for (i=0; i<num_levels; i++) { num_events = RLOG_GetNumEvents(pInput, k, i); total_num_events += num_events; printf(" level %d, num events: %d\n", i, num_events); if (nMask & EVENT_BIT) { for (j=0; j<num_events; j++) { RLOG_GetNextEvent(pInput, k, i, &event); PrintEvent(&event); } } } printf("num events total: %d\n", total_num_events); } } } RLOG_CloseInputStruct(&pInput); return 0; }