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

/* * Get memory  */LOCAL void* imalloc( size_t size, IMACB *imacb ){	QUEUE	*q;	VP	mem;	UW	imask;	/* If it is smaller than the minimum fragment size,	   allocate the minimum size to it. */	if ( size < MIN_FRAGMENT ) {		size = MIN_FRAGMENT;	}	size = ROUND(size);	DI(imask);  /* Exclusive control by interrupt disable */	SpinLock(&MemLockObj);	/* Search FreeQue */	q = searchFreeArea(size, imacb);	if ( q != &imacb->freeque ) {		/* There is free area: Split from FreeQue once */		removeFreeQue(q);		q = q - 1;	} else {		/* Reserve new pages because there is no free space */		QUEUE	*e;		size_t	n;		/* Reserve pages */		SpinUnlock(&MemLockObj);		EI(imask);		n = PageCount(size + sizeof(QUEUE) * 2);		q = GetSysMemBlk(n, imacb->mematr);		if ( q == NULL ) {			goto err_ret;  /* Insufficient memory */		}		DI(imask);		SpinLock(&MemLockObj);		/* Register on AreaQue */		e = (QUEUE*)((VB*)q + n * pagesz) - 1;		insertAreaQue(&imacb->areaque, e);		insertAreaQue(&imacb->areaque, q);		setAreaFlag(q, AREA_TOP);		setAreaFlag(e, AREA_END);	}	/* Allocate memory */	mem = mem_alloc(q, size, imacb);	SpinUnlock(&MemLockObj);	EI(imask);	return mem;err_ret:	BMS_DEBUG_PRINT(("imalloc error/n"));	return NULL;}

