C++ (Cpp) ALLOC_BYTES_ST Examples

Example #1

/*	Initialize db object
 *	max_trans and max_attrs can be 0, will be dynamically expanded
 *	as a result of "add" operations
 */
int
db_prop_init(struct db_context *ctx, u_int8_t protoid, int max_trans, int max_attrs) 
{
	int ret=-1;

	ctx->trans0 = NULL;
	ctx->attrs0 = NULL;

	if (max_trans > 0) { /* quite silly if not */
		ctx->trans0 = ALLOC_BYTES_ST ( sizeof (struct db_trans) * max_trans, 
			"db_context->trans", db_trans_st);
		if (!ctx->trans0) goto out;
	}

	if (max_attrs > 0) { /* quite silly if not */
		ctx->attrs0 = ALLOC_BYTES_ST (sizeof (struct db_attr) * max_attrs,
				"db_context->attrs", db_attrs_st);
		if (!ctx->attrs0) goto out;
	}
	ret = 0;
out:
	if (ret < 0 && ctx->trans0) {
		PFREE_ST(ctx->trans0, db_trans_st);
		ctx->trans0 = NULL;
	}
	ctx->max_trans = max_trans;
	ctx->max_attrs = max_attrs;
	ctx->trans_cur = ctx->trans0;
	ctx->attrs_cur = ctx->attrs0;
	ctx->prop.protoid = protoid;
	ctx->prop.trans = ctx->trans0;
	ctx->prop.trans_cnt = 0;
	return ret;
}

Example #2

/*	
 *	Expand storage for attributes by delta_attrs number AND
 *	rewrite trans->attr pointers
 */
static int
db_attrs_expand(struct db_context *ctx, int delta_attrs)
{
	int ret = -1;
	struct db_attr *new_attrs, *old_attrs;
	struct db_trans *t;
	int ti;
	int max_attrs = ctx->max_attrs + delta_attrs;
	int offset;

	old_attrs = ctx->attrs0;
	new_attrs = ALLOC_BYTES_ST ( sizeof (struct db_attr) * max_attrs, 
			"db_context->attrs (expand)", db_attrs_st);
	if (!new_attrs)
		goto out;

	memcpy(new_attrs, old_attrs, ctx->max_attrs * sizeof(struct db_attr));
	
	/* update attrs0 and attrs_cur (obviously) */
	offset = (char *)(new_attrs) - (char *)(old_attrs);
	(char *)ctx->attrs0 += offset;
	(char *)ctx->attrs_cur += offset;
	/* for each transform, rewrite attrs pointer by offsetting it */
	for (t=ctx->prop.trans, ti=0; ti < ctx->prop.trans_cnt; t++, ti++) {
		(char *)(t->attrs) += offset;
	}
	/* update elem count */
	ctx->max_attrs = max_attrs;
	PFREE_ST(old_attrs, db_attrs_st);
	ret = 0;
out:
	return ret;
}

Example #3

File: db_ops.c Project: KrisChaplin/LRT2x4_v1.0.2.06_GPL_source

/*	Expand storage for transforms by number delta_trans */
static int
db_trans_expand(struct db_context *ctx, int delta_trans)
{
    int ret = -1;
    struct db_trans *new_trans, *old_trans;
    int max_trans = ctx->max_trans + delta_trans;
    int offset;

    old_trans = ctx->trans0;
    new_trans = ALLOC_BYTES_ST ( sizeof (struct db_trans) * max_trans,
                                 "db_context->trans (expand)", db_trans_st);
    if (!new_trans)
        goto out;
    memcpy(new_trans, old_trans, ctx->max_trans * sizeof(struct db_trans));

    /* update trans0 (obviously) */
    ctx->trans0 = ctx->prop.trans = new_trans;
    /* update trans_cur (by offset) */
    offset = (char *)(new_trans) - (char *)(old_trans);

    {
        char *cctx = (char *)(ctx->trans_cur);

        cctx += offset;
        ctx->trans_cur = (struct db_trans *)cctx;
    }
    /* update elem count */
    ctx->max_trans = max_trans;
    PFREE_ST(old_trans, db_trans_st);
    ret = 0;
out:
    return ret;
}

Example #4

/*	Allocate a new db object */
struct db_context * 
db_prop_new(u_int8_t protoid, int max_trans, int max_attrs) 
{
	struct db_context *ctx;
	ctx = ALLOC_BYTES_ST ( sizeof (struct db_context), "db_context", db_context_st);
	if (!ctx) goto out;
	
	if (db_prop_init(ctx, protoid, max_trans, max_attrs) < 0) {
		PFREE_ST(ctx, db_context_st);
		ctx=NULL;
	}
out:
	return ctx;
}