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

/******************************************************************************** xorWinOverlapDetect - Detect XOR address windows overlaping** DESCRIPTION:*       An unpredicted behaviour is expected in case XOR address decode*       windows overlaps.*       This function detects XOR address decode windows overlaping of a*       specified window. The function does not check the window itself for*       overlaping. The function also skipps disabled address decode windows.** INPUT:*       winNum      - address decode window number.*       pAddrDecWin - An address decode window struct.** OUTPUT:*       None.** RETURN:*       MV_TRUE if the given address window overlap current address*       decode map, MV_FALSE otherwise, MV_ERROR if reading invalid data*       from registers.********************************************************************************/static MV_STATUS xorWinOverlapDetect(MV_U32 unit, MV_U32 winNum,	MV_ADDR_WIN *pAddrWin){	MV_U32 baseAddrEnableReg;	MV_U32 winNumIndex, chan;	MV_UNIT_WIN_INFO addrDecWin;	if (pAddrWin == NULL) {		DB(mvOsPrintf("%s: ERR. pAddrWin is NULL pointer/n",  __func__));		return MV_BAD_PTR;	}	for (chan = 0; chan < MV_XOR_MAX_CHAN_PER_UNIT; chan++) {		/* Read base address enable register. Do not check disabled windows     */		baseAddrEnableReg = MV_REG_READ(XOR_WINDOW_CTRL_REG(unit, chan));		for (winNumIndex = 0; winNumIndex < XOR_MAX_ADDR_DEC_WIN; winNumIndex++) {			/* Do not check window itself */			if (winNumIndex == winNum)				continue;			/* Do not check disabled windows */			if ((baseAddrEnableReg & XEXWCR_WIN_EN_MASK(winNumIndex)) == 0)				continue;			/* Get window parameters */			if (MV_OK != mvXorTargetWinRead(unit, winNumIndex, &addrDecWin)) {				DB(mvOsPrintf("%s: ERR. TargetWinGet failed/n",  __func__));				return MV_ERROR;			}			if (MV_TRUE == mvWinOverlapTest(pAddrWin, &(addrDecWin.addrWin)))				return MV_TRUE;		}	}	return MV_FALSE;}