int uart_putchar(unsigned char c){    int buffer_loc;    if(c == '/n') {        while(uart_putchar('/r')) {            ;        }    }    if(trans_buffer_size < BUFFER_SIZE) {        DI();        buffer_loc = (trans_buffer_current + trans_buffer_size) % BUFFER_SIZE;        trans_buffer[buffer_loc] = c;        trans_buffer_size++;        //trigger the interrupt if already ready to transmit        if((U0STAT0 & UART_TRAN_RDY) &&                ((IRQ0SET & UART_IRQ_TRAN) == 0)) {            IRQ0SET |= UART_IRQ_TRAN;        }        EI();    }    else {        return 1;    }    return 0;}

void led_display_text(const unsigned char *msg){	char *new_msg;	msg_size = strlen(msg);	new_msg = malloc(sizeof(*new_msg) * (msg_size + 2));	//+2 for space pad and null terminator	if(!new_msg) {		msg_size = 0;	}	else {		memcpy(new_msg, msg, msg_size);		//space pads the wrap-around		if(msg_size > 4) {			new_msg[msg_size] = ' ';			++msg_size;		}		new_msg[msg_size] = '/0';		DI();				if(led_msg != NULL) {			free(led_msg);		}				led_msg = new_msg;		msg_pos = 0;		row_pos = 0;		led_set_draw_chars();		EI();	}}

SifRpcDataQueue_t *SifSetRpcQueue(SifRpcDataQueue_t *qd, int thread_id){	SifRpcDataQueue_t *queue = NULL;	DI();	qd->thread_id = thread_id;	qd->active = 0;	qd->link   = NULL;	qd->start  = NULL;	qd->end    = NULL;	qd->next   = NULL;	if (!_sif_rpc_data.active_queue) {		_sif_rpc_data.active_queue = qd;	} else {		queue = _sif_rpc_data.active_queue;		while ((queue = queue->next))			;		queue->next = qd;	}	EI();	return queue;}

SifRpcServerData_t *SifRegisterRpc(SifRpcServerData_t *sd, 		int sid, SifRpcFunc_t func, void *buff, SifRpcFunc_t cfunc,		void *cbuff, SifRpcDataQueue_t *qd){	SifRpcServerData_t *server;	DI();	sd->link  = NULL;	sd->next  = NULL;	sd->sid   = sid;	sd->func  = func;	sd->buff  = buff;	sd->cfunc = cfunc;	sd->cbuff = cbuff;	sd->base  = qd;	if (!(server = qd->link)) {		qd->link = sd;	} else {		while ((server = server->next))			;		server->next = sd;	}	EI();	return server;}

int buscarIzquierdaAVL( AVL *a, int dato, int *band ){   int retAux;      retAux = eliminaAVL( &(*a)->izq, dato, band );      if( *band )   {      if( (*a) -> fe == 0 )      {         (*a) -> fe = 1;         *band = 0;      }else          if( (*a) -> fe == -1 )               (*a) -> fe = 0;          else             {               if( (*a) -> der -> fe >= 0 )               {                  if( (*a) -> der -> fe == 0 )                      *band = 0;                                     DD( a );               }else                   DI( a );                }   }      return( retAux );}

int eliminaAVL( AVL *a, int dato, int *band ){ int ret; AVL aux;  if( !*a )   *band = ret = 0; else    {      if( dato == (*a) -> info )      {        ret = *band = 1;        aux = *a;                if( !(*a) -> izq )           *a = (*a)-> der;        else          if( !(*a) -> der )            *a = (*a) -> izq;          else             {               recorreIzqDerAVL( &(*a) -> izq, &aux, band );               (*a) -> info = aux -> info;                              if( *band )               {                 if( (*a) -> fe == 0 )                 {                   (*a) -> fe = 1;                   *band = 0;                 }else                     if( (*a) -> fe == -1 )                        (*a) -> fe = 0;                     else                        {                          if( (*a) -> der -> fe >= 0 )                          {                            if( (*a) -> der -> fe == 0 )                              *band = 0;                                                      DD( a );                                              }else                               DI( a );                           }                 }            }                  free( aux );               }else           if( dato < (*a) -> info )              ret = buscarIzquierdaAVL( a, dato, band );            else              if( dato > (*a) -> info )                 ret=  buscarDerechaAVL( a, dato, band );    }      return( ret ); }

/************************************************************************************************************************ Function Name: R_Systeminit* Description  : This function initializes every macro.* Arguments    : None* Return Value : None***********************************************************************************************************************/void R_Systeminit(void){    DI();    /* Enable writing to registers related to operating modes, LPC, CGC and ATCM */    SYSTEM.PRCR.LONG = 0x0000A50BU;    /* Enable writing to MPC pin function control registers */    MPC.PWPR.BIT.B0WI = 0U;    MPC.PWPR.BIT.PFSWE = 1U;    r_set_exception_handler();    /* Set peripheral settings */    R_CGC_Create();    R_ICU_Create();    R_PORT_Create();    R_TPU_Create();    R_RSPI1_Create();    R_MPC_Create();	R_SCIFA2_Create();    /* Disable writing to MPC pin function control registers */    MPC.PWPR.BIT.PFSWE = 0U;    MPC.PWPR.BIT.B0WI = 1U;    /* Enable protection */    SYSTEM.PRCR.LONG = 0x0000A500U;    EI();}

int io_init(){	int i;	int res;	it_g = comedi_open("/dev/comedi0");	if (it_g == NULL) return -1;	// init 3 inputs and 3 outputs	for(i=1; i<4; i++)	{		res = comedi_dio_config(it_g, IO_DEV, DI(i), COMEDI_INPUT);		if (res<0) return res;		res = comedi_dio_config(it_g, IO_DEV, DO(i), COMEDI_OUTPUT);		if (res<0) return res;		res = comedi_dio_write(it_g, IO_DEV, DO(i), 0);		if (res<0) return res;	}	// set outputs to high	for(i=1; i<4; i++)	{		comedi_dio_write(it_g, IO_DEV, DO(i), 1);	}	return 1;}

int main(){	DI();//disable interrupts or hell breaks loose during hardware config	construct_system();//bind device addresses	init_system();//init devices		//clear all interrupts	clearall_interrupts();	EI();//enable interrupts: we have UART_recieve		//set the lcd contrast	//lcd_contrast(0x42);	lcd_contrast(0x32);	//clear the lcd	clearram();	//show boot up message	show_bootup();	//clear boot message	clearram();	//screen layout	screen_layout();	send(1, 225);	send(1, 255);	send(1, 2);	while(1)	{		get_temperature1();		get_temperature2();		get_light();		get_pressure();		get_humidity();		get_soilwetness();		display();		delay_ms(800);			}	return 0;}

intki_wait (struct k_t *sem, int timeout){// used by msg system  DI ();  if (0 < sem->cnt1) {    //      lucky that we do not need to wait ?    sem->cnt1--;		// Salute to Dijkstra    return (0);  }  if (timeout == -1) {    // no luck, dont want to wait so bye bye    return (-2);  }  // from here we want to wait  pRun->cnt2 = timeout;	// if 0 then wait forever  if (timeout)    pRun->cnt3 = (int) sem;	// nasty keep ref to semaphor  //  so we can be removed if timeout occurs  sem->cnt1--;		// Salute to Dijkstra  enQ (sem, deQ (pRun));  ki_task_shift ();		// call enables NOT interrupt on return  return ((char) (pRun->cnt2));	// 0: ok, -1: timeout}

int PS2CamReadPacket(int handle){	int *ret;	int *iop_addr;	WaitSema(sem);	ret = (int *)&data[0];	ret[0] = handle;	SifCallRpc(&cdata, PS2CAM_RPC_READPACKET, 0, (void*)(&data[0]),4,(void*)(&data[0]),4*2,0,0);	if(ret[0] < 0) return ret[0];	DI();	ee_kmode_enter();	iop_addr = (int *)(0xbc000000+ret[1]);	memcpy(&campacket[0],iop_addr, ret[0]);	ee_kmode_exit();	EI();	//if i add a printf here, the ps2 will exit to sony's explorer	SignalSema(sem);	return ret[0];}

charki_receive (struct k_msg_t *pB, void *el, int *lost_msg){    int i;    char r, *pSrc, *pDst;    // can be called from ISR bq no blocking    DI ();			// just to be sure    if (0 <= (r = ki_wait (pB->sem, -1))) {	pDst = (char *) el;	pB->r++;	pB->cnt--;		// got one	if (pB->nr_el <= pB->r) {	    pB->r = 0;	}	pSrc = pB->pBuf + pB->r * pB->el_size;	for (i = 0; i < pB->el_size; i++) {	    *(pDst++) = *(pSrc++);	}	if (lost_msg) {	    *lost_msg = pB->lost_msg;	    pB->lost_msg = 0;	}	return (r);		// yes    }    return (-1);		// nothing for you my friend}

intk_mut_ceil_enter (struct k_t *sem, int timeout){    int retval;    DI ();    // if ceiling_prio < 0 then its a normal wait call    if (sem->ceiling_prio < 0) {	retval = ki_wait (sem, timeout);	// could call k_wait but just extra fct call	EI ();	return retval;    }    if (pRun->prio < sem->ceiling_prio) {	// I have higher priority than ceiling :-(	EI ();	return CEILINGFAIL;    }    // now we play imm ceiling protocol    sem->saved_prio = pRun->prio;	// do im ceiling    pRun->prio = sem->ceiling_prio;	// dont need to reinsert in AQ bq ceil prio is higher or equal to mine and Im already in front of AQ    prio_enQ (pAQ, deQ (pRun));	// resinsert me in AQ acc to nwe(old) priority    retval = ki_wait (sem, timeout);    // coming back interrupt is still disabled !    // chk if we did get semaphore    if (retval < 0) {		// NOPE we did not	pRun->prio = sem->saved_prio;	// reset to my old priority	prio_enQ (pAQ, deQ (pRun));	// reinsert me in AQ acc to nwe(old) priority	ki_task_shift ();	// bq maybe started task has higher prio than me    }    EI ();    return retval;		// 0(has waited),1(straight through) : ok, -1: timeout}

intki_semval (struct k_t *sem){    DI ();    return (sem->cnt1);}

intki_signal (struct k_t *sem){    DI ();			// just in case    if (sem->cnt1 < sem->maxv) {	sem->cnt1++;		// Salute to Dijkstra	if (sem->cnt1 <= 0) {	    sem->next->cnt2 = 0;	// return code == ok	    prio_enQ (pAQ, deQ (sem->next));	    return (0);		// task was waiting	}	return (1);		// just delivered a signal - no task was waiting    }    if (SEM_MAX_VALUE > sem->clip) {	sem->clip++;    }    // here we are on bad clip failure no signal takes place    // signal is lost !!!#ifdef KRNLBUG    k_sem_clip (sem->nr, sem->clip);#endif    return (-1);}

intki_wait (struct k_t *sem, int timeout){    DI ();    if (0 < sem->cnt1) {	sem->cnt1--;		// Salute to Dijkstra	k_sem_unclip (sem->nr);	return (1);		// ok: 1 bq we are not suspended    }    if (timeout < 0)		// no luck, dont want to wait so bye bye    {	return (-2);    }    // from here we want to wait    pRun->cnt2 = timeout;	//  0 == wait forever    if (timeout) {		//  so we can be removed if timeout occurs	pRun->cnt3 = (int) sem;	// nasty keep ref to semaphore in task stomach    }    sem->cnt1--;		// Salute to Dijkstra    k_sem_unclip (sem->nr);    enQ (sem, deQ (pRun));    ki_task_shift ();    // back again - have semaphore received signal or timeout ?    pRun->cnt3 = 0;		// reset ref to timer semaphore    return ((char) (pRun->cnt2));	// 0: ok , -1: timeout}

int main(int argc, char**argv){      int err;    sqlite3 *conn;    char *errmsg;        err = sqlite3_open("test.sl3",&conn);    Table *t = table_new(TableCsv | TableColumns);        err = sqlite3_exec(conn,"select * from test",        table_add_row,t,&errmsg);        if (err) {        printf("err '%s'/n",errmsg);        return 1;    }    table_finish_rows(t);        DUMPA(float,(float*)t->cols[1],"%f");      sqlite3_close(conn);    unref(t);        DI(obj_kount());    return 0;}

static void TxThread(void *arg){	int ThreadToWakeUp;	while(1)	{		SleepThread();		if(PacketReqs.count > 0)		{			while(PacketReqs.count > 0)			{				WaitSema(NetManIOSemaID);				while(SifCallRpc(&NETMAN_rpc_cd, NETMAN_IOP_RPC_FUNC_SEND_PACKETS, 0, &PacketReqs, sizeof(PacketReqs), &ReceiveBuffer, sizeof(ReceiveBuffer.result), &TxEndCallback, NULL) < 0){};				SignalSema(NetManIOSemaID);			}		}		else		{			if(NetmanTxWaitingThread >= 0)			{				DI();				ThreadToWakeUp=NetmanTxWaitingThread;				NetmanTxWaitingThread=-1;				EI();				WakeupThread(ThreadToWakeUp);			}		}	}}

/************************************************************************************************************************ Function Name: __low_level_init* Description  : This function initializes hardware setting.* Arguments    : None* Return Value : None***********************************************************************************************************************/int __low_level_init(void){    DI();    R_Systeminit();    return (1U);}

/************************************************************************************************************************ Function Name: HardwareSetup* Description  : This function initializes hardware setting.* Arguments    : None* Return Value : None***********************************************************************************************************************/int HardwareSetup(void){    DI();    R_Systeminit();    return (1U);}

chark_receive (struct k_msg_t *pB, void *el, int timeout, int *lost_msg){  int i;  char *pSrc, *pDst;  DI ();  if (ki_wait (pB->sem, timeout) == 0) {    // ki_wait bq then intr is not enabled when coming back    pDst = (char *) el;    pB->r++;    pB->cnt--;		// got one    if (pB->nr_el <= pB->r)      pB->r = 0;    pSrc = pB->pBuf + pB->r * pB->el_size;    for (i = 0; i < pB->el_size; i++) {      *(pDst++) = *(pSrc++);    }    if (lost_msg) {      *lost_msg = pB->lost_msg;      pB->lost_msg = 0;    }    EI ();    return (0);		// yes  }  EI ();  return (-1);		// nothing for you my friend}

intk_wait (struct k_t *sem, int timeout){  // copy of ki_wait just with EI()'s before leaving  DI ();  if (0 < sem->cnt1) {     // lucky that we do not need to wait ?    sem->cnt1--;		       // Salute to Dijkstra    EI ();    return (0);  }  if (timeout == -1) {     // no luck, dont want to wait so bye     EI ();    return (-2);  }  // from here we have to wait  pRun->cnt2 = timeout;	// if 0 then wait forever  if (timeout)    pRun->cnt3 = (int) sem;	// nasty keep ref to semaphore,  //  so we can be removed if timeout occurs  sem->cnt1--;		// Salute to Dijkstra  enQ (sem, deQ (pRun));  ki_task_shift ();		// call enables interrupt on return  EI ();  return (char) (pRun->cnt2);	// 0: ok, -1: timeout}

voidk_reset (){    DI ();    wdt_enable (WDTO_15MS);    while (1);}

/* * Free memory *	It may be called during interrupt disable. In this case, need to wait *	 until interrupt is enabled and until free. */EXPORT void  knl_Ifree( void *ptr ){	QUEUE	*aq;	UINT	imask;	DI(imask);  /* Exclusive control by interrupt disable */	aq = (QUEUE*)ptr - 1;	clrAreaFlag(aq, AREA_USE);	if ( !chkAreaFlag(aq->next, AREA_USE) ) {		/* Merge with free area in after location */		knl_removeFreeQue(aq->next + 1);		knl_removeAreaQue(aq->next);	}	if ( !chkAreaFlag(aq->prev, AREA_USE) ) {		/* Merge with free area in front location */		aq = aq->prev;		knl_removeFreeQue(aq + 1);		knl_removeAreaQue(aq->next);	}	knl_appendFreeArea(knl_imacb, aq);	EI(imask);}

intk_set_prio (char prio){    int i;    if (!k_running) {	return (-2);    }    DI ();    if ((prio <= 0) || (DMY_PRIO <= prio))	// not legal value my friend    {	EI ();	return (-1);    }    i = pRun->prio;    pRun->prio = prio;    prio_enQ (pAQ, deQ (pRun));    ki_task_shift ();    EI ();    return (i);}

unsigned char midi_out_send_standard_msg(unsigned char status, unsigned char data1, unsigned char data2){	unsigned char buffer_loc;	if(msg_buffer_size < (MIDI_MSG_BUFFER_SIZE - 2)) {		DI();				buffer_loc = (msg_buffer_current + msg_buffer_size) % MIDI_MSG_BUFFER_SIZE;		midi_msg_buffer[buffer_loc] = status;		msg_buffer_size++;		buffer_loc = (msg_buffer_current + msg_buffer_size) % MIDI_MSG_BUFFER_SIZE;		midi_msg_buffer[buffer_loc] = data1;		msg_buffer_size++;		buffer_loc = (msg_buffer_current + msg_buffer_size) % MIDI_MSG_BUFFER_SIZE;		midi_msg_buffer[buffer_loc] = data2;		msg_buffer_size++;		//trigger the interrupt if already ready to transmit		if((U1STAT0 & UART1_TRAN_RDY) && 		   ((IRQ2SET & UART1_IRQ_EN) == 0)) {			IRQ2SET |= UART1_IRQ_EN;		}		EI();	}	else {		return 1;	}	return 0;}

/** Initializes audsrv library    @returns error code*/int audsrv_init(){	int ret;	if (initialized)	{		/* already done */		return 0;	}	memset(&cd0, '/0', sizeof(cd0));	while (1)	{		if (SifBindRpc(&cd0, AUDSRV_IRX, 0) < 0)		{			set_error(AUDSRV_ERR_RPC_FAILED);			return -1;		} 		if (cd0.server != 0)		{			break;		}		nopdelay();	}	ee_sema_t compSema;	compSema.init_count = 1;	compSema.max_count = 1;	compSema.option = 0;	completion_sema = CreateSema(&compSema);	if (completion_sema < 0)	{		set_error(AUDSRV_ERR_FAILED_TO_CREATE_SEMA);		return -1;	}	SifCallRpc(&cd0, AUDSRV_INIT, 0, sbuff, 64, sbuff, 64, NULL, NULL);	ret = sbuff[0];	if (ret != 0)	{		set_error(ret);		return ret;	}	/* register a callback handler */	DI();	SifAddCmdHandler(AUDSRV_CDDA_CALLBACK, cdda_stopped, NULL);	SifAddCmdHandler(AUDSRV_FILLBUF_CALLBACK, fillbuf_requested, NULL);	EI();	/* initialize IOP heap (for adpcm samples) */	SifInitIopHeap();	set_error(AUDSRV_ERR_NOERROR);	return AUDSRV_ERR_NOERROR;}

void DNF::setup_names()    {    if (pres_debug>=2)	fprintf(DebugFile,"Setting up names for DNF 0x%p/n", this);    for(DNF_Iterator DI(this); DI.live(); DI.next()) 	  DI.curr()->setup_names();    }