int check_alloc(int num)
{
int to_alloc;
if (num < coors_allocated)
return 0;
to_alloc = coors_allocated;
while (num >= to_alloc)
to_alloc += CHUNK;
if (coors_allocated == 0) {
xarray = (int *)falloc(to_alloc, sizeof(int));
yarray = (int *)falloc(to_alloc, sizeof(int));
}
else {
xarray = (int *)frealloc((char *)xarray,
to_alloc, sizeof(int), coors_allocated);
yarray = (int *)frealloc((char *)yarray,
to_alloc, sizeof(int), coors_allocated);
}
coors_allocated = to_alloc;
return 0;
}
void abitwriter::write( unsigned int val, int nbits )
{
// safety check for error
if ( error ) return;
// test if pointer beyond flush treshold
if ( cbyte > ( dsize - 5 ) ) {
dsize += adds;
data = (unsigned char*) frealloc( data, dsize );
if ( data == NULL ) {
error = true;
return;
}
memset( ( data + cbyte + 1 ), 0, ( dsize - ( cbyte + 1 ) ) * sizeof( char ) );
}
// write data
while ( nbits >= cbit ) {
data[cbyte] |= ( MBITS32(val, nbits, (nbits-cbit)) );
nbits -= cbit;
cbyte++;
cbit = 8;
}
if ( nbits > 0 ) {
data[cbyte] |= ( (RBITS32(val, nbits)) << (cbit - nbits) );
cbit -= nbits;
}
}
unsigned char* abytewriter::getptr( void )
{
// safety check for error
if ( error ) return NULL;
// forbid freeing memory
fmem = false;
// realloc data
data = (unsigned char*) frealloc( data, cbyte );
return data;
}
unsigned char* abitwriter::getptr( void )
{
// data is padded here
pad( fillbit );
// forbid freeing memory
fmem = false;
// realloc data
data = (unsigned char*) frealloc( data, cbyte );
return data;
}
/**
* @brief resizes the server list
* @return 1 if resize failed, 0 otherwise
**/
int string_list_resize(string_list** servers)
{
int new_size = (*servers)->max_size + SERVER_LIST_DEFAULT_MAX_SIZE;
char** new_array;
if((new_array = (char**) frealloc((*servers)->array,
new_size * sizeof(char*))) == NULL)
return 1;
(*servers)->max_size = new_size;
(*servers)->array = new_array;
return 0;
}
void abytewriter::write( unsigned char byte )
{
// safety check for error
if ( error ) return;
// test if pointer beyond flush threshold
if ( cbyte >= ( dsize - 2 ) ) {
dsize += adds;
data = (unsigned char*) frealloc( data, dsize );
if ( data == NULL ) {
error = true;
return;
}
}
// write data
data[ cbyte++ ] = byte;
}
void abytewriter::write_n( unsigned char* byte, int n )
{
// safety check for error
if ( error ) return;
// make sure that pointer doesn't get beyond flush threshold
while ( ( cbyte + n ) >= ( dsize - 2 ) ) {
dsize += adds;
data = (unsigned char*) frealloc( data, dsize );
if ( data == NULL ) {
error = true;
return;
}
}
// copy data from array
while ( n-- > 0 )
data[ cbyte++ ] = *(byte++);
}
/**
* @function ferite_stack_push
* @declaration void ferite_stack_push( FeriteStack *stck, void *ptr )
* @brief Push a value onto the stack
* @param FeriteStack *stck The stack to push the value onto
* @param void *ptr The pointer to push onto the stack
*/
void ferite_stack_push( FeriteScript *script, FeriteStack *stck, void *ptr )
{
int i;
FE_ENTER_FUNCTION;
stck->stack_ptr++;
if( stck->stack_ptr < stck->size )
stck->stack[stck->stack_ptr] = ptr;
else
{
FUD(("Resizing STACK\n"));
/* stack aint big enough. make it bigger. */
stck->size *= 2;
stck->stack = frealloc( stck->stack, sizeof( void * ) * stck->size );
for( i = stck->stack_ptr; i < stck->size; i++ )
stck->stack[i] = NULL;
stck->stack[stck->stack_ptr] = ptr;
}
FE_LEAVE_FUNCTION( NOWT );
}
const char* indentation(unsigned level) {
/* Try just using a static array full of spaces */
static char blanks[40 * IWIDTH + 1] = "";
if(blanks[0] == '\0') {
memset(blanks, ICHAR, ARRSIZE(blanks) - 1);
blanks[ARRSIZE(blanks) - 1] = '\0';
}
if(level <= (ARRSIZE(blanks) - 1) / IWIDTH) {
return &blanks[ARRSIZE(blanks) - 1 - level * IWIDTH];
}
/* Too much indentation for static array */
/* Find target index of spaces array large enough */
size_t index = 0;
size_t count = (ARRSIZE(blanks) - 1) / IWIDTH;
while(level > count) {
++index;
count *= 2;
}
/* Expand array if necessary */
static size_t large_count = 0;
static char** larger = NULL;
if(index + 1 > large_count) {
size_t new_count = index + 1;
larger = frealloc(larger, new_count * sizeof(*larger));
memset(larger + large_count, 0, (new_count - large_count) * sizeof(*larger));
large_count = new_count;
}
/* Need to create array of spaces */
if(larger[index] == NULL) {
larger[index] = fmalloc(count * IWIDTH + 1);
memset(larger[index], IWIDTH, count * IWIDTH);
larger[index][count * IWIDTH] = '\0';
}
return &larger[index][(count - level) * IWIDTH];
}
void abitwriter::write_bit( unsigned char bit )
{
// safety check for error
if ( error ) return;
// write data
if ( bit ) data[cbyte] |= 0x1 << (--cbit);
else --cbit;
if ( cbit == 0 ) {
// test if pointer beyond flush treshold
if ( ++cbyte > ( dsize - 5 ) ) {
dsize += adds;
data = (unsigned char*) frealloc( data, dsize );
if ( data == NULL ) {
error = true;
return;
}
memset( ( data + cbyte + 1 ), 0, ( dsize - ( cbyte + 1 ) ) * sizeof( char ) );
}
cbit = 8;
}
}
/**
* fills the global searchresult structure with the results of the given search.
* Returns the number of found titles.
* pat - pattern to search for
* global - include DNP
* fill - fill artist and album results
*/
int search( const char *pat, const mpcmd range, const int global ) {
mptitle *root=getConfig()->root;
mptitle *runner=root;
searchresults *res=getConfig()->found;
unsigned int i=0;
int found=0;
unsigned int cnt=0;
/* free buffer playlist, the arrays will not get lost due to the realloc later */
res->titles=wipePlaylist(res->titles);
res->tnum=0;
res->anum=0;
res->lnum=0;
do {
activity("searching");
found=0;
if( global || !(runner->flags & MP_DNP) ) {
/* check for searchrange and pattern */
if( MPC_ISTITLE(range) &&
isMatch( runner->title, pat, MPC_ISFUZZY(range) ) ) {
found=1;
}
if( MPC_ISDISPLAY( range ) &&
isMatch( runner->display, pat, MPC_ISFUZZY(range) ) ) {
found=1;
}
if( MPC_ISARTIST(range) &&
isMatch( runner->artist, pat, MPC_ISFUZZY(range) ) ) {
found=1;
}
if( MPC_ISALBUM( range ) &&
isMatch( runner->album, pat, MPC_ISFUZZY(range) ) ) {
found=1;
}
/* todo: genre and path are missing here */
if( found ) {
/* check for new artist */
for( i=0; (i<res->anum) && strcmp( res->artists[i], runner->artist ); i++ );
if( i == res->anum ) {
res->anum++;
res->artists=(char**)frealloc( res->artists, res->anum*sizeof(char*) );
res->artists[i]=runner->artist;
}
for( i=0; (i<res->lnum) && strcmp( res->albums[i], runner->album ); i++ );
if( i == res->lnum ) {
res->lnum++;
res->albums=(char**)frealloc( res->albums, res->lnum*sizeof(char*) );
res->albums[i]=runner->album;
res->albart=(char**)frealloc( res->albart, res->lnum*sizeof(char*) );
res->albart[i]=runner->artist;
}
else if( !strcmp( res->albart[i], ARTIST_SAMPLER ) &&
strcmp( res->albart[i], runner->artist ) ){
addMessage(1, "%s is considered a sampler (%s <> %s).", runner->album, runner->artist, res->albart[i] );
res->albart[i]=ARTIST_SAMPLER;
}
}
/* add titles too */
if( ( found != 0 ) && ( cnt++ < MAXSEARCH ) ) {
res->titles=appendToPL( runner, res->titles, 0 );
res->tnum++;
}
}
runner=runner->next;
} while( runner != root );
res->send=-1;
return (cnt>MAXSEARCH)?-1:cnt;
}
void returnGiant(giant g)
{
#if GIANTS_VIA_STACK
unsigned stackNum;
gstack *gs;
unsigned cap = g->capacity;
#if FEE_DEBUG
if(!gstackInitd) {
CKRaise("returnGiant before stacks initialized!");
}
#endif // FEE_DEBUG
#if GIANT_MAC_DEBUG
if(g == NULL) {
dblog0("returnGiant: null g!\n");
}
#endif
/*
* Find appropriate stack. Note we expect exact match of
* capacity and stack's giant size.
*/
/*
* Optimized unrolled loop. Just make sure there are enough cases
* to handle all of the stacks. Errors in this case will be flagged
* via LOG_GIANT_STACK_OVERFLOW.
*/
switch(cap) {
case MIN_GIANT_SIZE:
stackNum = 0;
break;
case MIN_GIANT_SIZE << GIANT_SIZE_INCR:
stackNum = 1;
break;
case MIN_GIANT_SIZE << (2 * GIANT_SIZE_INCR):
stackNum = 2;
break;
case MIN_GIANT_SIZE << (3 * GIANT_SIZE_INCR):
stackNum = 3;
break;
case MIN_GIANT_SIZE << (4 * GIANT_SIZE_INCR):
stackNum = 4;
break;
default:
stackNum = numGstacks;
break;
}
if(stackNum >= numGstacks) {
/*
* out of bounds; just free
*/
#if LOG_GIANT_STACK_OVERFLOW
gstackDbg(("giantToStack overflow; numDigits %d\n", cap));
#endif // LOG_GIANT_STACK_OVERFLOW
freeGiant(g);
return;
}
gs = &gstacks[stackNum];
if(gs->numFree == gs->totalGiants) {
if(gs->totalGiants == 0) {
gstackDbg(("Initial alloc of gstack(%d)\n",
gs->numDigits));
gs->totalGiants = INIT_NUM_GIANTS;
}
else {
gs->totalGiants *= 2;
gstackDbg(("Bumping gstack(%d) to %d\n",
gs->numDigits, gs->totalGiants));
}
gs->stack = (giantstruct**) frealloc(gs->stack, gs->totalGiants*sizeof(giant));
}
g->sign = 0; // not sure this is important...
gs->stack[gs->numFree++] = g;
#if GIANT_MAC_DEBUG
if((gs->numFree != 0) && (gs->stack == NULL)) {
dblog0("borrowGiant: null stack!\n");
}
#endif
#else /* GIANTS_VIA_STACK */
freeGiant(g);
#endif /* GIANTS_VIA_STACK */
}
Expression* Expression_parse(const char** expr) {
Expression* ret = NULL;
Variable* var;
Value* val;
const char* equals = strchr(*expr, '=');
if(equals == NULL) {
/* No assignment, just a plain expression. */
return parseExpr(expr);
}
/* There is an assignment */
/* First, parse the right side of the assignment */
equals++;
val = Value_parse(&equals, 0, 0);
if(val->type == VAL_ERR) {
/* A parse error occurred */
var = VarErr(Error_copy(val->err));
Value_free(val);
return Expression_new(var);
}
if(val->type == VAL_END) {
/* Empty input */
Value_free(val);
var = VarErr(earlyEnd());
return Expression_new(var);
}
/* Now parse the left side */
char* name = nextToken(expr);
if(name == NULL) {
Value_free(val);
var = VarErr(syntaxError("No variable to assign to."));
return Expression_new(var);
}
trimSpaces(expr);
if(**expr == '(') {
/* Defining a function */
(*expr)++;
/* Array of argument names */
unsigned size = 2;
char** args = fmalloc(size * sizeof(*args));
unsigned len = 0;
/* Add each argument name to the array */
char* arg = nextToken(expr);
if(arg == NULL && **expr != ')') {
/* Invalid character */
Value_free(val);
free(args);
free(name);
var = VarErr(badChar(**expr));
return Expression_new(var);
}
trimSpaces(expr);
if(arg == NULL) {
/* Empty parameter list means function with no args */
free(args);
args = NULL;
len = 0;
}
else {
/* Loop through each argument in the list */
while(**expr == ',' || **expr == ')') {
args[len++] = arg;
if(**expr == ')')
break;
(*expr)++;
/* Expand argument array if it's too small */
if(len >= size) {
size *= 2;
args = frealloc(args, size * sizeof(*args));
}
arg = nextToken(expr);
if(arg == NULL) {
/* Invalid character */
Value_free(val);
free(name);
/* Free argument names and return */
unsigned i;
for(i = 0; i < len; i++) {
free(args[i]);
}
free(args);
var = VarErr(badChar(**expr));
return Expression_new(var);
}
trimSpaces(expr);
}
}
if(**expr != ')') {
/* Invalid character inside argument name list */
Value_free(val);
free(name);
/* Free argument names and return */
unsigned i;
for(i = 0; i < len; i++) {
free(args[i]);
}
free(args);
var = VarErr(badChar(**expr));
return Expression_new(var);
}
/* Skip closing parenthesis */
(*expr)++;
trimSpaces(expr);
if(**expr != '=') {
Value_free(val);
free(name);
unsigned i;
for(i = 0; i < len; i++) {
free(args[i]);
}
free(args);
var = VarErr(badChar(**expr));
return Expression_new(var);
}
/* Construct function and return it */
Function* func = Function_new(len, args, val);
var = VarFunc(name, func);
free(name);
ret = Expression_new(var);
}
else {
/* Defining a variable */
if(**expr != '=') {
/* In-place manipulation */
BINTYPE bin = BinOp_nextType(expr, 0, 0);
/* Still not an equals sign means invalid character */
if(**expr != '=') {
Value_free(val);
free(name);
var = VarErr(badChar(**expr));
return Expression_new(var);
}
val = ValExpr(BinOp_new(bin, ValVar(name), val));
}
var = VarValue(name, val);
free(name);
ret = Expression_new(var);
}
return ret;
}