omni_thread::init_t::init_t(void){    if (count++ != 0)	// only do it once however many objects get created.	return;    DB(cerr << "omni_thread::init: NT implementation initialising/n");    self_tls_index = TlsAlloc();    if (self_tls_index == 0xffffffff)	throw omni_thread_fatal(GetLastError());    next_id_mutex = new omni_mutex;    //    // Create object for this (i.e. initial) thread.    //    omni_thread* t = new omni_thread;    t->_state = STATE_RUNNING;    if (!DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),			 GetCurrentProcess(), &t->handle,			 0, FALSE, DUPLICATE_SAME_ACCESS))	throw omni_thread_fatal(GetLastError());    t->nt_id = GetCurrentThreadId();    DB(cerr << "initial thread " << t->id() << " NT thread id " << t->nt_id       << endl);    if (!TlsSetValue(self_tls_index, (LPVOID)t))	throw omni_thread_fatal(GetLastError());    if (!SetThreadPriority(t->handle, nt_priority(PRIORITY_NORMAL)))	throw omni_thread_fatal(GetLastError());}

struct direct *readdir (DIR *dir){  struct FAB *dfab = &dir->fab;  struct NAM *dnam = (struct NAM *)(dfab->fab$l_nam);  struct direct *dentry = &dir->dir;  int i;  memset (dentry, 0, sizeof *dentry);  dnam->nam$l_rsa = dir->d_result;  dnam->nam$b_rss = MAXNAMLEN;  DB (DB_VERBOSE, ("."));  if (!((i = sys$search (dfab)) & 1))    {      DB (DB_VERBOSE, (_("sys$search() failed with %d/n"), i));      return (NULL);    }  dentry->d_off = 0;  if (dnam->nam$w_fid == 0)    dentry->d_fileno = 1;  else    dentry->d_fileno = dnam->nam$w_fid[0] + (dnam->nam$w_fid[1] << 16);  dentry->d_reclen = sizeof (struct direct);  dentry->d_namlen = dnam->nam$b_name + dnam->nam$b_type;  strncpy (dentry->d_name, dnam->nam$l_name, dentry->d_namlen);  dentry->d_name[dentry->d_namlen] = '/0';#ifdef HAVE_CASE_INSENSITIVE_FS  uppercasify (dentry->d_name);#endif  return (dentry);}

voidRenderArea::on_realize() {    try {        DB(cerr << "on_realize called" << endl);        queue_draw();    } catch (const asl::Exception & ex) {        AC_FATAL << "Exception caught: " << ex;    } catch (const exception & ex) {        AC_FATAL << "Exception caught: " << ex.what();    } catch (...) {        AC_FATAL << "Unknown exception";    }    Gtk::DrawingArea::on_realize();}

static void FreeChannel_m(VP_cl *self, Channel_Endpoint ep ){    dcb_rw_t     *rwp = RW(self);    dcb_ro_t     *rop = RO(self);    ep_rw_t      *eprw;    ep_ro_t      *epro;    if ( ep >= rop->num_eps ) {	DB(eprintf("VP$FreeChannel: invalid EP./n"));	RAISE_Channel$Invalid( ep );    }    epro = DCB_EPRO(rop,ep);    eprw = DCB_EPRW(rop,ep);    if ( epro->peer_dcb != NULL || eprw->state == Channel_State_Free ) {	DB(eprintf("VP$FreeChannel: Bad State./n"));	RAISE_Channel$BadState( ep, eprw->state );    }        eprw->state = Channel_State_Free;    eprw->ack   = (word_t)(rwp->free_eps);    rwp->free_eps = eprw;}

static void common_init(Flash *fls){	memset(fls, 0, sizeof(*fls));	DB(fls->blk.priv.type = KBT_FLASH);	fls->hw = &flash_stm32_hw;	fls->blk.blk_size = FLASH_PAGE_SIZE;	fls->blk.blk_cnt = (F_SIZE * 1024) / FLASH_PAGE_SIZE;	/* Unlock flash memory for the FPEC Access */	EMB_FLASH->KEYR = FLASH_KEY1;	EMB_FLASH->KEYR = FLASH_KEY2;}

static void gtk_dateentry_calendar_year(GtkWidget *calendar, GtkDateEntry *dateentry){guint year, month, day;	DB( g_print(" (dateentry) year changed/n") );	gtk_calendar_get_date (GTK_CALENDAR (dateentry->calendar), &year, &month, &day);	if( year < 1900)		g_object_set(calendar, "year", 1900, NULL);	if( year > 2200)		g_object_set(calendar, "year", 2200, NULL);	}

/** * Init serial driver for /a unit. * * Use values SER_UARTn as values for /a unit. */void ser_init(struct Serial *fds, unsigned int unit){	memset(fds, 0, sizeof(*fds));	DB(fds->fd._type = KFT_SERIAL);	fds->fd.reopen = ser_reopen;	fds->fd.close = ser_close;	fds->fd.read = ser_read;	fds->fd.write = ser_write;	fds->fd.flush = ser_flush;	fds->fd.error = ser_error;	fds->fd.clearerr = ser_clearerr;	ser_open(fds, unit);}

RenderArea::RenderArea(RenderAreaPtr theContext) : AbstractRenderWindow(jslib::JSApp::ShellErrorReporter),    _myContextRefCount(0),    _isFirstFrame(true){    GdkGLConfig * myGLConfig = gdk_gl_config_new_by_mode(                GdkGLConfigMode(GDK_GL_MODE_RGBA | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE | GDK_GL_MODE_ALPHA));    if (myGLConfig == 0) {        throw asl::Exception("can't init GL",PLUS_FILE_LINE);    }    // If another render area is supplied as constructor paramter, this render area is uses as    // source for a shared y60-gl-context and gdk-gl-context.    GdkGLContext * myGdkGLContext = 0;    if (theContext) {        myGdkGLContext = theContext->getGdkGlContext();        if (!myGdkGLContext) {            throw asl::Exception("RenderArea: Failed to get gdk GL context from shared render area.", PLUS_FILE_LINE);        }        setGLContext(theContext->getGLContext());    } else {        setGLContext(GLContextPtr(new GLContext()));    }    /* Set OpenGL-capability to the widget. */    DB(cerr << "RenderArea::RenderArea() sharing with " << myGdkGLContext << endl);    if (!gtk_widget_set_gl_capability (GTK_WIDGET(gobj()),                myGLConfig,                myGdkGLContext,                true,                GDK_GL_RGBA_TYPE))    {        throw asl::Exception("RenderArea: could not create GL context!", PLUS_FILE_LINE);    }    // enable mouse events    Gdk::EventMask flags = get_events();    flags |= Gdk::BUTTON_PRESS_MASK;    flags |= Gdk::POINTER_MOTION_MASK;    flags |= Gdk::BUTTON_RELEASE_MASK;    flags |= Gdk::SCROLL_MASK;    flags |= Gdk::ENTER_NOTIFY_MASK;    flags |= Gdk::LEAVE_NOTIFY_MASK;    set_events(flags);    y60::EventDispatcher::get().addSource(&_myEventAdapter);    y60::EventDispatcher::get().addSink(this);    // TODO: createRenderer(theOtherRenderer);    ShaderLibrary::setGLisReadyFlag(true);}

bool PhotoCommentQuery(PacketHandlerData d){	NetPacket *p;	p = d.pkt;	bool ret = true;	int min, max;	min = NetGetNumberData(p, "min");	max = NetGetNumberData(p, "max");	PhotoComment *plist;	NetPacket *pkt;	int len;	pkt = NetCreatePacket();	plist = QueryPhotoCommentList(DB(d),NetGetNumberData(p, "photo_id")							, min, max, &len);	if(plist == NULL){		pkt->header.type = PHOTO_COMMENT_QUERY_FAILED;		NetAddStringData(pkt, "reason", REASON_MEMORY_ERROR);		goto CleanUp;	}	else		pkt->header.type = PHOTO_COMMENT_INFO;	NetAddNumberData(pkt, "count", len);	for(int i=0;i<len;i++){		char msg[8];		sprintf(msg,"i%d", i+1);		NetAddStringData(pkt, msg, plist[i].id);		sprintf(msg,"c%d", i+1);		NetAddStringData(pkt, msg, plist[i].comment);		sprintf(msg,"pi%d", i+1);		NetAddNumberData(pkt, msg, plist[i].photo_id);		sprintf(msg,"t%d", i+1);		NetAddNumberData(pkt, msg, plist[i].time);	}CleanUp:	NetSendPacket(d.handle,d.io,pkt);	NetDisposePacket(pkt, true);	free(plist);	return ret;}

/* Clean up after an error. The caller should usually call do_request()   after this function returns. It can be called from an IRQ handler or the   normal kernel context. */void handle_error(const char *from){    u_long flags;    if(current_req == NULL)	return;    save_flags(flags);    cli();    kprintf("/nfd: %s (%s): Error (retry number %d)/n",        from, REQ_FD_DEV(current_req)->name, current_req->retries);    dump_stat();    fd_intr = NULL;    if(current_req->retries++ < MAX_RETRIES)    {#if 0	if((current_req->retries % RESET_FREQ) == 0)	    reset_pending = TRUE;#endif	if((current_req->retries % RECAL_FREQ) == 0)	    REQ_FD_DEV(current_req)->recalibrate = TRUE;	/* Retry the current request, this simply means stacking it on the	   front of the queue and calling do_request(). */	prepend_node(&fd_reqs, &current_req->node);	current_req = NULL;	DB(("fd:handle_error: Retrying request %p/n", current_req));    }    else    {#if 0	reset_pending = TRUE;#endif	REQ_FD_DEV(current_req)->recalibrate = TRUE;	DB(("/nfd: handle_error: Request %p has no more retries available./n",	    current_req));	fd_end_request(-1);    }    load_flags(flags);}

/******************************************************************************** mvXorSetProtWinSet - Configure access attributes of a XOR engine*                               to one of the XOR memory windows.** DESCRIPTION:*       Each engine can be configured with access attributes for each of the*       memory spaces. This function sets access attributes*       to a given window for the given engine** INPUTS:*       chan    - One of the possible engines.*       winNum  - One of the possible XOR memory spaces.*       access  - Protection access rights.*       write   - Write rights.** OUTPUT:*       None.** RETURN:*       MV_BAD_PARAM if parameters to function invalid, MV_OK otherwise.********************************************************************************/MV_STATUS mvXorProtWinSet(MV_U32 unit, MV_U32 chan, MV_U32 winNum, MV_BOOL access, MV_BOOL write){	MV_U32 temp;	/* Parameter checking   */	if (chan >= MV_XOR_MAX_CHAN_PER_UNIT) {		DB(mvOsPrintf("%s: ERR. Invalid chan num %d/n",  __func__, chan));		return MV_BAD_PARAM;	}	if (winNum >= XOR_MAX_ADDR_DEC_WIN) {		DB(mvOsPrintf("%s: ERR. Invalid win num %d/n",  __func__, winNum));		return MV_BAD_PARAM;	}	temp = MV_REG_READ(XOR_WINDOW_CTRL_REG(unit, chan)) & (~XEXWCR_WIN_ACC_MASK(winNum));	/* if access is disable */	if (!access) {		/* disable access */		temp |= XEXWCR_WIN_ACC_NO_ACC(winNum);	}	/* if access is enable */	else {		/* if write is enable */		if (write) {			/* enable write */			temp |= XEXWCR_WIN_ACC_RW(winNum);		}		/* if write is disable */		else {			/* disable write */			temp |= XEXWCR_WIN_ACC_RO(winNum);		}	}	MV_REG_WRITE(XOR_WINDOW_CTRL_REG(unit, chan), temp);	return MV_OK;}

USHORT	CHalWaveDevice::Service()// Called at interrupt time to service the circular buffer/////////////////////////////////////////////////////////////////////////////{	ULONG	ulReason = kReasonWave;	//DC('W');	//DPF(("CHalWaveDevice::Service: "));	//DB('s',COLOR_BOLD);	DX8( (BYTE)m_ulDeviceNumber, COLOR_NORMAL );	// go see why we were called	ULONG	ulStreamStatus = m_RegStreamStatus.Read();	//ULONG	ulStreamControl = m_RegStreamControl.Read();	//DC('[');	//DX16( (USHORT)(ulStreamStatus & REG_STREAMSTAT_L2PTR_MASK), COLOR_NORMAL );	//DC(',');	//DX16( (USHORT)(ulStreamControl & REG_STREAMCTL_PCPTR_MASK), COLOR_NORMAL );	//DC(']');	//DPF(("Stream Status %08lx/n", ulStreamStatus ));	// was the limit hit bit set?	if( ulStreamStatus & REG_STREAMSTAT_LIMHIT )	{		//DC('L');		//DPF(("Limit Hit/n"));	}	// was the overrun bit set?	if( ulStreamStatus & REG_STREAMSTAT_OVER )	{		DB('O',COLOR_BOLD);		m_ulOverrunCount++;		DPF(("/nCHalWaveDevice: Overrun Detected %ld/n", m_ulOverrunCount ));		ulReason = kReasonWaveEmpty;	}	if( m_usMode != MODE_RUNNING )	{		//DPF(("<%02ld %08lx %08lx>", m_ulDeviceNumber, m_RegStreamControl.Read(), ulStreamStatus ));		Stop();		//DPF(("Interrupt Detected on IDLE device %02ld/n", m_ulDeviceNumber ));		return( HSTATUS_INVALID_MODE );	}	// let the driver service the interrupt for this device	CHalDevice::Service( ulReason );	return( HSTATUS_OK );}

void sched.insert(int d, object* who)/*	schedule THIS to run in ``d'' time units	inserted by who*/{	register sched * p;	register sched * pp;	register long tt = s_time = clock + d;DB(("%x->sched::insert( %x, %x )/n",this,d,who));	switch (s_state) {	case TERMINATED:		task_error(E_RESTERM,this);		break;	case IDLE:		break;	case RUNNING:		if (this != (class sched *)thistask) task_error(E_RESRUN,this);	}	if (d<0) task_error(E_NEGTIME,this);		if (o_next) task_error(E_RESOBJ,this);	s_state = RUNNING;	if (o_type == TASK) ((task *) this)->t_alert = who;	/* run_chain ordered by s_time */	if (p = run_chain) {		if (tt < p->s_time) {			o_next = (object*) run_chain;			run_chain = this;		}		else {			while (pp = (sched *) p->o_next) {				if (tt < pp->s_time) {					o_next = pp;					p->o_next = this;					return;				}				else p = pp;			}			p->o_next = this;		}	}	else 		run_chain = this;}

/******************************************************************************** ahbToMbusRemapRegOffsGet - Get CPU address remap register offsets** DESCRIPTION:* 		CPU to PCI address remap registers offsets are inconsecutive. *		This function returns PCI address remap registers offsets.** INPUT:*       cpu      	- CPU id*       winNum - Address decode window number. See MV_U32 enumerator.** OUTPUT:*       None.** RETURN:*		MV_ERROR if winNum is not a PCI one.********************************************************************************/static MV_STATUS ahbToMbusRemapRegOffsGet(MV_U32 cpu, MV_U32 winNum, 					    AHB_TO_MBUS_REMAP_REG_OFFS *pRemapRegs){	pRemapRegs->lowRegOffs  = AHB_TO_MBUS_WIN_REMAP_LOW_REG(cpu, winNum);	pRemapRegs->highRegOffs = AHB_TO_MBUS_WIN_REMAP_HIGH_REG(cpu, winNum);	if ((pRemapRegs->lowRegOffs == 0) || (pRemapRegs->highRegOffs == 0))	{			DB(mvOsPrintf("ahbToMbusRemapRegOffsGet: ERR. Invalid winNum %d/n", 						winNum));		   	return MV_NO_SUCH;	}	return MV_OK;}

/** * Init serial driver for a usb-serial port /a unit. * * /return 0 if OK, a negative value in case of error. */int usbser_init(struct USBSerial *fds, int unit){    memset(fds, 0, sizeof(*fds));    DB(fds->fd._type = KFT_USB_SERIAL);    fds->fd.reopen = usb_serial_reopen;    fds->fd.close = usb_serial_close;    fds->fd.read = usb_serial_read;    fds->fd.write = usb_serial_write;    /* TODO: properly implement error handling. */    fds->fd.error = usb_serial_error;    fds->fd.clearerr = usb_serial_clearerr;    return usb_serial_open(fds, unit);}

static inline voidmap_cga_buffer(struct video *v, bool phys_buf){    int i;    DB(("map_cga_buffer: v=%p phys_buf=%#d/n", v, phys_buf));    forbid();    for(i = 0; i < 4; i++)    {	kernel->set_pte(v->task->page_dir, CGA_VIDEO_MEM + (i * PAGE_SIZE),			(phys_buf ? (CGA_VIDEO_MEM + (i * PAGE_SIZE))			 : TO_PHYSICAL(v->data.cga.video_buffer[i])) | PTE_USER			| PTE_READ_WRITE | PTE_PRESENT);    }    permit();}

 double MovieDecoderBase::getMovieTime(double theSystemTime) {     DB(AC_TRACE << "getMovieTime start: _myMovieTime: " << _myMovieTime             << ", theSystemTime: " << theSystemTime << ", _myLastSystemTime: "             << _myLastSystemTime);     if (theSystemTime <= _myLastSystemTime) {         return _myMovieTime;     }     float myPlaySpeed = _myMovie->get<PlaySpeedTag>();     if (_myLastSystemTime >= 0) {         _myMovieTime += (theSystemTime - _myLastSystemTime) * myPlaySpeed;         // disabled this code, cause looping movie playback failed with new ffmpeg: the enforced wraparound here is not needed anymore(vs, 2014)         // if difference between last system time and current system time is bigger than movie duration         /*if (getFrameCount() != -1 && _myMovieTime * getFrameRate() > getFrameCount()) {             _myMovieTime = getFrameCount() / getFrameRate();         }*/         // Calculate the wraparaound for reverse playback         if (_myMovieTime < 0) {             unsigned myFrameCount = getFrameCount();             if (myFrameCount == static_cast<unsigned>(-1) || myFrameCount == 0) {                 AC_WARNING << "Movie cannot play backwards, because its framecount is unknown (framecount="                            << myFrameCount << ")";                 _myMovieTime = 0;             } else {                 double myIncrement = getFrameCount() / getFrameRate();                 while (_myMovieTime < 0) {                     _myMovieTime += myIncrement;                 }             }         }     }     _myLastSystemTime = theSystemTime;     DB(AC_TRACE << "getMovieTime end: _myMovieTime: " << _myMovieTime             << ", theSystemTime: " << theSystemTime << ", _myLastSystemTime: "             << _myLastSystemTime);     return _myMovieTime; }

void kfileblock_init(KFileBlock *fb, KBlock *blk){	ASSERT(fb);	ASSERT(blk);	memset(fb, 0, sizeof(*fb));	kfile_init(&fb->fd);	DB(fb->fd._type = KFT_KFILEBLOCK);	fb->blk = blk;	fb->fd.size = blk->blk_cnt * blk->blk_size;	fb->fd.read = kfileblock_read;	fb->fd.write = kfileblock_write;	fb->fd.flush = kfileblock_flush;	fb->fd.error = kfileblock_error;	fb->fd.clearerr = kfileblock_clearerr;	fb->fd.close = kfileblock_close;}

/******************************************************************************** mvFlashErase - Completly Erase a flash.** DESCRIPTION:*       This function completly erase the given flash, by erasing all the*		flash sectors one by one (Currently there is no support for HW*		flash erase).** INPUT:*       pFlash - Flash identifier structure.** OUTPUT:*       None.** RETURN:*	MV_BAD_PARAM if pFlash is NULL,*   MV_OK if erased completed successfully,*	MV_FAIL otherwise.********************************************************************************/MV_STATUS mvFlashErase(MV_FLASH_INFO *pFlash){	MV_U32 i;	if (NULL == pFlash)		return MV_BAD_PARAM;	DB(mvOsPrintf("Flash: mvFlashErase /n"));	/* erase all sectors in the flash one by one */	for (i = 0; i < mvFlashNumOfSecsGet(pFlash); i++) {		if (MV_OK != mvFlashSecErase(pFlash, i))			return MV_FAIL;	}	return MV_OK;}

/** * Init AVR flash read/write file. */void flash_hw_init(struct Flash *fd){	memset(fd, 0, sizeof(*fd));	DB(fd->fd._type = KFT_FLASH);	// Set up flash programming functions.	fd->fd.reopen = flash_avr_reopen;	fd->fd.close = flash_avr_close;	fd->fd.read = flash_avr_read;	fd->fd.write = flash_avr_write;	fd->fd.seek = kfile_genericSeek;	fd->fd.flush = flash_avr_kfileFlush;	fd->curr_page = 0;	flash_avr_open(fd);}

/** * Initialize an USB serial port. * * /param fds KFile Serial struct interface. * /param unit Serial unit to open. */static int usb_serial_open(struct USBSerial *fds, int unit){    unit = unit;    ASSERT(!fds->is_open);    /* TODO: only a single usb-serial unit is supported for now */    ASSERT(unit == 0);    /* Initialize usb-serial driver */    if (usb_serial_hw_init() < 0)        return -1;    /* Clear error flags */    fds->status = 0;    DB(fds->is_open = true);    return 0;}

bool CmdDBJobsList::processArguments( int argc, char** argv, af::Msg &msg){   afsql::DBConnection DB( "afanasy.cmd.JobsList");   DB.DBOpen();   std::list<int> jids = DB.getIntegers( afsql::DBJob::dbGetIDsCmd());   for( std::list<int>::const_iterator it = jids.begin(); it != jids.end(); it++)   {      afsql::DBJob job( *it);      DB.getItem( &job);      job.stdOut( false);   }   DB.DBClose();   return true;}

AVPacket * Demux::getPacket(const int theStreamIndex){    DB(AC_TRACE << "Demux::getPacket for stream: " << theStreamIndex);    if (_myPacketLists.find(theStreamIndex) == _myPacketLists.end()) {        AC_ERROR << "Demux::getPacket called with nonexistent stream index "            << theStreamIndex << ".";    }    PacketList & myCurPacketList = _myPacketLists.find(theStreamIndex)->second;    if (!myCurPacketList.empty()) {        DB(AC_TRACE << "Demux::getPacket: packet already there.");        AVPacket * myPacket = myCurPacketList.front();        myCurPacketList.pop_front();        return myPacket;    } else {        DB(AC_TRACE << "Demux::getPacket: packet needs to be read.");        AVPacket * myPacket;        do {            DB(AC_TRACE << "Demux::getPacket: read.");            myPacket = new AVPacket;            memset(myPacket, 0, sizeof(AVPacket));            bool myEndOfFileFlag = (av_read_frame(_myFormatContext, myPacket) < 0);            if (myEndOfFileFlag) {                AC_DEBUG << "Demux::getPacket: end of file.";                av_free_packet(myPacket);                delete myPacket;                myPacket = 0;                return 0;            }            if (myPacket->stream_index != theStreamIndex) {                if (_myPacketLists.find(myPacket->stream_index) != _myPacketLists.end()) {                    DB(AC_TRACE << "Demux::getPacket: caching packet.");                    // Without av_dup_packet, ffmpeg reuses myPacket->data at first                    // opportunity and trashes our memory.                    av_dup_packet(myPacket);                    PacketList& myOtherPacketList =                            _myPacketLists.find(myPacket->stream_index)->second;                    myOtherPacketList.push_back(myPacket);                } else {                    DB(AC_DEBUG << "Demux::getPacket: rejecting packet.");                    av_free_packet(myPacket);                    delete myPacket;                    myPacket = 0;                }            }        } while (!myPacket || myPacket->stream_index != theStreamIndex);        DB(AC_TRACE << "Demux::getPacket: end.");        return myPacket;    }}

/* Perform the GNU make expansion function.  */static SCMguile_expand_wrapper (SCM obj){  char *str = cvt_scm_to_str (obj);  SCM ret;  char *res;  DB (DB_BASIC, (_("guile: Expanding '%s'/n"), str));  res = allocated_variable_expand (str);  ret = scm_from_locale_string (res);  free (str);  free (res);  return ret;}

/******************************************************************************** mvNflashInit - Initialize the Flash indetifier structure.** DESCRIPTION:*		This function initialize the Flash indetifier structure. *		Note that this function must be called only after the MV_NFLASH_HW_IF*		field in the MV_NFLASH_INFO was initialized by the BSP. Only then *		access to nflash is possible.** INPUT:*		pFlash - flash information.** OUTPUT:*		Initialize MV_NFLASH_INFO Nflash identifier struct.*		** RETURN:*		MV_ERROR if device and vendor ID can't be read.*		MV_OK otherwise.********************************************************************************/MV_STATUS mvNflashInit(MV_NFLASH_INFO *pFlash){	MV_U16 flashId;	int i = 0;    	if(NULL == pFlash)		return 0;	/* Initialize base address and device width from BSP */	pFlash->baseAddr = pFlash->nflashHwIf.devBaseAddr;	pFlash->devWidth = pFlash->nflashHwIf.devWidth;		    /* Initialize HW interface */    mvNflashHwIfInit(&pFlash->nflashHwIf);	/* Read the device and vendor ID */	flashId = mvNflashIdGet(pFlash);	/* check if this flash is Supported, and Init the pFlash flash feild */	    while((supNflashAry[i].devVen != ((flashId << VENDOR_ID_OFFS) & 0xFF) && 		  (supNflashAry[i].devId  != ((flashId << DEVICE_ID_OFFS) & 0xFF))))	{				if (i++ == (sizeof(supNflashAry) / sizeof(supNflashAry[0])))		{			mvOsPrintf("mvNflashInit: Unsupported Flash ID 0x%x./n", flashId);			return MV_ERROR;		}	}	pFlash->pNflashStruct = &supNflashAry[i];	/* Init pFlash sectors */		/*	if(MV_OK != flashSecsInit(pFlash))	{		mvOsPrintf("Flash: ERROR mvFlashInit flashSecsInit failed /n");		return 0;	}*/	    /* print all flash information */	DB(mvNflashPrint(pFlash));	/* reset the Flash */	mvNflashReset(pFlash);	return MV_OK;	}

bool LocationQuery(PacketHandlerData d){	NetPacket *p;	p = d.pkt;	bool ret = true;	int min, max;	Location *plist;	NetPacket *pkt;	int len;	pkt = NetCreatePacket();	printf("ASDF");	plist = QueryLocation(DB(d)							, &len);	if(plist == NULL){		pkt->header.type = LOCATION_QUERY_FAILED;		NetAddStringData(pkt, "reason", REASON_MEMORY_ERROR);		goto CleanUp;	}	else		pkt->header.type = LOCATION_INFO;	NetAddNumberData(pkt, "count", len);	for(int i=0;i<len;i++){		char msg[8];		sprintf(msg,"lt%d", i+1);		NetAddNumberData(pkt, msg, plist[i].lat);		sprintf(msg,"ln%d", i+1);		NetAddNumberData(pkt, msg, plist[i].lon);		sprintf(msg,"i%d", i+1);		NetAddStringData(pkt, msg, plist[i].id);	}CleanUp:	NetSendPacket(d.handle,d.io,pkt);	NetDisposePacket(pkt, true);	free(plist);	return ret;}

static intmaru_kue_free_callback(void *data, int len){    struct maru_message *msg = data;    struct buf *bp;    struct maru_token *tok;    DB("maru_free_callback(%p, %d)/n", data, len);    tok = maru_find_token(msg->mm_id);    free(msg, M_DEVBUF);    if (!tok)	return (EINVAL);    bp = tok->qt_bp;    maru_release_token(tok);    if (bp)	maru_berror(bp, ENXIO);    return 0;}