TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( DefaultSpmdVectorSpace_Parallel, emptyProcSimpleMultiVecAdjointApply,
Scalar )
{
// typedef typename Teuchos::ScalarTraits<Scalar>::magnitudeType ScalarMag; // unused
// typedef Teuchos::ScalarTraits<ScalarMag> SMT; // unused
const Ordinal localDim = g_localDim;
PRINT_VAR(localDim);
const Ordinal numCols1 = g_numCols1;
const Ordinal numCols2= g_numCols2;
PRINT_VAR(numCols1);
PRINT_VAR(numCols2);
const RCP<const DefaultSpmdVectorSpace<Scalar> > vs =
createZeroEleProcVS<Scalar>(localDim);
const RCP<MultiVectorBase<Scalar> > mv = createMembers<Scalar>(vs, numCols1);
const Scalar val1 = 2.0;
PRINT_VAR(val1);
ECHO(assign<Scalar>(mv.ptr(), val1));
out << "mv = " << *mv;
ECHO(const RCP<MultiVectorBase<Scalar> > Y = createMembers<Scalar>(mv->domain(), numCols2));
ECHO(const RCP<MultiVectorBase<Scalar> > X = createMembers<Scalar>(mv->range(), numCols2));
const Scalar val2 = 3.0;
PRINT_VAR(val2);
ECHO(assign<Scalar>(X.ptr(), val2));
out << "X = " << *X;
ECHO(apply<Scalar>(*mv, Thyra::CONJTRANS, *X, Y.ptr()));
out << "Y = " << *Y;
RTOpPack::ConstSubMultiVectorView<Scalar> Y_smvv =
Thyra::getLocalSubMultiVectorView<Scalar>(Y);
for (int i = 0; i < numCols1; ++i) {
for (int j = 0; j < numCols2; ++j) {
out << "i = " << i << ", j = " << j << ": ";
TEST_EQUALITY(Y_smvv(i,j), as<Scalar>(vs->dim())*val1*val2);
}
}
}
void
echo_command_line( int argc, char *argv[], char *echo_file)
{
int istr=0;
char echo_string[MAX_CHAR_IN_INPUT]="\0";
time_t start_time;
char *time_string;
start_time = time (NULL);
time_string = asctime( localtime(&start_time) );
SPF(echo_string,"Command line :");
while( istr < argc )
{
SPF(endofstring(echo_string)," %s", argv[istr]);
istr++;
}
ECHO(echo_string, echo_file);
SPF(echo_string,"Run Time : %s", time_string);
SPF(endofstring(echo_string),"Version : %s", GOMA_VERSION);
ECHO(echo_string,echo_file);
}
int xio_getc_pgm(struct __file *stream)
{
if ((PGM.flags & XIO_FLAG_EOF_bm) != 0) {
PGM.signal = XIO_SIG_EOF;
return (_FDEV_EOF);
}
if ((PGM.c = pgm_read_byte(&PGMf.filebase_P[PGMf.rd_offset])) == NUL) {
PGM.flags |= XIO_FLAG_EOF_bm;
}
++PGMf.rd_offset;
if (LINEMODE(PGM.flags) == 0) { // processing is simple if not LINEMODE
if (ECHO(PGM.flags) != 0) {
putchar(PGM.c);
}
return (PGM.c);
}
// now do the LINEMODE stuff
if (PGM.c == NUL) { // perform newline substitutions
PGM.c = '\n';
} else if (PGM.c == '\r') {
PGM.c = '\n';
// } else if ((SEMICOLONS(PGM.flags) != 0) && (PGM.c == ';')) {
// PGM.c = '\n';
}
if (ECHO(PGM.flags) != 0) {
putchar(PGM.c);
}
return (PGM.c);
}
static void aux(void)
/*@globals
fileSystem,
internalState,
AssertionException,
NotEnoughMemoryException
@*/
/*@modifies
fileSystem,
internalState
@*/
{
ECHO(("before_TRY_block\n"));
E4C_TRY{
ECHO(("inside_TRY_block\n"));
}E4C_FINALLY{
ECHO(("inside_FINALLY_block\n"));
goto out_of_try_block;
}
out_of_try_block:
ECHO(("after_TRY_block\n"));
}
static int socks_proxy(void)
{
static const struct {
enum ne_sock_sversion version;
int addr;
const char *fqdn;
unsigned int port;
const char *username, *password;
} ts[] = {
{ NE_SOCK_SOCKSV4, 4, NULL, 55555, NULL, NULL },
{ NE_SOCK_SOCKSV4, 4, NULL, 55555, "foobar", NULL },
{ NE_SOCK_SOCKSV4A, 0, "www.example.com", 55555, NULL, NULL },
{ NE_SOCK_SOCKSV5, 0, "www.example.com", 55555, NULL, NULL },
{ NE_SOCK_SOCKSV5, 4, NULL, 55555, NULL, NULL },
#ifdef TEST_IPV6
{ NE_SOCK_SOCKSV5, 6, NULL, 55555, NULL, NULL },
#endif
{ NE_SOCK_SOCKSV5, 0, "www.example.com", 55555, "norman", "foobar" }
};
unsigned n;
for (n = 0; n < sizeof(ts)/sizeof(ts[n]); n++) {
ne_socket *sock;
struct socks_server arg = {0};
int ret;
arg.version = ts[n].version;
arg.expect_port = ts[n].port;
if (ts[n].addr == 4)
arg.expect_addr = ne_iaddr_make(ne_iaddr_ipv4, raw_127);
#ifdef TEST_IPV6
else if (ts[n].addr == 6)
arg.expect_addr = ne_iaddr_make(ne_iaddr_ipv4, raw6_cafe);
#endif
else
arg.expect_fqdn = ts[n].fqdn;
arg.username = ts[n].username;
arg.password = ts[n].password;
CALL(begin_socks(&sock, &arg, echo_server, NULL));
ret = ne_sock_proxy(sock, ts[n].version, arg.expect_addr,
ts[n].fqdn, ts[n].port,
ts[n].username, ts[n].password);
ONV(ret, ("proxy connect #%u gave %d", n, ret));
FULLREAD("ok!\n");
ECHO("hello,\n");
ECHO("\n");
ECHO("world\n");
if (ts[n].addr)
ne_iaddr_free(arg.expect_addr);
CALL(finish(sock, 0));
}
return OK;
}
static int echo_lines(void)
{
ne_socket *sock;
CALL(begin(&sock, echo_server, NULL));
ECHO("hello,\n");
ECHO("\n");
ECHO("world\n");
return finish(sock, 0);
}
TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( SpmdLocalDataAccess,
zeroVS, Scalar )
{
out << "Create a locally replicated vector space ...\n";
typedef typename ScalarTraits<Scalar>::magnitudeType ScalarMag;
const RCP<const DefaultSpmdVectorSpace<Scalar> > vs =
createZeroVS<Scalar>();
TEST_ASSERT(!vs->isLocallyReplicated());
TEST_EQUALITY_CONST(vs->dim(), 0);
const RCP<const Teuchos::Comm<Ordinal> > comm = vs->getComm();
const Scalar val = as<Scalar>(1.5);
PRINT_VAR(val);
out << "Test locally replicated Vector ...\n";
const RCP<VectorBase<Scalar> > v = createMember<Scalar>(vs);
{
ECHO(RTOpPack::SubVectorView<Scalar> lsv =
getNonconstLocalSubVectorView<Scalar>(v));
TEST_EQUALITY_CONST(lsv.globalOffset(), 0);
TEST_EQUALITY(lsv.subDim(), 0);
TEST_EQUALITY_CONST(lsv.stride(), 1);
}
{
ECHO(RTOpPack::ConstSubVectorView<Scalar> lsv =
getLocalSubVectorView<Scalar>(v));
TEST_EQUALITY_CONST(lsv.globalOffset(), 0);
TEST_EQUALITY(lsv.subDim(), 0);
TEST_EQUALITY_CONST(lsv.stride(), 1);
}
assign<Scalar>(v.ptr(), val);
TEST_EQUALITY(sum<Scalar>(*v), as<Scalar>(0.0));
out << "Test locally replicated MultiVector ...\n";
const RCP<MultiVectorBase<Scalar> > mv = createMembers<Scalar>(vs, g_numCols);
{
ECHO(RTOpPack::SubMultiVectorView<Scalar> lsmv =
getNonconstLocalSubMultiVectorView<Scalar>(mv));
TEST_EQUALITY(lsmv.globalOffset(), 0);
TEST_EQUALITY(lsmv.subDim(), 0);
TEST_EQUALITY(lsmv.leadingDim(), lsmv.subDim());
TEST_EQUALITY_CONST(lsmv.colOffset(), 0);
TEST_EQUALITY(lsmv.numSubCols(), g_numCols);
}
{
ECHO(RTOpPack::ConstSubMultiVectorView<Scalar> lsmv =
getLocalSubMultiVectorView<Scalar>(mv));
}
assign<Scalar>(mv.ptr(), val);
for (int j = 0; j < g_numCols; ++j) {
TEST_EQUALITY(sum<Scalar>(*mv->col(0)), as<Scalar>(0.0));
}
}
pascal OSStatus CWindow::CarbonWindowHandler(
EventHandlerCallRef inHandlerCallRef,
EventRef inEvent,
void *inUserData)
{
CWindow *win=(CWindow*)inUserData;
Try_
{
switch (::GetEventKind(inEvent))
{
case kEventWindowActivated:
{
win->GetWindowLayer()->ActivateWindow(win);
/*
CCarbonWindowLayer *carb=dynamic_cast<CCarbonWindowLayer*>(win->GetWindowLayer());
AssertThrow_(carb);
if (carb->CanWindowBeActivated(win))
{
win->active=true;
win->WindowActivated();
}*/
}
break;
case kEventWindowDeactivated:
win->GetWindowLayer()->DeactivateWindow(win);
ECHO("Deactivate event received for window");
/*
if (win->IsWindowActive())
{
win->active=false;
win->WindowDeactivated();
}*/
break;
default:
ECHO("ERROR: Window handler received an event it doesn't know what to do with!");
break;
}
}
Catch_(err)
{
return ErrCode_(err);
}
return noErr;
}
static void
client_loop (client_state* state, void *frontend, void *backend)
{
zmq_pollitem_t items [] = { { frontend, 0, ZMQ_POLLIN, 0 },
{ backend, 0, ZMQ_POLLIN, 0 } };
client_state_set_heartbeat_time(state);
while (1) {
if(state->heartbeat_liveness <= 0)
{
//we dead
ECHO("Connection offline.");
return;
}
//s_dump(frontend);
zmq_poll (items, 2, -1);
if (items [0].revents & ZMQ_POLLIN)
{
client_loop_frontend(state,frontend);
}
if (items [1].revents & ZMQ_POLLIN)
{
client_loop_backend(state, backend);
}
if(client_state_is_time_to_heartbeat(state) == true)
{
add_ping_message(state);
}
send_outgoing_messages(state, frontend);
}
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ EndExecution /*e*/
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// Cleans up the program
void CProgram::EndExecution()
{
AssertThrow_(mProgramState==kRunning || mProgramState==kPaused);
// Clear all the remaining stack frames - thus releasing this programs memory pool
ULinkedListHelpers::DeleteAllData(&mStackFrames);
// flush the events to clear all the input which has accumulated whilst in play
::FlushEvents(kUserInputEventMask,0);
// Stop all sounds
UKaboom::Reset();
// mMADDriver.Reset();
UFuse::ShutDown();
UTNTMapManager::ShutDown();
UButtonManager::ResetButtons();
UCursorManager::ShowCursor();
CInputManager::SuspendInput();
UGammaManager::Shutdown();
// UMusicManager::CleanUp();
UFileManager::Shutdown();
UTNTMusicManager::ResetEngine();
delete mGraphicsContext;
mGraphicsContext=0L;
// Reset the PC and DC
mPC=mCode;
mDC=mRootScope.DataStatements();
mProgramState=kReady;
ECHO("Ended execution of program '" << GetProgramName() << "'");
}
static int _getc_char(void)
{
if (ECHO(ds[gdev].flags) != 0) {
ds[gdev].x_putc(ds[gdev].c, stdout);
}
return(ds[gdev].c);
}
TEUCHOS_UNIT_TEST( GlobalMPISession, basic ) {
#ifdef HAVE_MPI
TEST_ASSERT(GlobalMPISession::mpiIsInitialized());
int numProcs = -1;
ECHO(::MPI_Comm_size(MPI_COMM_WORLD, &numProcs));
TEST_EQUALITY(GlobalMPISession::getNProc(), numProcs);
int procRank = -1;
ECHO(::MPI_Comm_rank(MPI_COMM_WORLD, &procRank));
TEST_EQUALITY(GlobalMPISession::getRank(), procRank);
#else // HAVE_MPI
TEST_ASSERT(!GlobalMPISession::mpiIsInitialized());
TEST_EQUALITY_CONST(GlobalMPISession::getNProc(), 1);
TEST_EQUALITY_CONST(GlobalMPISession::getRank(), 0);
#endif // HAVE_MPI
TEST_ASSERT(!GlobalMPISession::mpiIsFinalized());
globalReduceSuccess(success, out);
}
void other_fn(void * arg)
{
int input = *(int *)arg;
lumiera_thread_sync (); // the main thread can discard the argument storage
CHECK (input == 42, "input is not 42, but %d", input);
input -= 42;
ECHO ("result is %d", input);
}
TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( DefaultSpmdVectorSpace_Parallel, emptyProcPrintVec,
Scalar )
{
const RCP<const DefaultSpmdVectorSpace<Scalar> > vs =
createZeroEleProcVS<Scalar>(g_localDim);
const RCP<VectorBase<Scalar> > v = createMember<Scalar>(vs);
ECHO(assign(v.ptr(), as<Scalar>(1.5)));
out << "v = " << *v;
}
inline void printState(const LR0State& state, const CFG& cfg) {
ECHO("Kernel:");
for (auto& item : state.kernel) {
ECHO(cfg.toReadableForm(cfg[item.productionNumber]));
// TRACE(item.position);
// TRACE(item.targetState);
}
ECHO("Items:");
for (auto& item : state.items) {
ECHO(cfg.toReadableForm(cfg[item.productionNumber]));
TRACE(item.position);
TRACE(item.targetState);
TRACE(static_cast<int>(item.action));
}
// TRACE(state.kernel.size());
// TRACE(state.items.size());
ECHO("");
}
/*
* Implemented GObject::finalize
*/
static void
echo_object_finalize (GObject *object)
{
Echo *echo = ECHO (object);
g_free (echo->instance_data);
echo_parent_class->finalize (object);
}
TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( DefaultSpmdVectorSpace_Parallel, emptyProcAssignSumVec,
Scalar )
{
const RCP<const DefaultSpmdVectorSpace<Scalar> > vs =
createZeroEleProcVS<Scalar>(g_localDim);
const RCP<VectorBase<Scalar> > v = createMember<Scalar>(vs);
ECHO(assign(v.ptr(), as<Scalar>(1.5)));
TEST_EQUALITY_CONST(sum(*v), as<Scalar>(1.5*g_localDim*(vs->getComm()->getSize()-1)));
}
// --------------------------------------------------------------------------------------------------------------------------
// * DebugHeader
// --------------------------------------------------------------------------------------------------------------------------
// Echos a time stamp into the file
void UBkgConsole::DebugHeader()
{
try
{
UInt32 time;
Str255 timeStr,dateStr;
::GetDateTime(&time);
::DateString(time,abbrevDate,dateStr,0);
::TimeString(time,true,timeStr,0);
ECHO("---------------------------------------------------------------------------");
ECHO( APP_NAME << " " << verShortText << " debug log started on " << dateStr << " " << timeStr);
ECHO("---------------------------------------------------------------------------");
}
catch(...)
{
}
}
static int _gets_NEWLINE(void) // handles any newline char
{
ds[gdev].signal = XIO_SIG_EOL;
ds[gdev].buf[ds[gdev].len] = NUL;
ds[gdev].flags &= ~XIO_FLAG_IN_LINE_bm; // clear in-line state (reset)
if (ECHO(ds[gdev].flags) != 0) {
ds[gdev].x_putc('\n',stdout); // echo a newline
}
return (XIO_EOL); // return for end-of-line
}
static void handler_z10(int signal_number)
/*@globals
fileSystem,
internalState
@*/
/*@modifies
fileSystem,
internalState
@*/
{
ECHO(("handler_%d\n", signal_number));
ECHO(("\nhandler_executed\n"));
/*@-exitarg@*/
exit(123);
/*@=exitarg@*/
}
static int _getc_NEWLINE(void) // convert CRs and LFs to newlines if line mode
{
if (LINEMODE(ds[gdev].flags) != 0) {
ds[gdev].c = '\n';
}
if (ECHO(ds[gdev].flags) != 0) {
ds[gdev].x_putc(ds[gdev].c, stdout);
}
return(ds[gdev].c);
}
static int _gets_DELETE(void)
{
if (--ds[gdev].len >= 0) {
if (ECHO(ds[gdev].flags) != 0) {
ds[gdev].x_putc(ds[gdev].c, stdout);
}
} else {
ds[gdev].len = 0;
}
return (XIO_EAGAIN); // line is still in process
}
TEUCHOS_UNIT_TEST( GlobalMPISession, allGather )
{
const int numProcs = GlobalMPISession::getNProc();
const int procRank = GlobalMPISession::getRank();
{
Array<int> allInts;
ECHO(allInts.resize(numProcs-1));
TEST_THROW(GlobalMPISession::allGather(procRank+1, allInts()), std::out_of_range);
ECHO(allInts.resize(numProcs+1));
TEST_THROW(GlobalMPISession::allGather(procRank+1, allInts()), std::out_of_range);
}
{
Array<int> allInts_expected(numProcs);
for (int k = 0; k < numProcs; ++k) {
allInts_expected[k] = k+1;
}
Array<int> allInts(numProcs);
ECHO(GlobalMPISession::allGather(procRank+1, allInts()));
TEST_EQUALITY(allInts, allInts_expected);
}
}
void SCA_Joystick::DestroyJoystickDevice(void)
{
#ifdef WITH_SDL
if (m_isinit) {
if (SDL_JoystickOpened(m_joyindex)) {
ECHO("Closing-joystick " << m_joyindex);
SDL_JoystickClose(m_private->m_joystick);
}
m_isinit = false;
}
#endif /* WITH_SDL */
}
TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( DefaultSpmdVectorSpace_Parallel, emptyProcPrintMultiVec,
Scalar )
{
const Ordinal localDim = g_localDim;
PRINT_VAR(localDim);
const Ordinal numCols = 3;
PRINT_VAR(numCols);
const RCP<const DefaultSpmdVectorSpace<Scalar> > vs = createZeroEleProcVS<Scalar>(localDim);
const RCP<MultiVectorBase<Scalar> > mv = createMembers<Scalar>(vs, numCols);
ECHO(assign(mv.ptr(), as<Scalar>(1.5)));
out << "mv = " << *mv;
}
TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( DefaultSpmdVectorSpace_Parallel, emptyProcGetFullSubVector,
Scalar )
{
const Ordinal localSubDim = g_localDim;
const RCP<const DefaultSpmdVectorSpace<Scalar> > vs =
createZeroEleProcVS<Scalar>(localSubDim);
const RCP<VectorBase<Scalar> > v = createMember<Scalar>(vs);
ECHO(assign(v.ptr(), as<Scalar>(1.5)));
RTOpPack::ConstSubVectorView<Scalar> subVec;
v->acquireDetachedView(Teuchos::Range1D(), &subVec);
TEST_EQUALITY(subVec.subDim(),
as<Ordinal>(localSubDim*(vs->getComm()->getSize()-1)));
}
static int _gets_char(void)
{
if (ds[gdev].len > ds[gdev].size) { // trap buffer overflow
ds[gdev].signal = XIO_SIG_EOL;
ds[gdev].buf[ds[gdev].size] = NUL; // size is zero based
return (XIO_BUFFER_FULL_NON_FATAL);
}
ds[gdev].buf[ds[gdev].len++] = ds[gdev].c;
if (ECHO(ds[gdev].flags) != 0) {
ds[gdev].x_putc(ds[gdev].c, stdout);// conditional echo
}
return (XIO_EAGAIN); // line is still in process
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ CWaitMouseDownStatement::ExecuteSelf
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void CWaitMouseDownStatement::ExecuteSelf(CProgram &inState)
{
if (USE_RNE_FOR_SYNC_INPUT)
{
// if the mouse button is held when we enter, then we're done instantly
if (Button())
return;
// otherwise, block our task until we get an event, if it's a mouse click, unblock, if not, handle it and reblock
// this drops our cpu usage from 100 to pretty much zero on mac os x
EventRef e;
// clear all pending mouse downs so we don't return immediately
{
EventTypeSpec eventsList[]={ { kEventClassMouse, kEventMouseDown } };
::FlushEventsMatchingListFromQueue(GetCurrentEventQueue(),1,eventsList);
}
// wait for a standard event with an infinite time out, this includes esc and cmd-. etc
inState.TBReceiveNextEvent(EventListWithCount(CApplication::kStdEventsListPlusAllMouse),kEventDurationForever,false,&e);
// if it's a mouse click, flush it and exit, if it's not a mouse click, don't flush it, let it be handled then repeat
if ((::GetEventClass(e)==kEventClassMouse) && (::GetEventKind(e)==kEventMouseDown) && inState.MouseEventIsOverGameWindow(e))
{
// remove the event from the queue
::RemoveEventFromQueue(GetCurrentEventQueue(),e); // we now own e
::ReleaseEvent(e);
}
else
{
ECHO("Non mouse up event, passing out and looping...");
inState.SetPC(this); // let the event out to our main handler and loop back into this command when it's done
}
}
else
{
if (!Button())
inState.SetPC(this);
else
{
#if TB_FlushEventsAllTheFeckinTime
::FlushEvents(kUserInputEventMask,0L);
#endif
}
}
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ CWaitMouseUpStatement::ExecuteSelf
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void CWaitMouseUpStatement::ExecuteSelf(CProgram &inState)
{
if (USE_RNE_FOR_SYNC_INPUT)
{
if (!Button()) // mouse button ain't held, return instantly
return;
// otherwise, block until mouse up is received
EventRef e;
// clear all pending mouse ups so we don't return immediately
{
EventTypeSpec eventsList[]={ { kEventClassMouse, kEventMouseUp } };
::FlushEventsMatchingListFromQueue(GetCurrentEventQueue(),1,eventsList);
}
// wait for a standard event with an infinite time out, this includes esc and cmd-. etc
inState.TBReceiveNextEvent(EventListWithCount(CApplication::kStdEventsListPlusAllMouse),kEventDurationForever,false,&e);
// if it's a mouse click, flush it and exit, if it's not a mouse click, don't flush it, let it be handled then repeat
if ((::GetEventClass(e)==kEventClassMouse) && (::GetEventKind(e)==kEventMouseUp))
{
// remove the event from the queue
::RemoveEventFromQueue(GetCurrentEventQueue(),e); // we now own e
::ReleaseEvent(e);
}
else
{
ECHO("Non mouse event, passing out and looping...");
inState.SetForceEventProcess(); // get it processed and out of the q immediately
inState.SetPC(this); // let the event out to our main handler and loop back into this command when it's done
}
}
else
{
if (Button())
inState.SetPC(this);
else
{
#if TB_FlushEventsAllTheFeckinTime
::FlushEvents(kUserInputEventMask,0L);
#endif
}
}
}
int main(void)
{
char str[100];
int flag = 1;
do
{
} while (0);
flag = (1, 2, 3);
printf("flag = %d\n", flag);
if (flag == 1)
ECHO(str);
else
printf("NULL doing\n");
return 0;
}
