static void entry(void) { struct MsgPort *port1,*port2; struct Message *msg; Forbid(); port1=FindPort("message test port"); Permit(); port2=CreateMsgPort(); if(port2!=NULL) { msg=(struct Message *)CreateIORequest(port2,sizeof(struct Message)); if(msg!=NULL) { int i; for(i=0;i<10;i++) { msg->mn_Node.ln_Name=(char *)i; PutMsg(port1,msg); WaitPort(port2); GetMsg(port2); } DeleteIORequest((struct IORequest *)msg); } DeleteMsgPort(port2); } Signal(port1->mp_SigTask,1<<port1->mp_SigBit); Wait(0);/* Let the parent remove me */ }
// Send an IPC startup int ASM L_IPC_Startup( REG(a0, IPCData *ipc), REG(a1, APTR data), REG(a2, struct MsgPort *reply)) { struct MsgPort *port=0; IPCMessage startup; // If no message port supplied, create one if (!reply) port=reply=CreateMsgPort(); // Fill out startup message startup.msg.mn_ReplyPort=reply; startup.command=IPC_STARTUP; startup.flags=(ULONG)ipc; startup.data=data; // Send the startup message PutMsg(&ipc->proc->pr_MsgPort,(struct Message *)&startup); // Wait for reply back WaitPort(reply); GetMsg(reply); // Delete port if we created one if (port) DeleteMsgPort(port); // If there's no command port, report failure if (startup.command!=IPC_STARTUP) return 0; return 1; }
IPC_StartupCode(funced_init, FunctionStartup *, startup) #endif { FuncEdData *data; // Allocate data if (!(data=AllocVec(sizeof(FuncEdData),MEMF_CLEAR))) return 0; // Store data startup->data=data; // Initialise some pointers data->startup=startup; data->function=startup->function; data->locale=startup->locale; // Create timer if (!(data->drag.timer=AllocTimer(UNIT_VBLANK,0))) return 0; // Create lists if (!(data->func_display_list=Att_NewList(0)) || !(data->flag_list=Att_NewList(0)) || !(data->function_list=Att_NewList(0))) return 0; // Create app port data->appport=CreateMsgPort(); return 1; }
struct NepClassRocket * AllocRocket(struct NepClassRocket *nch) { nch->nch_Task = FindTask(NULL); if((nch->nch_TaskMsgPort = CreateMsgPort())) { nch->nch_IF0 = psdFindInterface(nch->nch_Device, NULL, IFA_InterfaceNum, 0, TAG_END); nch->nch_IF1 = psdFindInterface(nch->nch_Device, NULL, IFA_InterfaceNum, 1, TAG_END); if(nch->nch_IF0 && nch->nch_IF1) { if((nch->nch_EP0Pipe = psdAllocPipe(nch->nch_Device, nch->nch_TaskMsgPort, NULL))) { return(nch); } else { PutStr("Couldn't allocate default pipe\n"); } } else { PutStr("Couldn't find interfaces\n"); } DeleteMsgPort(nch->nch_TaskMsgPort); } return(NULL); }
int dllKillLibrary(char *portname) { dll_tMessage msg,*reply; struct MsgPort *myport; struct MsgPort *dllport; bug("[DynLink] %s('%s')\n", __PRETTY_FUNCTION__, portname); if(!(myport=CreateMsgPort())) exit(0L); //Arghh bzero(&msg, sizeof(msg)); msg.dllMessageType=DLLMTYPE_Kill; msg.Message.mn_ReplyPort = myport; if((dllport=FindPort(portname))) { PutMsg(dllport, (struct Message *)&msg); /*WaitPort(myport);*/ while(!(reply=(dll_tMessage *)GetMsg(myport))) { Delay(2); if(FindPort(portname)!=dllport) break; } } DeleteMsgPort(myport); return (dllport?1:0); }
static int Audio_Available(void) { int ok=0; struct MsgPort *p; struct AHIRequest *req; if(p=CreateMsgPort()) { if(req=(struct AHIRequest *)CreateIORequest(p,sizeof(struct AHIRequest))) { req->ahir_Version=4; if(!OpenDevice(AHINAME,0,(struct IORequest *)req,NULL)) { D(bug("AHI available.\n")); ok=1; CloseDevice((struct IORequest *)req); } DeleteIORequest((struct IORequest *)req); } DeleteMsgPort(p); } D(if(!ok) bug("AHI not available\n")); return ok; }
BOOL Initialize(void) { LocaleBase = OpenLibrary("locale.library", 38); OpenahiprefsCatalog(); AHImp=CreateMsgPort(); if( AHImp != NULL ) { AHIio = (struct AHIRequest *)CreateIORequest( AHImp,sizeof(struct AHIRequest)); if( AHIio != NULL ) { AHIio->ahir_Version = 4; AHIDevice = OpenDevice(AHINAME,AHI_NO_UNIT,(struct IORequest *)AHIio,NULL); if(AHIDevice == 0) { AHIBase = (struct Library *)AHIio->ahir_Std.io_Device; return TRUE; } } } Printf((char *) msgTextNoOpen, (ULONG) "ahi.device", 4); Printf("\n"); return FALSE; }
int uae_start_thread (void *(*f) (void *), void *arg, uae_thread_id *foo) { struct MsgPort *replyport = CreateMsgPort(); if (replyport) { *foo = (struct Task *)myCreateNewProcTags (NP_Output, Output (), NP_Input, Input (), NP_Name, (ULONG) "UAE thread", NP_CloseOutput, FALSE, NP_CloseInput, FALSE, NP_StackSize, 16384, NP_Entry, (ULONG) do_thread, TAG_DONE); if(*foo) { struct startupmsg msg; msg.msg.mn_ReplyPort = replyport; msg.msg.mn_Length = sizeof msg; msg.func = f; msg.arg = arg; PutMsg (&((struct Process*)*foo)->pr_MsgPort, (struct Message*)&msg); WaitPort (replyport); } DeleteMsgPort (replyport); } return *foo!=0; }
/* * Start proxy thread */ static int start_proxy_thread (void) { int result = -1; struct MsgPort *replyport = CreateMsgPort(); struct Process *p; if (replyport) { p = myCreateNewProcTags (NP_Name, (ULONG) "E-UAE semaphore proxy", NP_Priority, 10, NP_StackSize, 2048, NP_Entry, (ULONG) proxy_thread_main, TAG_DONE); if (p) { /* Send startup message */ struct Message msg; msg.mn_ReplyPort = replyport; msg.mn_Length = sizeof msg; PutMsg (&p->pr_MsgPort, (struct Message*)&msg); WaitPort (replyport); proxy_thread = p; atexit (stop_proxy_thread); result = 0; } DeleteMsgPort (replyport); } return result; }
void openLibrariesAndPorts(void) { if(!(IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", MINOSVERSION))) { cleanup(EXIT_ERROR,"Can't open intuition.library."); } if(!(RexxSysBase = (struct RsxLib *)OpenLibrary("rexxsyslib.library",0L))) { cleanup(EXIT_ERROR,"Can't open rexxsyslib.library."); } if(!(UtilityBase = OpenLibrary("utility.library", MINOSVERSION))) { cleanup(EXIT_ERROR,"Can't open utility.library."); } if(!(NiKomBase = OpenLibrary("nikom.library", NIKLIBVERSION))) { cleanup(EXIT_ERROR, "Can't open nikom.library v" NIKLIBVERSIONSTR " or later."); } if(!(permitport = (struct MsgPort *)CreatePort("NiKomPermit",0))) { cleanup(EXIT_ERROR,"Can't open port 'NiKomPermit'"); } if(!(nodereplyport = CreateMsgPort())) { cleanup(EXIT_ERROR,"Can't open node reply message port."); } if(!(rexxport=(struct MsgPort *)CreatePort("NIKOMREXXHOST",0))) { cleanup(EXIT_ERROR, "Could not open ARexx function host port."); } RegisterARexxFunctionHost(TRUE); }
int main(int argc, char* argv[]) { int rc = RETURN_OK; if (argc != 2) { fprintf(stderr, "Usage: %s <audio mode id>\n", argv[0]); rc = RETURN_ERROR; } else { struct MsgPort* mp = CreateMsgPort(); if (mp != NULL) { struct AHIRequest* io = (struct AHIRequest *) CreateIORequest(mp, sizeof(struct AHIRequest)); if (io != NULL) { io->ahir_Version = 4; if (OpenDevice(AHINAME, AHI_NO_UNIT, (struct IORequest *) io, 0) == 0) { AHIBase = (struct Library *) io->ahir_Std.io_Device; BetterAudioID = atol(argv[1]); Forbid(); OldBestAudioIDA = (BestAudioIDA_proto*) SetFunction(AHIBase, _LVOAHI_BestAudioIDA, (ULONG (*)(void)) MyBestAudioIDA ); Wait(SIGBREAKF_CTRL_C); SetFunction(AHIBase, _LVOAHI_BestAudioIDA, (ULONG (*)(void)) OldBestAudioIDA ); rc = 0; Permit(); CloseDevice((struct IORequest *) io); } else { fprintf(stderr, "Unable to open '" AHINAME "' version 4.\n"); rc = RETURN_FAIL; } DeleteIORequest((struct IORequest *) io); } else { fprintf(stderr, "Unable to create IO request.\n"); rc = RETURN_FAIL; } DeleteMsgPort(mp); } else { fprintf(stderr, "Unable to create message port.\n"); rc = RETURN_FAIL; } } return rc; }
void OpenAHI( void ) { if( AHIDevice != 0 ) { AHImp = CreateMsgPort(); if( AHImp != NULL ) { AHIio = (struct AHIRequest *) CreateIORequest( AHImp, sizeof( struct AHIRequest ) ); if( AHIio != NULL ) { AHIio->ahir_Version = AHIVERSION; AHIDevice = OpenDevice( AHINAME, AHI_NO_UNIT, (struct IORequest *) AHIio, AHIDF_NOMODESCAN ); } } if( AHIDevice != 0 ) { Printf( "Unable to open %s version %ld\n", (ULONG) AHINAME, AHIVERSION ); cleanup( RETURN_FAIL ); } AHIBase = (struct Library *) AHIio->ahir_Std.io_Device; } }
void SendEvent(LONG event) { struct IOStdReq *InputRequest; struct MsgPort *InputPort; struct InputEvent *ie; if ((InputPort = (struct MsgPort*)CreateMsgPort())) { if ((InputRequest = (struct IOStdReq*)CreateIORequest(InputPort, sizeof(struct IOStdReq)))) { if (!OpenDevice("input.device", 0, (struct IORequest*)InputRequest, 0)) { if ((ie = AllocVec(sizeof(struct InputEvent), MEMF_PUBLIC | MEMF_CLEAR))) { ie->ie_Class = event; InputRequest->io_Command = IND_WRITEEVENT; InputRequest->io_Data = ie; InputRequest->io_Length = sizeof(struct InputEvent); DoIO((struct IORequest*)InputRequest); FreeVec(ie); } CloseDevice((struct IORequest*)InputRequest); } DeleteIORequest((struct IORequest *)InputRequest); } DeleteMsgPort (InputPort); } }
struct SysThread *Sys_Thread_CreateThread(void (*entrypoint)(void *), void *argument) { struct SysThread *thread; thread = AllocVec(sizeof(*thread), MEMF_ANY); if (thread) { thread->msgport = CreateMsgPort(); if (thread->msgport) { thread->msg.mn_Node.ln_Type = NT_MESSAGE; thread->msg.mn_ReplyPort = thread->msgport; thread->msg.mn_Length = sizeof(thread->msg); thread->entrypoint = entrypoint; thread->argument = argument; thread->process = CreateNewProcTags(NP_Entry, Sys_Thread_Trampoline, NP_UserData, thread, NP_Name, "Fodquake Thread", NP_StackSize, 32768, TAG_DONE); if (thread->process) { return thread; } DeleteMsgPort(thread->msgport); } FreeVec(thread); } return 0; }
uint32_t urndis_ctrl_msg(struct NepClassEth *ncp, uint8_t rt, uint8_t r, uint16_t index, uint16_t value, void *buf, size_t buflen) { LONG err=-1; struct PsdPipe *pp; struct MsgPort *mp; if((mp = CreateMsgPort())) { if((pp = psdAllocPipe(ncp->ncp_Device, mp, NULL))) { psdSetAttrs(PGA_PIPE, pp, PPA_NakTimeout, FALSE, PPA_NakTimeoutTime, 5000, PPA_AllowRuntPackets, TRUE, TAG_END); // bug("urndis_ctrl_msg:pipesetup( %d,%d,%d,%d,%d )\n",pp, rt, r, value, index); psdPipeSetup(pp, rt, r, value, index); // bug("urndis_ctrl_msg:psdDoPipe(%d,%d,%d)\n",pp, buf, buflen); err = psdDoPipe(pp, buf, buflen); if(err!=0){ bug("urndis_ctrl_msg:error %d,%s\n",err,psdNumToStr(NTS_IOERR, err, "unknown")); } psdFreePipe(pp); } DeleteMsgPort(mp); } return err; }
VOID __saveds PingFunc( VOID ) { struct MsgPort *ClientPort, *ReplyPort; struct Library *SysBase; BlankMsg PingMsg; SysBase = *( struct Library ** )4L; if( ReplyPort = CreateMsgPort()) { PingMsg.bm_Mess.mn_ReplyPort = ReplyPort; PingMsg.bm_Mess.mn_Length = sizeof( BlankMsg ); PingMsg.bm_Type = BM_PING; /* Stealthimania, to alleviate processing at the blanker */ PingMsg.bm_Mess.mn_Node.ln_Name = ( UBYTE * )( &Blanking ); for( ;; ) { if( SetSignal( 0L, SIGBREAKF_CTRL_C ) & SIGBREAKF_CTRL_C ) break; if( ClientPort = FindPort( "GarshneClient" )) { PingMsg.bm_Flags = 0L; PutMsg( ClientPort, ( struct Message * )( &PingMsg )); WaitPort( ReplyPort ); GetMsg( ReplyPort ); } } DeletePort( ReplyPort ); } }
/** * Initializes the network core (as that is needed for some platforms * @return true if the core has been initialized, false otherwise */ bool NetworkCoreInitialize() { #if defined(__MORPHOS__) || defined(__AMIGA__) /* * IMPORTANT NOTE: SocketBase needs to be initialized before we use _any_ * network related function, else: crash. */ DEBUG(net, 3, "[core] loading bsd socket library"); SocketBase = OpenLibrary("bsdsocket.library", 4); if (SocketBase == NULL) { DEBUG(net, 0, "[core] can't open bsdsocket.library version 4, network unavailable"); return false; } #if defined(__AMIGA__) /* for usleep() implementation (only required for legacy AmigaOS builds) */ TimerPort = CreateMsgPort(); if (TimerPort != NULL) { TimerRequest = (struct timerequest*)CreateIORequest(TimerPort, sizeof(struct timerequest); if (TimerRequest != NULL) { if (OpenDevice("timer.device", UNIT_MICROHZ, (struct IORequest*)TimerRequest, 0) == 0) { TimerBase = TimerRequest->tr_node.io_Device; if (TimerBase == NULL) { /* free ressources... */ DEBUG(net, 0, "[core] can't initialize timer, network unavailable"); return false; } } } }
int32 V86Start (struct ContextState *state) { struct Msg *msg; uint32 signals; if ((v86_msgport = CreateMsgPort()) != NULL) { KSignal (v86_init_pid, SIG_INIT); } else { KPANIC ("V86 error"); } while (1) { signals = KWait (1 << v86_msgport->signal); if (signals & (1 << v86_msgport->signal)) if ((msg = GetMsg (v86_msgport)) != NULL) break; } handler_v86msg = (struct V86Msg *) msg; state->eax = handler_v86msg->state->eax; state->ebx = handler_v86msg->state->ebx; state->ecx = handler_v86msg->state->ecx; state->edx = handler_v86msg->state->edx; state->esi = handler_v86msg->state->esi; state->edi = handler_v86msg->state->edi; state->ebp = handler_v86msg->state->ebp; state->gs = PL3_DATA_SEGMENT; state->fs = PL3_DATA_SEGMENT; state->es = PL3_DATA_SEGMENT; state->ds = PL3_DATA_SEGMENT; state->v86_gs = handler_v86msg->state->gs; state->v86_fs = handler_v86msg->state->fs; state->v86_es = handler_v86msg->state->es; state->v86_ds = handler_v86msg->state->ds; *(uint8 *)(0x00010000) = OPCODE_INT; *(uint8 *)(0x00010001) = handler_v86msg->vector; *(uint8 *)(0x00010002) = OPCODE_IRET; state->return_eip = 0x0000; state->return_cs = 0x1000; state->return_eflags = EFLG_IF | EFLG_VM; state->return_esp = 0xfff0; state->return_ss = 0x2000; return 0; }
BOOL IPC_PutMsg( struct MsgPort *destino, IPCACT_T action, APTR udata ) { struct MsgPort *replyport = NULL; BOOL error = TRUE; ENTER(); DBG_POINTER(destino); if(destino && (replyport = CreateMsgPort())) { struct IPCMsg ipcmsg; APTR xMsg; ipcmsg.ipc_msg.mn_ReplyPort = replyport; ipcmsg.ipc_msg.mn_Length = sizeof(struct IPCMsg); ipcmsg.ipc_ID = IPC_MAGIC; ipcmsg.ipc_action = action; ipcmsg.ipc_result = IPCR_ABORTED; ipcmsg.ipc_data = udata; DBG("Sending action '%ld' from %lx to %lx\n", action, replyport, destino); Forbid(); PutMsg( destino, &ipcmsg.ipc_msg); WaitPort(replyport); while((xMsg = GetMsg( replyport ))) { DBG("Got reply...\n"); switch(((struct IPCMsg *)xMsg)->ipc_result) { // TODO case IPCR_ABORTED: DBG("IPCR_ABORTED\n"); break; case IPCR_FAIL: DBG("IPCR_FAIL\n"); break; case IPCR_OK: DBG("IPCR_OK\n"); break; default: break; } } Permit(); DeleteMsgPort(replyport); error = FALSE; } LEAVE(); return !error; }
void SAVEDS handler(void) { struct Process *me = (struct Process *)FindTask(NULL); struct startMsg *smsg; struct MsgPort *port; BOOL res = FALSE; ENTER(); WaitPort(&me->pr_MsgPort); smsg = (struct startMsg *)GetMsg(&me->pr_MsgPort); #if defined(__amigaos4__) port = AllocSysObject(ASOT_PORT, TAG_DONE); #else port = CreateMsgPort(); #endif if(port != NULL) res = localSendRexxMsg(port, smsg->port, smsg->cmd); smsg->res = res; ReplyMsg((struct Message *)smsg); if(res == TRUE) { struct RexxMsg *rxmsg; WaitPort(port); rxmsg = (struct RexxMsg *)GetMsg(port); DeleteArgstring((APTR)rxmsg->rm_Args[0]); DeleteRexxMsg(rxmsg); } if(port != NULL) { #if defined(__amigaos4__) FreeSysObject(ASOT_PORT, port); #else DeleteMsgPort(port); #endif } ObtainSemaphore(&OpenURLBase->libSem); OpenURLBase->rexx_use--; ReleaseSemaphore(&OpenURLBase->libSem); #if !defined(__amigaos4__) // all systems except OS4 should leave this function in forbidden state Forbid(); #endif LEAVE(); }
// EMULATOR int emulator::setUpEmulator2() { DEBUG(3) dprintf("emulator::setUpEmulator2() called. this=%p\n", this); proc = (struct Process *)FindTask(0); port = CreateMsgPort(); if(port == NULL) return ENOMEM; return 0; }
int arexx_init(void) { int rc = 0; Forbid(); if (!arexx_find()) { if ((arexx_execute_port = CreateMsgPort())) { if ((arexx_port = CreateMsgPort())) { arexx_port->mp_Node.ln_Name = (char*)"SIMPLEMAIL.1"; AddPort(arexx_port); rc = 1; } } } Permit(); return rc; }
context *context::createContext() { DEBUG(3) dprintf("context::createContext() called.\n"); struct Process *my_proc = (struct Process *)FindTask(0); struct MsgPort *my_port = CreateMsgPort(); if(my_port == NULL) return NULL; return new context(my_proc, my_port); }
// Send an ARexx command long __asm __saveds HookRexxCommand( register __a0 char *command, register __a1 char *result, register __d0 long length, register __a2 struct MsgPort *replyport, register __d1 ULONG flags) { struct MsgPort *rexx,*reply; struct RexxMsg *msg; long rc=-1; // Clear result if (result) *result=0; // Get rexx port if (!GUI->rexx_proc || !(rexx=(struct MsgPort *)IPCDATA(GUI->rexx_proc))) return -1; // Create reply port if needed if ((reply=replyport) || (reply=CreateMsgPort())) { // Create message if (msg=BuildRexxMsgExTags( reply, ".dopus5", rexx->mp_Node.ln_Name, RexxTag_Arg0,command, TAG_END)) { // Initialise message msg->rm_Action|=1|RXCOMM; if (result) msg->rm_Action|=RXFF_RESULT; // Send the message and wait for reply PutMsg(rexx,(struct Message *)msg); WaitPort(reply); GetMsg(reply); // String reply? if (msg->rm_Result2 && result) stccpy(result,(char *)msg->rm_Result2,length); rc=msg->rm_Result1; // Free message FreeRexxMsgEx(msg); } // Free message port if (reply!=replyport) DeleteMsgPort(reply); } return rc; }
int OpenIO(struct Window *iowin) { if(!(timerport=(struct MsgPort *)CreateMsgPort())) return(FALSE); if(!(timerreq=(struct timerequest *)CreateExtIO(timerport,(LONG)sizeof(struct timerequest)))) return(FALSE); if(OpenTimer(timerreq)) return(FALSE); else timeryes=TRUE; if(!(conwriteport=(struct MsgPort *)CreateMsgPort())) return(FALSE); if(!(conwritereq=(struct IOStdReq *)CreateExtIO(conwriteport,(LONG)sizeof(struct IOStdReq)))) return(FALSE); if(!(conreadport=(struct MsgPort *)CreateMsgPort())) return(FALSE); if(!(conreadreq=(struct IOStdReq *)CreateExtIO(conreadport,(LONG)sizeof(struct IOStdReq)))) return(FALSE); if(OpenConsole(iowin)) return(FALSE); else consoleyes=TRUE; return(TRUE); }
int main() { APTR ProcessorBase; IPTR args[6] = { 0, 0, 0, 0, 0, 0 }; struct RDArgs *rda; int max_cpus = 0; int max_iter = 0; int req_width = 0, req_height = 0; char tmpbuf[200]; int explicit_mode = 0; struct MsgPort *timerPort = CreateMsgPort(); struct timerequest *tr = CreateIORequest(timerPort, sizeof(struct timerequest)); struct TimerBase *TimerBase = NULL; struct timeval start_time; struct timeval now; struct Window *displayWin; struct BitMap *outputBMap = NULL; IPTR coreCount = 1; struct TagItem tags[] = { {GCIT_NumberOfProcessors, (IPTR)&coreCount}, {0, (IPTR)NULL}}; ProcessorBase = OpenResource(PROCESSORNAME); if (!ProcessorBase) return 0; KernelBase = OpenResource("kernel.resource"); if (!KernelBase) return 0; if (timerPort) { FreeSignal(timerPort->mp_SigBit); timerPort->mp_SigBit = -1; timerPort->mp_Flags = PA_IGNORE; } if (tr) { if (!OpenDevice("timer.device", UNIT_VBLANK, (struct IORequest *)tr, 0)) { TimerBase = (struct TimerBase *)tr->tr_node.io_Device; } } else return 0; GetCPUInfo(tags); D(bug("[SMP-Smallpt] %s: detected %d CPU cores\n", __func__, coreCount);)
int uae_start_thread (const TCHAR *name, void *(*f)(void *), void *arg, uae_thread_id *tid) { struct MsgPort *replyport; struct Process *newtask = NULL; struct TagItem procTags[] = { { NP_Name, (IPTR) NULL}, { NP_StackSize, (IPTR)(64 * 1024)}, { NP_Entry, (IPTR) do_thread}, //{ NP_Output, Output ()}, //{ NP_Input, Input ()}, //{ NP_CloseOutput, FALSE}, //{ NP_CloseInput, FALSE}, { TAG_DONE, 0} }; #warning Do we need to care for priorities here? WinUAE does.. if(!name) procTags[0].ti_Data = (IPTR)default_name; else procTags[0].ti_Data = (IPTR)name; bug("[JUAE:PX] %s('%s', f %lx, arg %lx, tid %lx)\n", __PRETTY_FUNCTION__, procTags[0].ti_Data, f, arg, tid); replyport = CreateMsgPort(); if(!replyport) { write_log("ERROR: Unable to create MsgPort!\n"); } newtask = CreateNewProc (procTags); bug("[JUAE:PX] %s: Process @ %p, MsgPort @ %p\n", __PRETTY_FUNCTION__, newtask, newtask->pr_MsgPort); if(newtask) { struct startupmsg msg; msg.msg.mn_ReplyPort = replyport; msg.msg.mn_Length = sizeof msg; msg.func = f; msg.arg = arg; PutMsg (&newtask->pr_MsgPort, (struct Message*)&msg); WaitPort (replyport); } DeleteMsgPort (replyport); if(tid) { *tid=newtask; } return (newtask != 0); }
void main(void) { struct AHIAudioModeRequester *req; BOOL res; if(AHImp=CreateMsgPort()) if(AHIio=(struct AHIRequest *)CreateIORequest(AHImp,sizeof(struct AHIRequest))) { AHIio->ahir_Version = 2; AHIDevice=OpenDevice(AHINAME,AHI_NO_UNIT,(struct IORequest *)AHIio,NULL); } if(AHIDevice) { Printf("Unable to open %s version 2\n",AHINAME); cleanup(RETURN_FAIL); } AHIBase=(struct Library *)AHIio->ahir_Std.io_Device; req=AHI_AllocAudioRequest( AHIR_SleepWindow,TRUE, AHIR_UserData,999, AHIR_PubScreenName,NULL, TAG_DONE); res=AHI_AudioRequest(req, AHIR_TitleText, "Select a mode or cancel", AHIR_NegativeText, "Abort", AHIR_DoMixFreq, TRUE, AHIR_DoDefaultMode, TRUE, AHIR_InitialAudioID, 0x20003, AHIR_InitialMixFreq, 30000, AHIR_FilterTags, ReqFilterTags, TAG_DONE); if(!res) { if(IoErr() == ERROR_NO_FREE_STORE) Printf("AHI ran out of memory!\n"); else if(IoErr() == ERROR_NO_MORE_ENTRIES) Printf("No available modes!\n"); else Printf("Requester cancelled!\n"); } else Printf("Selected AudioMode: 0x%08lx, %ld Hz\n",req->ahiam_AudioID,req->ahiam_MixFreq); AHI_FreeAudioRequest(req); cleanup(RETURN_OK); }
int main( int argc, char* argv[] ) { int rc = RETURN_OK; if( argc != 1 ) { fprintf( stderr, "Usage: %s\n", argv[ 0 ] ); rc = RETURN_ERROR; } else { struct MsgPort* mp = CreateMsgPort(); if( mp != NULL ) { struct AHIRequest* io = (struct AHIRequest *) CreateIORequest( mp, sizeof( struct AHIRequest ) ); if( io != NULL ) { // We use 32 bit samples, so we need version 6. io->ahir_Version = 6; if( OpenDevice( AHINAME, AHI_NO_UNIT, (struct IORequest *) io, 0 ) == 0 ) { AHIBase = (struct Library *) io->ahir_Std.io_Device; rc = PlaySineEverywhere(); CloseDevice( (struct IORequest *) io ); } else { fprintf( stderr, "Unable to open '" AHINAME "' version 6.\n" ); rc = RETURN_FAIL; } DeleteIORequest( (struct IORequest *) io ); } else { fprintf( stderr, "Unable to create IO request.\n" ); rc = RETURN_FAIL; } DeleteMsgPort( mp ); } else { fprintf( stderr, "Unable to create message port.\n" ); rc = RETURN_FAIL; } } return rc; }
static void openpar(void) { ParMP = CreateMsgPort(); if (!ParMP) cleanup("Failed to create msgport", RETURN_ERROR); ParIO = (struct IOStdReq *)CreateIORequest(ParMP, sizeof(struct IOExtPar)); if (!ParIO) cleanup("Failed to create IO request", RETURN_ERROR); if (OpenDevice("parallel.device", 0, (struct IORequest *)ParIO, 0)) { cleanup("Failed to open parallel.device", RETURN_ERROR); } ParOpen = TRUE; }