示例#1
0
文件: dthread.c 项目: relabsoss/uart
int dthread_port_send_term(dthread_t* thr, dthread_t* source, 
			   ErlDrvTermData target,
			   ErlDrvTermData* spec, int len)
{
    if (thr->smp_support)
	return DSEND_TERM(thr, target, spec, len);
    else {
	dmessage_t* mp;
	int xsz = dterm_dyn_size(spec, len);
	if (xsz < 0)
	    return -1;
	mp = dmessage_create(DTHREAD_SEND_TERM,(char*)spec,
			     len*sizeof(ErlDrvTermData));
	if (xsz > 0) {
	    char* xptr = DALLOC(xsz);
	    if ((dterm_dyn_copy((ErlDrvTermData*)mp->buffer, 
				len, xptr)) == NULL)
		return -1;
	    mp->udata = xptr;
	    mp->release = release_xptr_func;
	}
	mp->to = target;
	// dterm_dump(stderr, (ErlDrvTermData*) mp->buffer, mp->used / sizeof(ErlDrvTermData));
	return dthread_send(thr, source, mp);
    }
}
示例#2
0
文件: dthread.c 项目: relabsoss/uart
dthread_t* dthread_start(ErlDrvPort port,
			 void* (*func)(void* arg),
			 void* arg, int stack_size)
{
    ErlDrvThreadOpts* opts = NULL;
    dthread_t* thr = NULL;

    if (!(thr = DALLOC(sizeof(dthread_t))))
	return 0;

    if (dthread_init(thr, port) < 0)
	goto error;

    if (!(opts = erl_drv_thread_opts_create("dthread_opts")))
	goto error;

    opts->suggested_stack_size = stack_size;
    thr->arg = arg;

    if (erl_drv_thread_create("dthread", &thr->tid, func, thr, opts) < 0)
	goto error;
    erl_drv_thread_opts_destroy(opts);
    return thr;

error:
    dthread_finish(thr);
    if (opts)
        erl_drv_thread_opts_destroy(opts);
    dthread_finish(thr);
    DFREE(thr);
    return 0;
}
示例#3
0
文件: dterm.c 项目: relabsoss/uart
// auxillary space
void* dterm_link_alloc_data(dterm_t* p, size_t size)
{
    dterm_link_t* lp = DALLOC(sizeof(dterm_link_t)+size);
    lp->next = p->head;
    p->head = lp;
    return (void*) &lp->data[0];
}
示例#4
0
文件: dterm.c 项目: relabsoss/uart
// dynamic allocation of dterm_t structure, the data part is
// can be less the DTERM_FIXED in this case
dterm_t* dterm_alloc(size_t size)
{
    size_t  sz = (sizeof(dterm_t) - DTERM_FIXED*sizeof(ErlDrvTermData)) +
	size*sizeof(ErlDrvTermData);
    dterm_t* p;

    if ((p = DALLOC(sz)) != NULL) {
	p->dyn_alloc  = 1;
	p->dyn_size   = size;
	p->base       = p->data;
	p->ptr        = p->data;
	p->ptr_end    = p->data + p->dyn_size;
	p->head       = 0;
	p->mark       = 0;
    }
    return p;
}
示例#5
0
文件: dterm.c 项目: relabsoss/uart
int dterm_expand(dterm_t* p, size_t n)
{
    ErlDrvTermData* new_base;
    size_t old_size = dterm_allocated_size(p);
    size_t new_size = old_size + n;
    size_t old_sz   = old_size * sizeof(ErlDrvTermData);
    size_t new_sz   = new_size * sizeof(ErlDrvTermData);
    ptrdiff_t offset = p->ptr - p->base;  // offset of ptr

    if (p->base == p->data) {
	if ((new_base = DALLOC(new_sz)) == NULL)
	    return 0;
	memcpy(new_base, p->base, old_sz);
    }
    else if ((new_base = DREALLOC(p->base, new_sz)) == NULL)
	return 0;
    p->base    = new_base;
    p->ptr     = p->base + offset;
    p->ptr_end = new_base + new_size;
    p->base    = new_base;
    return 1;
}
示例#6
0
/*-------------------------------------------------------------------
 *  init_xfer -- initialize the transfer tables by transferring coarse
 *			control points from an ICC ResponseRecord
 *			and interpolating the fine tables from them;
 *			returns +1 for success, -1 for failure to
 *			allocate memory for coarse table
 *-------------------------------------------------------------------
 */
