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;
}
