void
__profile_call(ADDR caller, ADDR callee, char *caller_name, char *callee_name)
{
#ifdef _DEBUG
return;
#else
if (num_counts == 0)
ir_prof_start();
if (num_counts == sizeof_counts_array) {
sizeof_counts_array *= 2;
counts_array = (counts_entry *)REALLOC(
counts_array, sizeof_counts_array);
PR_ASSERT(counts_array, "realloc of counts_array failed");
}
hash_entry(caller, callee, caller_name, callee_name);
#endif
}
enum pipe_error
pb_validate_add_buffer(struct pb_validate *vl,
struct pb_buffer *buf)
{
assert(buf);
if(!buf)
return PIPE_ERROR;
/* We only need to store one reference for each buffer, so avoid storing
* consecutive references for the same buffer. It might not be the more
* common pasttern, but it is easy to implement.
*/
if(vl->used && vl->buffers[vl->used - 1] == buf) {
return PIPE_OK;
}
/* Grow the table */
if(vl->used == vl->size) {
unsigned new_size;
struct pb_buffer **new_buffers;
new_size = vl->size * 2;
if(!new_size)
return PIPE_ERROR_OUT_OF_MEMORY;
new_buffers = (struct pb_buffer **)REALLOC(vl->buffers,
vl->size*sizeof(struct pb_buffer *),
new_size*sizeof(struct pb_buffer *));
if(!new_buffers)
return PIPE_ERROR_OUT_OF_MEMORY;
memset(new_buffers + vl->size, 0, (new_size - vl->size)*sizeof(struct pb_buffer *));
vl->size = new_size;
vl->buffers = new_buffers;
}
assert(!vl->buffers[vl->used]);
pb_reference(&vl->buffers[vl->used], buf);
++vl->used;
return PIPE_OK;
}
void *
__gf_realloc (void *ptr, size_t size)
{
size_t tot_size = 0;
char *orig_ptr = NULL;
xlator_t *xl = NULL;
uint32_t type = 0;
char *new_ptr;
if (!THIS->ctx->mem_acct_enable)
return REALLOC (ptr, size);
REQUIRE(NULL != ptr);
tot_size = size + GF_MEM_HEADER_SIZE + GF_MEM_TRAILER_SIZE;
orig_ptr = (char *)ptr - 8 - 4;
GF_ASSERT (*(uint32_t *)orig_ptr == GF_MEM_HEADER_MAGIC);
orig_ptr = orig_ptr - sizeof(xlator_t *);
xl = *((xlator_t **)orig_ptr);
orig_ptr = (char *)ptr - GF_MEM_HEADER_SIZE;
type = *(uint32_t *)orig_ptr;
new_ptr = realloc (orig_ptr, tot_size);
if (!new_ptr) {
gf_log_nomem ("", GF_LOG_ALERT, tot_size);
return NULL;
}
/*
* We used to pass (char **)&ptr as the second
* argument after the value of realloc was saved
* in ptr, but the compiler warnings complained
* about the casting to and forth from void ** to
* char **.
*/
gf_mem_set_acct_info (xl, &new_ptr, size, type);
return (void *)new_ptr;
}
int add_init_section(InitFile *inif, InitSection *inis)
{
int i;
InitSection *oinis;
if ((i = find_init_section(inif, inis->section_name)) >= 0) {
oinis = inif->sections[i];
inif->sections[i] = inis;
free_init_section(oinis);
return INIT_FILE_PRESENT;
}
if (inif->num_sections == inif->size_sections) {
inif->size_sections += 10;
inif->sections = REALLOC(inif->sections,
sizeof(InitSection *) * inif->size_sections);
}
inif->sections[inif->num_sections] = inis;
++(inif->num_sections);
return INIT_FILE_NOT_PRESENT;
}
sStatment* sStatment_new(sObject* block, int sline, char* sname)
{
if(SBLOCK(block).mStatmentsNum >= SBLOCK(block).mStatmentsSize) {
const int statments_size = SBLOCK(block).mStatmentsSize;
int new_statments_size = SBLOCK(block).mStatmentsSize * 2;
SBLOCK(block).mStatments = REALLOC(SBLOCK(block).mStatments, sizeof(sStatment)*new_statments_size);
memset(SBLOCK(block).mStatments + SBLOCK(block).mStatmentsSize, 0, sizeof(sStatment)*(new_statments_size - SBLOCK(block).mStatmentsSize));
SBLOCK(block).mStatmentsSize = new_statments_size;
}
sStatment* self = SBLOCK(block).mStatments + SBLOCK(block).mStatmentsNum;
SBLOCK(block).mStatmentsNum++;
self->mLine = sline;
self->mFName = STRDUP(sname);
self->mFlags = 0;
return self;
}
VAStatus
vlVaBufferSetNumElements(VADriverContextP ctx, VABufferID buf_id,
unsigned int num_elements)
{
vlVaBuffer *buf;
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
buf = handle_table_get(VL_VA_DRIVER(ctx)->htab, buf_id);
buf->data = REALLOC(buf->data, buf->size * buf->num_elements,
buf->size * num_elements);
buf->num_elements = num_elements;
if (!buf->data)
return VA_STATUS_ERROR_ALLOCATION_FAILED;
return VA_STATUS_SUCCESS;
}
void AddLine(int SkipLineInfo)
{
if(/*ooutptr!=outptr&&*/dbgact==0&&(oline!=linenumber||omodule!=currentfileinfo)){
while(ooutptr>outptr&&pdbg!=0&&ooutptr!=0xffffffff)KillLastLine();
if(pdbg==pdbgmax){
pdbgmax+=MAXDBGS;
dbgloc=(unsigned int *) REALLOC(dbgloc,pdbgmax*sizeof(unsigned int));
dbgnum=(unsigned int *) REALLOC(dbgnum,pdbgmax*sizeof(unsigned int));
dbgmod=(unsigned short *)REALLOC(dbgmod,pdbgmax*sizeof(unsigned short));
if(lstflag){
lststring=(char **)REALLOC(lststring,pdbgmax*sizeof(char *));
lstflag=(unsigned char *)REALLOC(lstflag,pdbgmax*sizeof(char));
lstend=(unsigned int *)REALLOC(lstend,pdbgmax*sizeof(unsigned int));
memset((char *)lstflag+(pdbgmax-MAXDBGS),-1,MAXDBGS*sizeof(char));
memset((unsigned int *)lstend+(pdbgmax-MAXDBGS),0,MAXDBGS*sizeof(unsigned int));
}
}
dbgloc[pdbg]=ooutptr=outptr;
dbgnum[pdbg]=oline=linenumber;
dbgmod[pdbg]=(unsigned short)currentfileinfo;
omodule=currentfileinfo;
if(dbg&2){
if(SkipLineInfo)lststring[pdbg]=NULL;
else{
char *ofs=startline;
char c;
int sizestring=0;
char buf[MAXLSTSTR];
for(;sizestring<(MAXLSTSTR-1);sizestring++){
c=*ofs;
ofs=ofs+1;
if(c==13||ofs==endinput)break;
buf[sizestring]=c;
}
buf[sizestring]=0;
strbtrim(buf);
if((sizestring=strlen(buf))==0)lststring[pdbg]=NULL;
else{
lststring[pdbg]=(char *)MALLOC(sizestring+1);
strcpy(lststring[pdbg],buf);
}
}
lstflag[pdbg]=(unsigned char)(am32|lsttypedata);
AddEndLine();
// printf("%s(%d) outptr=%d\n",(startfileinfo+currentfileinfo)->filename,linenumber,outptr);
}
pdbg++;
(startfileinfo+currentfileinfo)->numdline++;
}
}
void oputs ( int streamid, int detail, char *string )
{
int i, j;
if ( streamid == OUT_SYS && !quietmode )
{
printf ( string );
fflush ( stdout );
}
if ( detail_level < detail )
return;
for ( i = 0; i < output_stream_count; ++i )
{
if ( streamid == streams[i].id )
{
if ( streams[i].valid )
{
fputs ( string, streams[i].f );
if ( streams[i].autoflush )
fflush ( streams[i].f );
break;
}
else
{
if ( streams[i].buffer )
{
j = strlen ( streams[i].buffer ) +
strlen ( string ) + 1;
streams[i].buffer = (char *)REALLOC ( streams[i].buffer, j );
strcat ( streams[i].buffer, string );
}
else
{
streams[i].buffer = (char *)MALLOC ( strlen ( string ) + 1 );
strcpy ( streams[i].buffer, string );
}
}
}
}
}
boolean TS_AddExtension(char ** ppszExtList, char * psz)
{
char * pExt;
if (!ppszExtList || !psz)
return FALSE;
if (*ppszExtList)
pExt = REALLOC(*ppszExtList, STRLEN(*ppszExtList) + STRLEN(psz) + STRLEN(MP_EXT_SEPARATOR) + 1);
else
pExt = MALLOC(STRLEN(psz) + STRLEN(MP_EXT_SEPARATOR) + 1);
if (!pExt)
return FALSE;
STRCAT(pExt, psz);
STRCAT(pExt, MP_EXT_SEPARATOR);
*ppszExtList = pExt;
return TRUE;
}
static a_reduce_action *addReduceAction( a_pro *pro, a_word *follow, a_reduce_action *r )
{
a_reduce_action *raction;
a_reduce_action *new_raction;
a_word *new_follow;
size_t i;
for( raction = r; raction->pro != NULL; ) {
++raction;
}
i = raction - r;
new_follow = AllocSet( 1 );
Assign( new_follow, follow );
new_raction = REALLOC( r, i + 2, a_reduce_action );
new_raction[i].pro = pro;
new_raction[i].follow = new_follow;
new_raction[i + 1].pro = NULL;
new_raction[i + 1].follow = NULL;
return( new_raction );
}
spif_bool_t
spif_str_trim(spif_str_t self)
{
spif_charptr_t start, end;
ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
start = self->s;
end = self->s + self->len - 1;
for (; isspace((spif_uchar_t) (*start)) && (start < end); start++);
for (; isspace((spif_uchar_t) (*end)) && (start < end); end--);
if (start > end) {
return spif_str_done(self);
}
*(++end) = 0;
self->len = (spif_stridx_t) (end - start);
self->size = self->len + 1;
memmove(self->s, start, self->size);
self->s = (spif_charptr_t) REALLOC(self->s, self->size);
return TRUE;
}
static void expand_n_viterbi_egraphs(int req_n_viterbi_egraph_size)
{
int old_size,i;
if (req_n_viterbi_egraph_size > max_n_viterbi_egraph_size) {
old_size = max_n_viterbi_egraph_size;
while (req_n_viterbi_egraph_size > max_n_viterbi_egraph_size) {
max_n_viterbi_egraph_size *= 2;
}
n_viterbi_egraphs =
(V_ENT_PTR *)REALLOC(n_viterbi_egraphs,
max_n_viterbi_egraph_size * sizeof(V_ENT_PTR));
for (i = old_size; i < max_n_viterbi_egraph_size; i++) {
n_viterbi_egraphs[i] = NULL;
}
}
}
void *Clear_realloc(void *OldPtr,size_t OldSize,size_t NewSize)
{
void *NewPtr ;
NewPtr = REALLOC(OldPtr,NewSize) ;
if (!NewPtr)
{
printf("ERROR - No more memory\n") ;
/* werror(E_OUT_OF_MEM,__FILE__,NewSize);*/
exit (1);
}
if (NewPtr)
if (NewSize > OldSize)
memset((char *) NewPtr + OldSize,0x00,NewSize - OldSize) ;
return NewPtr ;
}
static void add_completer_widget(Widget w, int row)
{
if (row >= 0)
{
if (cmpwids_size <= row)
{
int i;
i = cmpwids_size;
cmpwids_size = row + 8;
if (cmpwids == NULL)
cmpwids = (Widget *)CALLOC(cmpwids_size, sizeof(Widget));
else
{
cmpwids = (Widget *)REALLOC(cmpwids, cmpwids_size * sizeof(Widget));
for (; i < cmpwids_size; i++) cmpwids[i] = NULL;
}
}
cmpwids[row] = w;
}
}
void add_unique_range_nosort(
range_list_t *ranges,
GElf_Off start,
GElf_Off length,
void *user,
void (*err_fn)(range_error_t, range_t *, range_t *),
void (*user_dtor)(void * ))
{
if (ranges->num_ranges == ranges->array_length) {
ranges->array_length += PARALLEL_ARRAY_SIZE;
ranges->array = REALLOC(ranges->array,
ranges->array_length*sizeof(range_t));
}
ranges->array[ranges->num_ranges].start = start;
ranges->array[ranges->num_ranges].length = length;
ranges->array[ranges->num_ranges].user = user;
ranges->array[ranges->num_ranges].err_fn = err_fn;
ranges->array[ranges->num_ranges].user_dtor = user_dtor;
ranges->num_ranges++;
}
static void tokens_expand( struct ureg_tokens *tokens,
unsigned count )
{
unsigned old_size = tokens->size * sizeof(unsigned);
if (tokens->tokens == error_tokens) {
return;
}
while (tokens->count + count > tokens->size) {
tokens->size = (1 << ++tokens->order);
}
tokens->tokens = REALLOC(tokens->tokens,
old_size,
tokens->size * sizeof(unsigned));
if (tokens->tokens == NULL) {
tokens_error(tokens);
}
}
BOOL
PutEvent (
PINPUT_RECORD InputRecord
)
{
EnterCriticalSection(&(EventBuffer.CriticalSection));
//
// If no space at beginning of buffer, resize and shift right
//
if ( EventBuffer.EventIndex == 0 ) {
EventBuffer.EventBuffer = REALLOC( EventBuffer.EventBuffer,
(EventBuffer.MaxEvents + EVENT_INCREMENT) * sizeof(INPUT_RECORD));
if ( !EventBuffer.EventBuffer ) {
CleanExit(1, 0);
}
memmove( EventBuffer.EventBuffer + EVENT_INCREMENT,
EventBuffer.EventBuffer ,
EventBuffer.NumberOfEvents * sizeof(INPUT_RECORD) );
EventBuffer.EventIndex = EVENT_INCREMENT;
}
//
// Add event
//
EventBuffer.EventIndex--;
EventBuffer.NumberOfEvents++;
memcpy( EventBuffer.EventBuffer + EventBuffer.EventIndex,
InputRecord,
sizeof(INPUT_RECORD ));
LeaveCriticalSection(&(EventBuffer.CriticalSection));
return TRUE;
}
/**
* Resize the bitmask if necessary
*/
static inline boolean
util_bitmask_resize(struct util_bitmask *bm,
unsigned minimum_index)
{
unsigned minimum_size = minimum_index + 1;
unsigned new_size;
util_bitmask_word *new_words;
/* Check integer overflow */
if(!minimum_size)
return FALSE;
if(bm->size >= minimum_size)
return TRUE;
assert(bm->size % UTIL_BITMASK_BITS_PER_WORD == 0);
new_size = bm->size;
while(new_size < minimum_size) {
new_size *= 2;
/* Check integer overflow */
if(new_size < bm->size)
return FALSE;
}
assert(new_size);
assert(new_size % UTIL_BITMASK_BITS_PER_WORD == 0);
new_words = (util_bitmask_word *)REALLOC((void *)bm->words,
bm->size / UTIL_BITMASK_BITS_PER_BYTE,
new_size / UTIL_BITMASK_BITS_PER_BYTE);
if (!new_words)
return FALSE;
memset(new_words + bm->size/UTIL_BITMASK_BITS_PER_WORD,
0,
(new_size - bm->size)/UTIL_BITMASK_BITS_PER_BYTE);
bm->size = new_size;
bm->words = new_words;
return TRUE;
}
//
// Add the given value to the list of suggested values for this parameter
//
bool ParameterDefinition::addValueOption(const char *value)
{
int position;
if (!this->valueOptions) {
int size = 4;
this->valueOptions = (char**)MALLOC(size * sizeof(char*));
memset(this->valueOptions,0, size * sizeof(char*));
position = 0;
} else {
position = 0;
while (this->valueOptions[position])
position++;
int nextpos = position + 1;
switch (nextpos) {
case 4:
case 8:
case 16:
case 32:
case 64:
this->valueOptions = (char**)REALLOC((void*)this->valueOptions,
2 * nextpos * sizeof(char*));
memset(this->valueOptions + nextpos, 0, nextpos*sizeof(char*));
break;
default:
if (nextpos > 64) {
fprintf(stderr,
"Too many value options for parameter (ignoring)");
position = -1;
}
break;
}
}
if (position >= 0) {
this->valueOptions[position] = DuplicateString(value);
return true;
} else {
return false;
}
}
void gges_mapping_append_symbol(struct gges_mapping *mapping, char *token)
{
int tlen;
if (mapping) {
tlen = strlen(token);
/* first, check to see if the string buffer needs
* extending, and realloc as required */
if ((mapping->l + tlen + 1) > mapping->sz) {
while (mapping->sz < (mapping->l + tlen + 1)) mapping->sz += BUFFER_INC;
mapping->buffer = REALLOC(mapping->buffer, mapping->sz, sizeof(char));
}
/* then, push terminal symbol into stream */
strcat(mapping->buffer, token);
mapping->l += tlen;
} else {
fprintf(stdout, "%s", token);
}
}
static void expand_viterbi_egraphs(int req_viterbi_egraph_size)
{
int old_size,i;
if (req_viterbi_egraph_size > max_viterbi_egraph_size) {
old_size = max_viterbi_egraph_size;
while (req_viterbi_egraph_size > max_viterbi_egraph_size) {
max_viterbi_egraph_size *= 2;
}
viterbi_egraphs =
(EG_NODE_PTR *)
REALLOC(viterbi_egraphs,
max_viterbi_egraph_size * sizeof(EG_NODE_PTR));
for (i = old_size; i < max_viterbi_egraph_size; i++) {
viterbi_egraphs[i] = NULL;
}
}
}
void resizeMatrix(sparseMatrix *matrix, int newSize)
{
int oldSize;
if(matrix == NULL)
oldSize = 0;
else
oldSize = matrix->size;
while(oldSize>newSize) {
oldSize--;
freeVector(matrix->list[oldSize]);
return;
}
REALLOC(matrix->list, newSize);
while(oldSize<newSize) {
matrix->list[oldSize] = NULL;
oldSize++;
}
if(newSize>0)
matrix->size = newSize;
}
void mesh_addluafaces(struct mesh *m, lua_State *L, int index)
{
int n, i;
DEBUG(2, "Adding faces from Lua array at index %d\n", index);
n = lua_objlen(L, index);
DEBUG(2, "Length of array reported as %d\n", n);
REALLOC(m->faces, m->nfaces + n);
MEMSET(&m->faces[m->nfaces], 0, n);
for (i=1; i<=n; i++)
{
lua_getfieldi(L, index, i);
if (!lua_istable(L, -1))
luaL_error(L, "index %d: table expected, got %s",
i, luaL_typename(L, -1));
facefromlua(&m->faces[m->nfaces], L, -1);
lua_pop(L, 1);
m->nfaces++;
}
DEBUG(2, "%d faces added, current total is %d\n", i-1, m->nfaces);
}
/* ----------------------------- MNI Header -----------------------------------
@NAME : acr_lookup_vr_name
@INPUT : vr_name - the 2-letter VR name to look up
@OUTPUT : (none)
@RETURNS : Internal VR code
@DESCRIPTION: Looks up a VR name in the table. If it does not exist, the
name is added to the unknown table.
@METHOD :
@GLOBALS :
@CALLS :
@CREATED : January 31, 1997 (Peter Neelin)
@MODIFIED :
---------------------------------------------------------------------------- */
Acr_VR_Type acr_lookup_vr_name(char *vr_name)
{
Acr_VR_Type vr_code;
int ientry;
char *string;
/* Look up the name and return the matching code if found */
vr_code = find_vr_name(vr_name);
if (vr_code >= 0) {
return vr_code;
}
/* If name is not found, add it to the unknown table */
if (unknown_VR_table_length <= 0) {
unknown_VR_table_length = 1;
unknown_VR_table = MALLOC((size_t) unknown_VR_table_length *
sizeof(*unknown_VR_table));
}
else {
unknown_VR_table_length++;
unknown_VR_table = REALLOC(unknown_VR_table,
(size_t) unknown_VR_table_length *
sizeof(*unknown_VR_table));
}
/* Fill in the entry */
ientry = unknown_VR_table_length-1;
unknown_VR_table[ientry].vr_code = ientry + ACR_VR_NUM_TYPES;
string = MALLOC(3);
string[0] = vr_name[0];
string[1] = vr_name[1];
string[2] = '\0';
unknown_VR_table[ientry].vr_name = string;
unknown_VR_table[ientry].convert_to_numeric = return_zero;
unknown_VR_table[ientry].convert_to_string = return_empty_string;
/* Return the code */
return unknown_VR_table[ientry].vr_code;
}
/*
* NAME: rsrc->resize()
* DESCRIPTION: change the length of a resource
*/
void *rsrc_resize(void *rdata, unsigned long newsize)
{
rsrchandle *newrsrc, *rsrc = gethandle(rdata);
if (rsrc->len == newsize)
goto done;
newrsrc = (rsrchandle *) REALLOC(rsrc, byte, sizeof(rsrchandle) + newsize);
if (newrsrc == 0)
ERROR(ENOMEM, 0);
newrsrc->attrs |= RSRC_RES_CHANGED;
newrsrc->len = newsize;
rdata = getrdata(newrsrc);
done:
return rdata;
fail:
return 0;
}
void ALLOCEXPANDARRAY::SetAt (size_t iElement, PVOID pData)
{
size_t iHeap = iElement / m_cElementsPerHeap;
size_t iIndex = iElement % m_cElementsPerHeap;
if (!REALLOC (m_aHeaps, m_cHeaps, 1+iHeap, cREALLOC_EXPANDARRAYHEAPS))
return;
if (!m_aHeaps[ iHeap ])
{
size_t cbHeap = sizeof(EXPANDARRAYHEAP) + (m_cElementsPerHeap * m_cbElement);
if ((m_aHeaps[ iHeap ] = (LPEXPANDARRAYHEAP)GlobalAlloc (GMEM_FIXED, cbHeap)) == NULL)
return;
memset (m_aHeaps[ iHeap ], 0x00, cbHeap);
m_aHeaps[ iHeap ]->aElements = ((PBYTE)m_aHeaps[ iHeap ]) + sizeof(EXPANDARRAYHEAP);
}
if (!pData)
memset (&((PBYTE)m_aHeaps[ iHeap ]->aElements)[ iIndex * m_cbElement ], 0x00, m_cbElement);
else
memcpy (&((PBYTE)m_aHeaps[ iHeap ]->aElements)[ iIndex * m_cbElement ], pData, m_cbElement);
}
static boolean
batch_query_add(struct hud_batch_query_context **pbq,
struct pipe_context *pipe, unsigned query_type,
unsigned *result_index)
{
struct hud_batch_query_context *bq = *pbq;
unsigned i;
if (!bq) {
bq = CALLOC_STRUCT(hud_batch_query_context);
if (!bq)
return false;
bq->pipe = pipe;
*pbq = bq;
}
for (i = 0; i < bq->num_query_types; ++i) {
if (bq->query_types[i] == query_type) {
*result_index = i;
return true;
}
}
if (bq->num_query_types == bq->allocated_query_types) {
unsigned new_alloc = MAX2(16, bq->allocated_query_types * 2);
unsigned *new_query_types
= REALLOC(bq->query_types,
bq->allocated_query_types * sizeof(unsigned),
new_alloc * sizeof(unsigned));
if (!new_query_types)
return false;
bq->query_types = new_query_types;
bq->allocated_query_types = new_alloc;
}
bq->query_types[bq->num_query_types] = query_type;
*result_index = bq->num_query_types++;
return true;
}
spif_bool_t
spif_str_splice_from_ptr(spif_str_t self, spif_stridx_t idx, spif_stridx_t cnt, spif_charptr_t other)
{
spif_charptr_t tmp, ptmp;
spif_stridx_t len, newsize;
ASSERT_RVAL(!SPIF_STR_ISNULL(self), FALSE);
len = (other ? strlen((const char *) other) : 0);
if (idx < 0) {
idx = self->len + idx;
}
REQUIRE_RVAL(idx >= 0, FALSE);
REQUIRE_RVAL(idx < self->len, FALSE);
if (cnt < 0) {
cnt = idx + self->len + cnt;
}
REQUIRE_RVAL(cnt >= 0, FALSE);
REQUIRE_RVAL(cnt <= (self->len - idx), FALSE);
newsize = self->len + len - cnt + 1;
ptmp = tmp = (spif_charptr_t) MALLOC(newsize);
if (idx > 0) {
memcpy(tmp, self->s, idx);
ptmp += idx;
}
if (len) {
memcpy(ptmp, other, len);
ptmp += len;
}
memcpy(ptmp, self->s + idx + cnt, self->len - idx - cnt + 1);
if (self->size < newsize) {
self->s = (spif_charptr_t) REALLOC(self->s, newsize);
self->size = newsize;
}
self->len = newsize - 1;
memcpy(self->s, tmp, newsize);
FREE(tmp);
return TRUE;
}
int pc_mp_send_switches_0(void)
{
char *msg, *str;
TERM msw;
int msglen, msgsiz;
int vals[2];
int i, n;
msglen = 0;
msgsiz = 65536;
msg = MALLOC(msgsiz);
for (i = 0; i < occ_switch_tab_size; i++) {
msw = bpx_get_arg(1, prism_sw_ins_term(occ_switches[i]->id));
str = (char *)bpx_term_2_string(msw);
n = strlen(str) + 1;
if (msgsiz <= msglen + n) {
msgsiz = (msglen + n + 65536) & ~65535;
msg = REALLOC(msg, msgsiz);
}
strcpy(msg + msglen, str);
msglen += n;
}
msg[msglen++] = '\0'; /* this is safe */
vals[0] = msglen;
vals[1] = occ_switch_tab_size;
MPI_Gather(vals, 2, MPI_INT, NULL, 0, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Send(msg, msglen, MPI_CHAR, 0, TAG_SWITCH_REQ, MPI_COMM_WORLD);
free(msg);
return BP_TRUE;
}
static boolean svga_shader_expand( struct svga_shader_emitter *emit )
{
char *new_buf;
unsigned newsize = emit->size * 2;
if(emit->buf != err_buf)
new_buf = REALLOC(emit->buf, emit->size, newsize);
else
new_buf = NULL;
if (new_buf == NULL) {
emit->ptr = err_buf;
emit->buf = err_buf;
emit->size = sizeof(err_buf);
return FALSE;
}
emit->size = newsize;
emit->ptr = new_buf + (emit->ptr - emit->buf);
emit->buf = new_buf;
return TRUE;
}