PTErr_t
	init_xfer (	xfer_p				xferp,
				ResponseRecord_p	rrp)
{
PTErr_t		PTErr = KCP_SUCCESS;
double		val;			/* input variables */
KpInt32_t	numcoarse;		/* number of input control points */
double_p	coarse[2];		/* storage for control points */
KpInt32_t	i;			/* control-point index */
KpInt32_t	hint;
KpUInt16_t	*pCurveData = NULL;

     /* Verify inputs:  */
	if (xferp == (xfer_p)NULL)	return KCP_SYSERR_0;
	if (rrp == (ResponseRecord_p)NULL)	return KCP_SYSERR_0;
	
	if (PARA_TYPE_SIG == rrp->TagSig)
	{
		pCurveData = (KpUInt16_p) allocBufferPtr (MFV_CURVE_TBL_ENT*sizeof(KpUInt16_t));	/* get memory for curve data */
		if (NULL == pCurveData) {
			return KCP_NO_MEMORY;
		}
		makeCurveFromPara (rrp->ParaFunction, rrp->ParaParams, pCurveData, MFV_CURVE_TBL_ENT);
		rrp->CurveCount = MFV_CURVE_TBL_ENT;
		rrp->CurveData = pCurveData;
	}
	if (rrp->CurveCount < 2) {
		PTErr = KCP_SYSERR_0;
		goto ErrOut;
	}
	if (rrp->CurveData == (KpUInt16_p)NULL) {
		PTErr = KCP_SYSERR_0;
		goto ErrOut;
	}
	   
     /* Allocate space for coarse tables:  */
	numcoarse = rrp->CurveCount - 1;	/* skip zero entry to avoid infinity in logarithm */
	coarse[0] = (double_p)ALLOC (numcoarse, sizeof(double));
	if (coarse[0] == NULL)
	{
		PTErr = KCP_NO_MEMORY;
		goto ErrOut;
	}
	coarse[1] = (double_p)ALLOC (numcoarse, sizeof(double));
	if (coarse[1] == NULL)
	{
	   DALLOC (coarse[0]);	/* release storage */
		PTErr = KCP_NO_MEMORY;
		goto ErrOut;
	}

     /* Build coarse tables from ResponseRecord:  */
	for (i = 0; i < numcoarse; i++)
	{
	   val = (double)(i + 1) / (double)numcoarse;	/* skip zero to avoid infinite log */
	   coarse[0][i] = -log10 (val);
	   val = (double)rrp->CurveData[i + 1] / SCALEDOT16;
	   val = MAX (val, 1.0e-12);			/* clip to avoid infinite log */
	   coarse[1][i] = -log10 (val);
	}

     /* Build fine tables by interpolating in coarse tables:  */
	hint = 1;
	for (i = 0; i < NUMFINE; i++)				/* spaced code values */
	{
	   double	code;

	   code = (double)i * 2.4 / (double)(NUMFINE - 1);	/* equally spaced in [0, 2.4] */
	   xferp->nonlinear[i] = code;
	   xferp->linear[i] = f4l (code, coarse[0], coarse[1], numcoarse, &hint);
	}

     /* Delete coarse tables:  */
	DALLOC (coarse[0]);
	DALLOC (coarse[1]);

ErrOut:
	if (NULL != pCurveData) {
		freeBufferPtr (pCurveData);
	}
	return PTErr;
}