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

/* call a callback function for each used channel */BOOLcm__chan_foreach(BOOL (*func)(), VOID *a1, VOID *a2){    INT     n;    BOOL    ret = TRUE;    D_LOG(D_ENTRY, ("cm__chan_foreach: entry, func: %lx, a1: 0x%lx, a2: 0x%lx", /                                    func, a1, a2));    for ( n = 0 ; n < MAX_CHAN_IN_SYSTEM ; n++ )        if ( chan_used[n] )        {			CM_CHAN		*chan = chan_tbl + n;            D_LOG(D_ALWAYS, ("cm__chan_foreach: calling for chan# %d, channel: %lx", n, chan));            ret = (*func)(chan, a1, a2);            D_LOG(D_ALWAYS, ("cm__chan_foreach: returned %d", ret));            if ( !ret )                break;        }    return(ret);}

/* find a matching listening connection */CM*cm__find_listen_conn(CHAR *lname, CHAR *rname, CHAR *addr, VOID *Idd){    CM          *cm;    ULONG       n;    D_LOG(D_ENTRY, ("cm__find_listen_conn: entry, lname: [%s], rname: [%s], addr: [%s]", /                            lname, rname, addr));    /* scan connection table */    for ( n = 0; n < MAX_CM_IN_SYSTEM ; n++)	{		cm = cm_tbl[n];        if ( cm_used[n] && (cm->idd == Idd) && (cm->state == CM_ST_LISTEN) )        {            D_LOG(D_ENTRY, ("cm__find_listen_conn: comparing to: name: [%s], remote_name: [%s]", /                                    cm->dprof.name, cm->dprof.remote_name));            if ( cm__match_str(cm->dprof.name, rname) &&                 cm__match_str(cm->dprof.remote_name, lname) )                return(cm);        }	}    return(NULL);}

