自学教程：C++ CreateMsgPort函数代码示例

// Send an IPC startupint 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);}

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

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

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

// EMULATORint 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 commandlong __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);}

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