/***********************9
* Append data represented by ptr[0..size]
*/
void DtBuilder::nbytes(unsigned size, const char *ptr)
{
if (!size)
return;
dt_t *dt;
if (size < DTibytesMax)
{ dt = dt_calloc(DT_ibytes);
dt->DTn = size;
memcpy(dt->DTdata,ptr,size);
}
else
{
dt = dt_calloc(DT_nbytes);
dt->DTnbytes = size;
dt->DTpbytes = (char *) MEM_PH_MALLOC(size);
memcpy(dt->DTpbytes,ptr,size);
}
assert(!*pTail);
*pTail = dt;
pTail = &dt->DTnext;
assert(!*pTail);
}
type *type_alloc_template(symbol *s)
{ type *t;
#if TX86
t = (type *) mem_fcalloc(sizeof(typetemp_t));
#else
t = (type *) MEM_PH_MALLOC(sizeof(typetemp_t));
memset(t, 0, sizeof(typetemp_t));
#endif
t->Tty = TYtemplate;
if (s->Stemplate->TMprimary)
s = s->Stemplate->TMprimary;
((typetemp_t *)t)->Tsym = s;
#if SRCPOS_4TYPES
if (PARSER && config.fulltypes)
t->Tsrcpos = getlinnum();
#endif
#ifdef DEBUG
t->id = IDtype;
type_num++;
if (type_num > type_max)
type_max = type_num;
//dbg_printf("Alloc'ing template type %p ",t); WRTYxx(t->Tty); dbg_printf("\n");
#endif
return t;
}
type *type_alloc(tym_t ty)
{ type *t;
static type tzero;
assert(tybasic(ty) != TYtemplate);
if (type_list)
{ t = type_list;
type_list = t->Tnext;
}
else
#if TX86
t = (type *) mem_fmalloc(sizeof(type));
#else
t = (type *) MEM_PH_MALLOC(sizeof(type));
#endif
tzero.Tty = ty;
*t = tzero;
#if SRCPOS_4TYPES
if (PARSER && config.fulltypes)
t->Tsrcpos = getlinnum();
#endif
#ifdef DEBUG
t->id = IDtype;
type_num++;
if (type_num > type_max)
type_max = type_num;
#endif
//dbg_printf("type_alloc() = %p ",t); WRTYxx(t->Tty); dbg_printf("\n");
//if (t == (type*)0xB6B744) *(char*)0=0;
return t;
}
param_t *param_calloc()
{
static param_t pzero;
param_t *p;
#if !TX86
debug_assert(PARSER);
#endif
if (param_list)
{
p = param_list;
param_list = p->Pnext;
}
else
{
#if TX86
p = (param_t *) mem_fmalloc(sizeof(param_t));
#else
p = (param_t *) MEM_PH_MALLOC(sizeof(param_t));
#endif
}
*p = pzero;
#ifdef DEBUG
p->id = IDparam;
#endif
return p;
}
/*****************************************
* Write a reference to the data ptr[0..size+nzeros]
*/
void DtBuilder::abytes(tym_t ty, unsigned offset, unsigned size, const char *ptr, unsigned nzeros)
{
dt_t *dt = dt_calloc(DT_abytes);
dt->DTnbytes = size + nzeros;
dt->DTpbytes = (char *) MEM_PH_MALLOC(size + nzeros);
dt->Dty = ty;
dt->DTabytes = offset;
memcpy(dt->DTpbytes,ptr,size);
if (nzeros)
memset(dt->DTpbytes + size, 0, nzeros);
assert(!*pTail);
*pTail = dt;
pTail = &dt->DTnext;
assert(!*pTail);
}
/**************************************
* Repeat a list of dt_t's count times.
*/
void DtBuilder::repeat(dt_t *dt, size_t count)
{
if (!count)
return;
unsigned size = dt_size(dt);
if (!size)
return;
if (dtallzeros(dt))
{
if (head && dtallzeros(head))
head->DTazeros += size * count;
else
nzeros(size * count);
return;
}
if (dtpointers(dt))
{
dt_t *dtp = NULL;
dt_t **pdt = &dtp;
for (size_t i = 0; i < count; ++i)
{
for (dt_t *dtn = dt; dtn; dtn = dtn->DTnext)
{
dt_t *dtx = dt_calloc(dtn->dt);
*dtx = *dtn;
dtx->DTnext = NULL;
switch (dtx->dt)
{
case DT_abytes:
case DT_nbytes:
dtx->DTpbytes = (char *) MEM_PH_MALLOC(dtx->DTnbytes);
memcpy(dtx->DTpbytes, dtn->DTpbytes, dtx->DTnbytes);
break;
}
*pdt = dtx;
pdt = &dtx->DTnext;
}
}
assert(!*pTail);
*pTail = dtp;
assert(*pdt == NULL);
pTail = pdt;
return;
}
char *p = (char *)MEM_PH_MALLOC(size * count);
size_t offset = 0;
for (dt_t *dtn = dt; dtn; dtn = dtn->DTnext)
{
switch (dtn->dt)
{
case DT_nbytes:
memcpy(p + offset, dtn->DTpbytes, dtn->DTnbytes);
offset += dtn->DTnbytes;
break;
case DT_ibytes:
memcpy(p + offset, dtn->DTdata, dtn->DTn);
offset += dtn->DTn;
break;
case DT_azeros:
memset(p + offset, 0, dtn->DTazeros);
offset += dtn->DTazeros;
break;
default:
#ifdef DEBUG
printf("dt = %p, dt = %d\n",dt,dt->dt);
#endif
assert(0);
}
}
assert(offset == size);
for (size_t i = 1; i < count; ++i)
{
memcpy(p + offset, p, size);
offset += size;
}
dt_t *dtx = dt_calloc(DT_nbytes);
dtx->DTnbytes = size * count;
dtx->DTpbytes = p;
assert(!*pTail);
*pTail = dtx;
pTail = &dtx->DTnext;
assert(!*pTail);
}