cl_int MemoryObjectWrapper::createSubBuffer (cl_mem_flags aFlags,                                             RegionWrapper const& aRegion,                                             MemoryObjectWrapper** aResultOut) {#if CL_WRAPPER_CL_VERSION_SUPPORT >= 110    D_METHOD_START;    cl_int err = CL_SUCCESS;    VALIDATE_ARG_POINTER (aResultOut, &err, err);    cl_buffer_region region;    region.origin = aRegion.origin;    region.size = aRegion.size;    cl_mem mem = clCreateSubBuffer (mWrapped, aFlags, CL_BUFFER_CREATE_TYPE_REGION,                                 (void const*)&region, &err);    if (err != CL_SUCCESS || !mem)        D_LOG (LOG_LEVEL_ERROR, "clCreateSubBuffer failed. (error %d)", err);    // NOTE: clCreateSubBuffer can return an existing handle.    *aResultOut = MemoryObjectWrapper::getNewOrExisting (mem);    return err;#else // CL_WRAPPER_CL_VERSION_SUPPORT >= 110    (void)aFlags; (void)aRegion; (void)aResultOut;    D_LOG (LOG_LEVEL_ERROR, "CLWrapper support for OpenCL 1.1 API was not enabled at build time.");    return CL_INVALID_VALUE;#endif}

voiddirect_trap( const char *domain, int sig ){     sigval_t val;     if (direct_config->delay_trap_ms) {          D_LOG( Direct_Trap, VERBOSE, "NOT RAISING signal %d from %s, waiting for %dms... attach gdb --pid=%d/n", sig, domain, direct_config->delay_trap_ms, getpid() );          direct_thread_sleep( direct_config->delay_trap_ms * 1000LL );          return;     }     D_LOG( Direct_Trap, VERBOSE, "Raising signal %d from %s.../n", sig, domain );     val.sival_int = direct_gettid();#ifndef DIRECT_BUILD_NO_SIGQUEUE     sigqueue( direct_gettid(), sig, val );#endif//     direct_tgkill( direct_getpid(), direct_gettid(), sig );     D_LOG( Direct_Trap, VERBOSE, "...tgkill(%d) on ourself returned, maybe blocked, calling abort()!/n", sig );     abort();     D_LOG( Direct_Trap, VERBOSE, "...abort() returned as well, calling %s()!/n",#ifdef __NR_exit_group            "exit_group" );     syscall( __NR_exit_group, DR_BUG );#else            "_exit" );            _exit( DR_BUG );#endif}

/* add a channel to channel table */mtl_add_chan(VOID *mtl_1, VOID *idd, USHORT bchan, ULONG speed, ULONG ConnectionType){	MTL	*mtl = (MTL*)mtl_1;    INT         ret = MTL_E_SUCC;    MTL_CHAN    *chan;    INT         n;    D_LOG(D_ENTRY, ("mtl_add_chan: entry, mtl: 0x%lx, idd: 0x%lx, bchan: %d, speed: 0x%x/n", /                                                      mtl, idd, bchan, speed));    /* lock */    NdisAcquireSpinLock(&mtl->chan_tbl.lock);    /* check for space */    if ( mtl->chan_tbl.num >= MAX_CHAN_PER_CONN )        ret = MTL_E_NOROOM;    else    {        /* find free slot, MUST find! */        for ( chan = mtl->chan_tbl.tbl, n = 0 ; n < MAX_CHAN_PER_CONN ; n++, chan++ )            if ( !chan->idd )                break;        if ( n >= MAX_CHAN_PER_CONN )        {            D_LOG(DIGIMTL, ("mtl_add_chan: not free slot when num < MAX!/n"));            ret = MTL_E_NOROOM;        }        else        {            /* slot found, fill it */            mtl->chan_tbl.num++;			if (ConnectionType == CM_DKF)			{				mtl->IddTxFrameType = IDD_FRAME_DKF;				mtl->SendFramingBits = RAS_FRAMING;			}			else			{				mtl->IddTxFrameType = IDD_FRAME_PPP;				mtl->SendFramingBits = PPP_FRAMING;			}            chan->idd = idd;            chan->bchan = bchan;            chan->speed = speed;            chan->mtl = mtl;            /* add handler for slot */            idd_attach(idd, bchan, (VOID*)mtl__rx_bchan_handler, chan);        }    }    /* release & return */    NdisReleaseSpinLock(&mtl->chan_tbl.lock);    D_LOG(D_EXIT, ("mtl_add_chan: exit, ret: %d/n", ret));    return(ret);}

/* do timer tick processing for rx side */VOIDmtl__rx_tick(MTL *mtl){    INT         n;    MTL_AS      *as;	MTL_RX_TBL	*RxTable = &mtl->rx_tbl;	//	// see if there are any receives to give to wrapper	//	IndicateRxToWrapper(mtl);	NdisAcquireSpinLock(&mtl->lock);	NdisAcquireSpinLock(&RxTable->lock);    /* scan assembly table */    for ( n = 0, as = RxTable->as_tbl ; n < MTL_RX_BUFS ; n++, as++ )    {        /* update ttl & check */        if ( as->tot && !(as->ttl -= 25) )        {			D_LOG(D_ALWAYS, ("mtl__rx_bchan_handler: Pkt Kill ttl = 0: Slot: %d, mtl: 0x%p", n, mtl));			D_LOG(D_ALWAYS, ("AS Timeout! mtl: 0x%p, as: 0x%p, as->seq: 0x%x", mtl, as, as->seq));			D_LOG(D_ALWAYS, ("as->tot: %d, as->num: %d", as->tot, as->num));			RxTable->TimeOutReceiveError1++;			//			// if this guy was queued for indication to wrapper			// and was not indicated within a second something is wrong			//			if (as->Queued)			{				D_LOG(D_ALWAYS, ("AS Timeout while queued for indication! mtl: 0x%p, as: 0x%p", mtl, as));#if	DBG				DbgBreakPoint();#endif			}            as->tot = 0;			//			// mark this guy as being free			//			as->Queued = 0;        }    }	NdisReleaseSpinLock(&RxTable->lock);	NdisReleaseSpinLock(&mtl->lock);}

/* get mac mtu on connection */mtl_get_mac_mtu(VOID *mtl_1, ULONG *mtu){	MTL	*mtl = (MTL*)mtl_1;    D_LOG(D_ENTRY, ("mtl_get_mac_mtu: entry, mtl: 0x%lx, @mtu: 0x%lx/n", mtl, mtu));    *mtu = MTL_MAC_MTU;    D_LOG(D_EXIT, ("mtl_get_mac_mtu: exit, mtu: %ld/n", *mtu));    return(MTL_E_SUCC);}

/* handler for trace and dump area data packets */VOIDtrc__cmd_handler(VOID *idd_1, USHORT chan, ULONG Reserved, IDD_MSG *msg){    TRC         *trc;    TRC_ENTRY   *ent;	IDD	*idd = (IDD*)idd_1;	D_LOG(D_ENTRY, ("trc__cmd_handler: idd: %lx, chan: %d, msg: %lx", /								idd, chan, msg));	D_LOG(D_ENTRY, ("trc__cmd_handler: opcode: 0x%x, buflen: 0x%x, bufptr: %lx", /						msg->opcode, msg->buflen, msg->bufptr));	D_LOG(D_ENTRY, ("trc__cmd_handler: bufid: %lx, param: 0x%x", /						msg->bufid, msg->param));	// Get the trace object for this idd	trc = idd_get_trc(idd);	// if no obect exit	if (trc == NULL || msg->bufid >= 2)		return;    /* if here it is a trace frame. param is rx/tx attribute */    /* establish entry to insert into & update vars */	/* check if trace enabled */	if ( trc->stat.state == TRC_ST_STOP )		return;	D_LOG(D_ALWAYS, ("trc__cmd_handler: trc: %lx", trc));	/* check if frame filters in */	if ( !trc__filter(trc->stat.filter, msg->bufptr, msg->buflen) )		return;	/* frames needs to be buffered, establish entry pointer */	ent = trc->ent_tbl + trc->ent_put;	trc->ent_put = (trc->ent_put + 1) % trc->stat.depth;	if ( trc->ent_num < trc->stat.depth )		trc->ent_num++;	/* fill up entry */	ent->seq = trc->ent_seq++;	KeQuerySystemTime(&ent->time_stamp);	ent->attr = msg->bufid;	ent->org_len = msg->buflen;	ent->len = MIN(msg->buflen, sizeof(ent->data));	IddGetDataFromAdapter(idd,	                      (PUCHAR)ent->data,						  (PUCHAR)msg->bufptr,						  (USHORT)ent->len);//	NdisMoveMemory (ent->data, msg->bufptr, ent->len);}

static voidcall_handlers( int   num,               void *addr ){     DirectLink   *l, *n;     if (num == SIG_DUMP_STACK)          num = DIRECT_SIGNAL_DUMP_STACK;     /* Loop through all handlers. */     direct_mutex_lock( &handlers_lock );     direct_list_foreach_safe (l, n, handlers) {          DirectSignalHandler *handler = (DirectSignalHandler*) l;          if (handler->removed) {               direct_list_remove( &handlers, &handler->link );               D_MAGIC_CLEAR( handler );               D_FREE( handler );               continue;          }          D_LOG( Direct_Signals, FATAL, "    --> %d/n", handler->num );          if (handler->num != num && handler->num != DIRECT_SIGNAL_ANY)               continue;          if (handler->num == DIRECT_SIGNAL_ANY && num == DIRECT_SIGNAL_DUMP_STACK)               continue;          switch (handler->func( num, addr, handler->ctx )) {               case DSHR_OK:                    break;               case DSHR_REMOVE:                    direct_list_remove( &handlers, &handler->link );                    D_MAGIC_CLEAR( handler );                    D_FREE( handler );                    break;               case DSHR_RESUME:                    D_LOG( Direct_Signals, FATAL, "    '-> cured!/n" );                    direct_mutex_unlock( &handlers_lock );                    return;               default:                    D_BUG( "unknown result" );                    break;          }     }

cl_int EventWrapper::setUserEventStatus (cl_int aExecutionStatus) {#if CL_WRAPPER_CL_VERSION_SUPPORT >= 110    D_METHOD_START;    cl_int err = clSetUserEventStatus (mWrapped, aExecutionStatus);    if (err != CL_SUCCESS) {        D_LOG (LOG_LEVEL_ERROR, " clSetUserEventStatus failed. (error %d)", err);    }    return err;#else // CL_WRAPPER_CL_VERSION_SUPPORT >= 110    (void)aExecutionStatus;    D_LOG (LOG_LEVEL_ERROR, "CLWrapper support for OpenCL 1.1 API was not enabled at build time.");    return CL_INVALID_VALUE;#endif}

cl_int MemoryObjectWrapper::getGLObjectInfo (cl_gl_object_type *aGLObjectTypeOut,                                             cl_GLuint *aGLObjectNameOut) {#ifdef CL_WRAPPER_ENABLE_OPENGL_SUPPORT    D_METHOD_START;    cl_int err = clGetGLObjectInfo (mWrapped, aGLObjectTypeOut, aGLObjectNameOut);    if (err != CL_SUCCESS)        D_LOG (LOG_LEVEL_ERROR, "clGetGLObjectInfo failed. (error %d)", err);    return err;#else //CL_WRAPPER_ENABLE_OPENGL_SUPPORT    (void)aGLObjectTypeOut; (void)aGLObjectNameOut;    D_LOG (LOG_LEVEL_ERROR,           "CLWrapper support for OpenCL/OpenGL interoperability API was not enabled at build time.");    return CL_INVALID_VALUE;#endif //CL_WRAPPER_ENABLE_OPENGL_SUPPORT}

/* XXX: fix it to restore all registers */void tlb_fill(CPUCRISState *env1, target_ulong addr, int is_write, int mmu_idx,              uintptr_t retaddr){    TranslationBlock *tb;    CPUCRISState *saved_env;    int ret;    saved_env = env;    env = env1;    D_LOG("%s pc=%x tpc=%x ra=%p/n", __func__,          env->pc, env->debug1, (void *)retaddr);    ret = cpu_cris_handle_mmu_fault(env, addr, is_write, mmu_idx);    if (unlikely(ret)) {        if (retaddr) {            /* now we have a real cpu fault */            tb = tb_find_pc(retaddr);            if (tb) {                /* the PC is inside the translated code. It means that we have                   a virtual CPU fault */                cpu_restore_state(tb, env, retaddr);		/* Evaluate flags after retranslation.  */                helper_top_evaluate_flags();            }        }        cpu_loop_exit(env);    }    env = saved_env;}

/* free a channel */VOIDcm__chan_free(CM_CHAN *chan){    D_LOG(D_ENTRY, ("cm__chan_free: entry, chan: 0x%lx", chan));    chan_used[chan - chan_tbl] = FALSE;}

//// Allocate free channel pool//VOIDChannelInit(VOID){    NDIS_PHYSICAL_ADDRESS	pa = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1);	/* allocate memory object */    NdisAllocateMemory((PVOID*)&chan_tbl, sizeof(CM_CHAN) * MAX_CHAN_IN_SYSTEM, 0, pa);    if ( chan_tbl == NULL )    {        D_LOG(D_ALWAYS, ("ChannelInit: memory allocate failed!"));		return;    }    D_LOG(D_ALWAYS, ("ChannelInit: chan_tbl: 0x%x", chan_tbl));	NdisZeroMemory (chan_tbl, sizeof(CM_CHAN) * MAX_CHAN_IN_SYSTEM);	NdisZeroMemory (chan_used, sizeof(chan_used));}

/* XXX: fix it to restore all registers */void tlb_fill (target_ulong addr, int is_write, int mmu_idx, void *retaddr){    TranslationBlock *tb;    CPUState *saved_env;    unsigned long pc;    int ret;    /* XXX: hack to restore env in all cases, even if not called from       generated code */    saved_env = env;    env = cpu_single_env;    D_LOG("%s pc=%x tpc=%x ra=%x/n", __func__, 	     env->pc, env->debug1, retaddr);    ret = cpu_cris_handle_mmu_fault(env, addr, is_write, mmu_idx, 1);    if (unlikely(ret)) {        if (retaddr) {            /* now we have a real cpu fault */            pc = (unsigned long)retaddr;            tb = tb_find_pc(pc);            if (tb) {                /* the PC is inside the translated code. It means that we have                   a virtual CPU fault */                cpu_restore_state(tb, env, pc);		/* Evaluate flags after retranslation.  */                helper_top_evaluate_flags();            }        }        cpu_loop_exit(env);    }    env = saved_env;}

/* get connection speed, add channels from chan_tbl */mtl_get_conn_speed(VOID *mtl_1, ULONG *speed){	MTL	*mtl = (MTL*)mtl_1;    USHORT     n;    D_LOG(D_ENTRY, ("mtl_get_conn_speed: entry, mtk: 0x%lx, @speed: 0x%lx/n", mtl, speed));    /* get lock, count, release */    NdisAcquireSpinLock(&mtl->chan_tbl.lock);    for ( n = 0, *speed = 0 ; n < mtl->chan_tbl.num ; n++ )        *speed += mtl->chan_tbl.tbl[n].speed;    NdisReleaseSpinLock(&mtl->chan_tbl.lock);    D_LOG(D_EXIT, ("mtl_get_conn_speed: exit, speed: %ld bps/n", *speed));    return(MTL_E_SUCC);}

/* static */nsresult WebCLKernel::getInstance (cl_kernel aInternal, WebCLKernel** aResultOut,                                   WebCL_LibCLWrapper* aLibWrapper){  nsresult rv = NS_OK;  WebCLKernel* existing = 0;  if (instanceRegistry.findById (aInternal, &existing))  {    NS_IF_ADDREF (*aResultOut = existing);  }  else  {    nsCOMPtr<WebCLKernel> obj = do_CreateInstance (WEBCL_KERNEL_CONTRACTID, &rv);    if (NS_FAILED (rv))    {      D_LOG (LOG_LEVEL_ERROR, "Failed to create instance. rv=%d.", rv);      return rv;    }    obj->setWrapper (aLibWrapper);    obj->mInternal = aInternal;    instanceRegistry.add (obj->mInternal, obj);    NS_IF_ADDREF (*aResultOut = obj);  }  return rv;}

/* issue an element request to idp cm port */INTcm__elem_rq(VOID *idd, USHORT port, CHAR *elem_buf, USHORT elem_len){    IDD_MSG     msg;    CHAR        *p;    D_LOG(D_ENTRY|DIGIQ931, ("cm__elem_rq: entry, idd: 0x%lx, port: 0x%d, elem_buf: 0x%lx, elem_len: 0x%d/n", /                                idd, port, elem_buf, elem_len));    /* clear outgoing message */    NdisZeroMemory(&msg, sizeof(msg));    /* allocate a local buffer */    if ( !(msg.bufptr = p = ut_get_buf()) )        return(CM_E_NOMEM);    /* copy buffer */    adv_ptr(p, elem_buf, (INT)elem_len);    /* fillin message structure */    msg.opcode = Q931_ELEM_RQ;    msg.buflen = p - msg.bufptr;    /* send to idd */    if ( idd_send_msg(idd, &msg, port,                            (VOID*)cm__q931_cmpl_handler, NULL) != IDD_E_SUCC )    {        ut_free_buf(msg.bufptr);        return(CM_E_IDD);    }    return(CM_E_SUCC);}

/* control data transfer on a bchannel */INTcm__bchan_ctrl_comp(CM_CHAN *chan, ULONG CompressionFlag){    IDD_MSG     msg;   USHORT      Enable = 0;    D_LOG(D_ENTRY|DIGIQ931, ("cm__bchan_ctrl_comp: entry, chan: 0x%lx, state: %d/n", /                                                    chan, CompressionFlag));    /* channel must be assigned */    if ( !CM_BCHAN_ASSIGNED(chan->bchan) )        return(CM_E_BADCHAN);    /* map channel type to operation */    if ( CompressionFlag )      Enable = COMP_TX_ENA | COMP_RX_ENA;    /* build msg */    NdisZeroMemory(&msg, sizeof(msg));    msg.opcode = CMD_COMPRESS;    msg.bufid = MAKELONG( chan->bchan | ( Enable << 8 ), 0);    /* send it */    idd_send_msg(chan->idd, &msg, IDD_PORT_CMD_TX, NULL, NULL);    return(CM_E_SUCC);}

/* format a disconenct request */INTcm__disc_rq(CM_CHAN *chan){    IDD_MSG     msg;    D_LOG(D_ENTRY|DIGIQ931, ("cm__disc_rq: entry, chan: 0x%lx/n", chan));    /* clear outgoing message */    NdisZeroMemory(&msg, sizeof(msg));    /* fillin message structure */    msg.opcode = Q931_REL_RQ;    msg.bufid = MAKELONG(0, chan->cid);    msg.bufptr = ut_get_buf();   msg.buflen = 0;    /* send to idd */    if (idd_send_msg(chan->idd, &msg, (USHORT)CM_PORT(chan), (VOID*)cm__q931_cmpl_handler, NULL) != IDD_E_SUCC)        ut_free_buf(msg.bufptr);    /* turn off channel */    cm__bchan_ctrl(chan, 0);    return(CM_E_SUCC);}

/* format a call ignore response */INTcm__est_ignore(   PVOID idd,   USHORT   cid,   USHORT   lterm){    IDD_MSG     msg;    D_LOG(D_ENTRY|DIGIQ931, ("cm__est_ignore: entry, idd: 0x%lx, cid: 0x%x, lterm: 0x%x/n", idd, cid, lterm));    /* clear outgoing message */    NdisZeroMemory(&msg, sizeof(msg));    /* fillin message structure */    msg.opcode = Q931_EST_IGNORE;    msg.bufid = MAKELONG(0, cid);    msg.bufptr = ut_get_buf();   msg.buflen = 0;    /* send to idd */    if (idd_send_msg(idd, &msg, (USHORT)(lterm + IDD_PORT_CM0_TX), (VOID*)cm__q931_cmpl_handler, NULL) != IDD_E_SUCC)        ut_free_buf(msg.bufptr);    return(CM_E_SUCC);}

/* static */nsresult WebCLSampler::getInstance (cl_sampler aInternal, WebCLSampler** aResultOut,                                    WebCL_LibCLWrapper* aLibWrapper){  nsresult rv = NS_OK;  WebCLSampler* existing = 0;  if (instanceRegistry.findById (aInternal, &existing))  {    NS_IF_ADDREF (*aResultOut = existing);  }  else  {    nsCOMPtr<WebCLSampler> obj ( new WebCLSampler () );    if (!obj)    {      D_LOG (LOG_LEVEL_ERROR, "Failed to create instance. rv=%d.", rv);      return NS_ERROR_OUT_OF_MEMORY;    }    obj->setWrapper (aLibWrapper);    obj->mInternal = aInternal;    instanceRegistry.add (obj->mInternal, obj);    NS_IF_ADDREF (*aResultOut = obj);  }  return rv;}

/* set connection state */mtl_set_conn_state(	VOID *mtl_1,	USHORT NumberOfChannels,	BOOL is_conn){	MTL	*mtl = (MTL*)mtl_1;	ADAPTER *Adapter = mtl->Adapter;    NDIS_PHYSICAL_ADDRESS   pa = NDIS_PHYSICAL_ADDRESS_CONST(0xffffffff, 0xffffffff);    D_LOG(D_ENTRY, ("mtl_set_conn_state: entry, is_conn: %d/n", is_conn));    /* get lock, set, release & return */    NdisAcquireSpinLock(&mtl->lock);    mtl->is_conn = is_conn;	//	// if we are being notified of a new connection we need to do some stuff	//	if (is_conn)	{		mtl->FramesXmitted = 0;		mtl->FramesReceived = 0;		mtl->BytesXmitted = 0;		mtl->BytesReceived = 0;		mtl->RecvFramingBits = 0;		mtl->tx_tbl.NextFree = 0;		mtl->rx_tbl.NextFree = 0;	}    NdisReleaseSpinLock(&mtl->lock);    return(MTL_E_SUCC);}

void Palette::PresetApply(PalettePreset &preset){static const U16 b_arr[] = { 0, 1, 3, 0, 0, 1, 3, 0, 0, 1, 3, 0, 0, 1, 3 };static const U16 r_arr[] = { 0, 0, 0, 1, 3, 1, 3, 0, 0, 0, 0, 1, 3, 1, 3 };static const U16 g_arr[] = { 0, 0, 0, 0, 0, 0, 0, 1, 3, 1, 3, 1, 3, 1, 3 };const auto &coeffs = preset.CoeffsGet();const U16 brights[] = { coeffs.zz, coeffs.zn, coeffs.nn, coeffs.zb, coeffs.nb, 0 /*dummy*/, coeffs.bb };U16 r, g, b;U16 tr, tg, tb;    D_LOG(D_DEBUG, D_LOG_MSG("Apply palette preset: %s", CSTR(preset.NameGet())));    clear();    for (auto row = 0; row < PALETTE_ROWS; ++row) {        for (auto col = row; col < PALETTE_COLUMS; ++col) {            b = brights[b_arr[row] + b_arr[col]];            r = brights[r_arr[row] + r_arr[col]];            g = brights[g_arr[row] + g_arr[col]];            tr = ((r * coeffs.r11) + (g * coeffs.g12) + (b * coeffs.b13)) / (U16)0x100;            tg = ((r * coeffs.r21) + (g * coeffs.g22) + (b * coeffs.b23)) / (U16)0x100;            tb = ((r * coeffs.r31) + (g * coeffs.g32) + (b * coeffs.b33)) / (U16)0x100;            const PaletteItem item(tr, tg, tb);            if (TRUE != IsDuplicate(item)) { // Filter duplicate colors.                append(item);                //D_LOG(D_DEBUG, D_LOG_MSG("row=%i,/tcol=%i,/tr=%i,/tg=%i,/tb=%i", row, col, tr, tg, tb));            }        }    }}

/* nsIVariant getSamplerInfo (in long aName); */NS_IMETHODIMP WebCLSampler::GetSamplerInfo(PRInt32 aName, JSContext *cx, nsIVariant **_retval){  D_METHOD_START;  NS_ENSURE_ARG_POINTER (_retval);  nsresult rv;  cl_int err = CL_SUCCESS;  int type = getTypeForInfoName (aName);  if (type == types::UNKNOWN)  {    D_LOG (LOG_LEVEL_ERROR, "Info parameter name %d does not have a known type.", aName);    WebCL_reportJSError (cx, "Info name %d is not supported by %s.",                         aName, __FUNCTION__);    return WEBCL_XPCOM_ERROR; //NS_ERROR_FAILURE;  }  nsCOMPtr<nsIWritableVariant> variant = do_CreateInstance(NS_VARIANT_CONTRACTID, &rv);  NS_ENSURE_SUCCESS (rv, rv);  WEBCL_GETINFO_MEDIATOR_SWITCH (aName, type, mWrapper, getSamplerInfo, mInternal,                                 variant, err, rv);  NS_ADDREF (*_retval = variant);  return NS_OK;}

/* get an entry by sequence number */INTtrc_get_entry(VOID *trc_1, ULONG seq, TRC_ENTRY *ent){	TRC		*trc = (TRC*)trc_1;    ULONG     n, index;        D_LOG(D_ENTRY, ("trc_get_entry: entry, trc: 0x%lx, seq: %ld, ent: 0x%lx", /                                trc, seq, ent));	// if no obect exit	if (trc == NULL)		return(TRC_E_NOSUCH);    /* find requested sequence number, temp!!!, using search! */    for ( n = 0 ; n < trc->ent_num ; n++ )    {        index = (trc->ent_get + n) % trc->stat.depth;        if ( trc->ent_tbl[index].seq == seq )        {            /* found */            *ent = trc->ent_tbl[index];            return(TRC_E_SUCC);        }    }    /* if here not found */    return(TRC_E_NOSUCH);}

static boolshow_segv( const siginfo_t *info, ucontext_t *uctx ){     switch (info->si_code) {#ifdef SEGV_MAPERR          case SEGV_MAPERR:               D_LOG( Direct_Signals, FATAL, "    --> Caught signal %d (at %p, invalid address) <--/n", info->si_signo, info->si_addr );               return true;#endif#ifdef SEGV_ACCERR          case SEGV_ACCERR:               D_LOG( Direct_Signals, FATAL, "    --> Caught signal %d (at %p, invalid permissions) <--/n", info->si_signo, info->si_addr );               return true;#endif     }     return false;}

/* filter trace frame */INTtrc__filter(ULONG filter, CHAR *buf, ULONG len){    D_LOG(D_ENTRY, ("trc__filter: entry, filter: %ld, buf: 0x%lx, len: %ld",/                                filter, buf, len));    /* not implemented, all frames filter in */    return(1);}  

/* completion handler for q931 command with attached local buffers */VOIDcm__q931_cmpl_handler(VOID *arg, USHORT port, IDD_MSG *msg){    D_LOG(D_ENTRY|DIGIQ931, ("cm__q931_cmpl_handler: arg: 0x%lx, port: 0x%d, msg: 0x%lx/n", /                                            arg, port, msg));    /* free attached buffer */    ut_free_buf(msg->bufptr);}

/* initialize support */INTres_init(VOID){    NDIS_PHYSICAL_ADDRESS   pa = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1);    /* allocate memory object */    NdisAllocateMemory((PVOID*)&res__tbl, (sizeof(RES) * MAX_RES), 0, pa);    if ( !res__tbl )    {        D_LOG(D_ALWAYS, ("res_init: memory allocate failed!"));        return(RES_E_NOMEM);    }    D_LOG(D_ALWAYS, ("res_init: res__tbl: 0x%lx", res__tbl));    NdisZeroMemory (res__tbl, sizeof(RES) * MAX_RES);//	NdisAllocateSpinLock(&res__lock);    return(RES_E_SUCC);}