static pascal void ExitToShellPatchRoutine() { ExitToShellUPP oldETS; long oldA5; /* * Set up our A5 world. This allows us to have * access to our global variables in the 68k world. */ oldA5 = SetCurrentA5(); SetA5(gExitToShellData->a5); /* * Call the function that invokes all * of the handlers. */ TclMacExitHandler(); /* * Call the origional ExitToShell routine. */ oldETS = gExitToShellData->oldProc; DisposePtr((Ptr) gExitToShellData); SetA5(oldA5); CallExitToShellProc(oldETS); return; }
pascal void snd_channel_callback(SndChannelPtr theChannel,SndCommand* theCommand) { long theA5; short channel = -1,i,which_sound; #ifndef EXILE_BIG_GUNS theA5 = SetA5(theCommand->param2); #endif for (i = 0; i < 4; i++) if (chan[i] == theChannel) channel = i; which_sound = snd_played[channel]; snd_played[channel] = -1; //if (in_startup_mode == false) // print_num(0,snd_played[channel],channel); if ((sound_going(which_sound) == false) && (load_when_play[which_sound] == true)) { HUnlock(sound_handles[which_sound]); //if (in_startup_mode == false) // print_num(99,snd_played[channel],channel); } #ifndef EXILE_BIG_GUNS theA5 = SetA5(theA5); #endif }
/* Routine passed to NewSndChannel -- schedule a call to SndCh_CallCallBack */ static pascal void SndCh_UserRoutine(SndChannelPtr chan, SndCommand *cmd) { SndChannelObject *p = (SndChannelObject *)(chan->userInfo); if (p->ob_callback != NULL) { long A5 = SetA5(p->ob_A5); p->ob_cmd = *cmd; Py_AddPendingCall(SndCh_CallCallBack, (void *)p); SetA5(A5); } }
static pascal void SPB_completion(SPBPtr my_spb) { SPBObject *p = (SPBObject *)(my_spb->userLong); if (p && p->ob_completion) { long A5 = SetA5(p->ob_A5); p->ob_thiscallback = p->ob_completion; /* Hope we cannot get two at the same time */ Py_AddPendingCall(SPB_CallCallBack, (void *)p); SetA5(A5); } }
/*-------------------------------------------------------------------- * FUNCTION NAME * callProgress - Macintosh Version * * DESCRIPTION * This function calls the user's call back function * must be done as separate subroutine so that progress function * address is addressed via the A6 stack * *--------------------------------------------------------------------*/ static PTErr_t FAR PASCAL callProgress ( callBack_p callBack, KpInt32_t percent) { initializedGlobals_p iGP; PTRelay_t relay; PTErr_t theReturn; #if defined (KPMACPPC) long thisA5; #endif if (callBack->progressFunc == NULL) { return KCP_SUCCESS; } iGP = getInitializedGlobals (); if (iGP == NULL) { return KCP_NO_PROCESS_GLOBAL_MEM; } relay = iGP->callBackRelay; /* do the progress call-back */ #if defined (KPMACPPC) thisA5 = SetA5 (callBack->gHostA5); /* PPC or 68K callback code? */ if ( ((UniversalProcPtr)callBack->progressFunc)->goMixedModeTrap == _MixedModeMagic) { theReturn = (PTErr_t) CallUniversalProc ((UniversalProcPtr)callBack->progressFunc, uppCallProgressProcInfo, percent); } else { /* callback code is 68K */ theReturn = (PTErr_t) CallUniversalProc ((UniversalProcPtr)relay, upprelayProcInfo, callBack->gHostA5, callBack->gHostA4, callBack->progressFunc, percent); } SetA5 (thisA5); #endif #if defined (KPMAC68K) theReturn = (PTErr_t)relay (callBack->gHostA5, callBack->gHostA4, callBack->progressFunc, percent); #endif return (theReturn); }
/*-------------------------------------------------------------------- * DESCRIPTION * Do progress callback. - MAC version * * AUTHOR * mec * * DATE CREATED * May 4, 1995 *------------------------------------------------------------------*/ static SpStatus_t SpDoIter ( SpTagIter_t ProgressFunc, SpIterState_t State, SpProfile_t Profile, SpTagId_t TagId, void FAR *Data) { #if defined(KPMAC68K) volatile long hostA4, hostA5; volatile long thisA4, thisA5; #endif SpStatus_t status; if (NULL == ProgressFunc) return SpStatSuccess; #if defined(KPMAC68K) /* restore host's global world - we don't know if its an A4 or A5*/ SPretrieveCallbackA4A5(&hostA4, &hostA5); if (hostA5 != 0) thisA5 = SetA5(hostA5); if (hostA4 != 0) thisA4 = SetA4(hostA4); #endif status = CallSPIterCallBackFunc((spIterCallBackUPP)ProgressFunc, State, Profile, TagId, Data); #if defined (KPMAC68K) /* reset our global world */ if (hostA5 != 0) SetA5(thisA5); if (hostA4 != 0) SetA4(thisA4); #endif return status; }
pascal void OTTCPNotifier(void* vobj, OTEventCode code, OTResult result, void* cookie) { OTTCP *x = (OTTCP *) vobj; long oldA5; OSStatus s; EnterCallback(); oldA5 = SetA5(x->o_a5); post("*** OTTCPNotifier(code %x, result %ld)", (long) code, (long) result); if (code == T_OPENCOMPLETE) { if (result != noErr) { post("OTTCPNotifier got a T_OPENCOMPLETE code with error %ld", result); } // Even if we got an error, we'll use the endpoint. x->o_tcp_ep = (EndpointRef) cookie; if (x->o_inetHostName != 0) { BindTheEndpoint(x); // Now we expect a T_BINDCOMPLETE message. } } else if (code == T_BINDCOMPLETE) { TCall sndCall; InetAddress inAddr; // See what ephemeral port number OT gave us x->o_receiveInetPort = x->o_addrWeActuallyGot.fPort; // Now the endpoint has been bound; next trick is connecting OTInitInetAddress(&inAddr, x->o_inetPort, x->o_inetHost); OTMemzero(&sndCall, sizeof(TCall)); sndCall.addr.buf = (void *) &inAddr; sndCall.addr.len = sizeof(InetAddress); post("** About to OTConnect"); s = OTConnect(x->o_tcp_ep, &sndCall, NULL); if (s == kOTNoDataErr) { // No problem; that means connection is in progress post("** OTConnect returned kOTNoDataErr - good"); } else { post("е OTTCP: error: OTConnect returned %ld; not connecting.", s); } // Now we expect T_CONNECT } else if (code == T_CONNECT) { if (result == kOTBadAddressErr) { post("е OTTCP: error: bad address. Disconnecting"); x->o_inetHost = 0; change_connection(x); } else { post("** Got T_CONNECT"); post("** Result passed to notifier: %ld", (long) result); post("** Endpoint state before OTRcvConnect: %ld", (long) OTGetEndpointState(x->o_tcp_ep)); // We could pass in buffers to find out the actual address we connected to, etc. s = OTRcvConnect(x->o_tcp_ep, nil); if (s != kOTNoError) { post("е OTTCP: error: RcvConnect returned %ld", s); } post("** Endpoint state after OTRcvConnect: %ld", (long) OTGetEndpointState(x->o_tcp_ep)); ChangeState(x, NO_REQUEST); x->o_connectionSymbol = ps_connected; clock_delay(x->o_connectedclock, 0); } } else if (code == T_UNBINDCOMPLETE) { // If we have a new inetHost, try to bind it if (x->o_inetHost != 0) { BindTheEndpoint(x); // Now we expect T_BINDCOMPLETE } else { // No inetHost, so we're disonnected x->o_connectionSymbol = ps_disconnected; clock_delay(x->o_connectedclock, 0); } } else if (code == T_DISCONNECTCOMPLETE) { // We always want to rebind when we reconnect, so after disconnecting we unbind s = OTUnbind(x->o_tcp_ep); if (s != kOTNoError) { post("OTTCP: warning: OTUnbind returned %ld", s); } } else if (code == T_DATA) { ottcp_handleIncomingData(x); } else if (code == T_UDERR) { if (x->o_errorreporting) { PostUDERR("OTTCPNotifier was called for a T_UDERR code", x->o_tcp_ep); } else { /* We still have to receive the error to clear the condition */ OTRcvUDErr(x->o_tcp_ep, 0); } } else if (code == T_GODATA) { // Flow control restriction has lifted; now it's OK to send more data. do_write(x, 0, 0); } else if (code == T_DISCONNECT) { // The other dude wants to disconnect post("OTTCP: peer wants to disconnect"); s = OTRcvDisconnect(x->o_tcp_ep, NULL); if (s == kOTNoError) { x->o_inetHost = 0; change_connection(x); } else if (s == kOTNoDisconnectErr) { // false alarm } else { post("е OTTCP: error: OTRcvDisconnect returned %ld", s); } } else if (code == T_ORDREL) { post("*** Got T_ORDREL"); s = OTRcvOrderlyDisconnect(x->o_tcp_ep); if (s == kOTNoReleaseErr) { post("...false alarm!"); } else if (s == kOTNoError) { x->o_inetHost = 0; change_connection(x); } else { post("е OTTCP: error: OTRcvOrderlyDisconnect returned %ld", s); } } else { if (x->o_errorreporting) { post("OTTCP: Unrecognized OTEventCode %ld in event handler. Oh well.", (long) code); } } done: SetA5(oldA5); ExitCallback(); }