/* return pointer to copy of substitution template in the command buffer */
static char *extract_subst_template( const char **ibufpp, const char isglobal )
{
int i = 0, n = 0;
char c;
const char delimiter = **ibufpp;
++(*ibufpp);
if( **ibufpp == '%' && (*ibufpp)[1] == delimiter )
{
++(*ibufpp);
if( !stbuf ) set_error_msg( "No previous substitution" );
return stbuf;
}
while( **ibufpp != delimiter )
{
if( !resize_buffer( &stbuf, &stbufsz, i + 2 ) ) return 0;
c = stbuf[i++] = *(*ibufpp)++;
if( c == '\n' && **ibufpp == 0 ) { --i, --(*ibufpp); break; }
if( c == '\\' && ( stbuf[i++] = *(*ibufpp)++ ) == '\n' && !isglobal )
{
while( ( *ibufpp = get_tty_line( &n ) ) &&
( n == 0 || ( n > 0 && (*ibufpp)[n-1] != '\n' ) ) )
clearerr( stdin );
if( !(*ibufpp) ) return 0;
}
}
if( !resize_buffer( &stbuf, &stbufsz, i + 1 ) ) return 0;
stbuf[stlen = i] = 0;
return stbuf;
}
/* modify text according to a substitution template; return offset to
end of modified text */
static int apply_subst_template( const char *boln, const regmatch_t *rm, int off,
const int re_nsub )
{
const char *sub = stbuf;
for( ; sub - stbuf < stlen; ++sub )
{
int n;
if( *sub == '&' )
{
int j = rm[0].rm_so; int k = rm[0].rm_eo;
if( !resize_buffer( &rbuf, &rbufsz, off + k - j ) ) return -1;
while( j < k ) rbuf[off++] = boln[j++];
}
else if( *sub == '\\' && *++sub >= '1' && *sub <= '9' &&
( n = *sub - '0' ) <= re_nsub )
{
int j = rm[n].rm_so; int k = rm[n].rm_eo;
if( !resize_buffer( &rbuf, &rbufsz, off + k - j ) ) return -1;
while( j < k ) rbuf[off++] = boln[j++];
}
else
{
if( !resize_buffer( &rbuf, &rbufsz, off + 1 ) ) return -1;
rbuf[off++] = *sub;
}
}
if( !resize_buffer( &rbuf, &rbufsz, off + 1 ) ) return -1;
rbuf[off] = 0;
return off;
}
/* replace a range of lines with the joined text of those lines */
bool join_lines( const int from, const int to, const bool isglobal )
{
static char * buf = 0;
static int bufsz = 0;
int size = 0;
line_t * const ep = search_line_node( inc_addr( to ) );
line_t * bp = search_line_node( from );
while( bp != ep )
{
const char * const s = get_sbuf_line( bp );
if( !s || !resize_buffer( &buf, &bufsz, size + bp->len ) ) return false;
memcpy( buf + size, s, bp->len );
size += bp->len;
bp = bp->q_forw;
}
if( !resize_buffer( &buf, &bufsz, size + 2 ) ) return false;
memcpy( buf + size, "\n", 2 );
size += 2;
if( !delete_lines( from, to, isglobal ) ) return false;
current_addr_ = from - 1;
disable_interrupts();
if( !put_sbuf_line( buf, size, current_addr_ ) ||
!push_undo_atom( UADD, current_addr_, current_addr_ ) )
{ enable_interrupts(); return false; }
modified_ = true;
enable_interrupts();
return true;
}
/* Read until the next space, '=', EOL, or EOF. Escape using backslash. */
char *read_option_string(STREAM *file) {
int buffersize = 10;
int c, i = 0;
char *newbuffer = NULL;
char *buffer = (char *)malloc(buffersize);
while ((c = stream_getc(file)) != EOF && c != '\n' && c != '=' && c > ' ') {
if (c == '\\') {
c = stream_getc(file);
if (c == EOF) {
break;
}
}
buffer[i++] = c;
if (i >= buffersize) {
newbuffer = resize_buffer(buffer, buffersize, buffersize + buffersize);
if (!newbuffer) {
free(buffer);
return NULL;
}
buffer = newbuffer;
buffersize += buffersize;
}
}
stream_ungetc(c, file);
buffer[i] = 0;
return buffer;
}
void Fl_Device::rtl_draw(const char *str, int n, float x, float y)
{
// USE BUFFER HERE ALSO
SetTextColor(fl_gc, fl_colorref);
SelectObject(fl_gc, current_font);
int i = 0;
int lx = 0;
const WCHAR *skod;
resize_buffer(n);
int wn = fl_utf2unicode((const unsigned char *)str, n, wstr);
while (i < wn) {
lx = int(fl_width(wstr[i]));
x -= lx;
skod = (const WCHAR*)wstr + i;
#ifndef _WIN32_WCE
TextOutW(fl_gc, int(floor(x+.5f)), int(floor(y+.5f)), skod, 1);
#else
RECT rect = {int(floor(x+.5f)),int(floor(y+.5f)), 0,0};
DrawText(fl_gc, skod, 1, &rect, DT_SINGLELINE | DT_TOP | DT_LEFT | DT_NOCLIP);
#endif
if (fl_nonspacing(wstr[i])) {
x += lx;
}
i++;
}
}
/* get a line of text from the scratch file; return pointer to the text */
char * get_sbuf_line( const line_t * const lp )
{
static char * buf = 0;
static int bufsz = 0;
int len;
if( lp == &buffer_head ) return 0;
seek_write = true; /* force seek on write */
/* out of position */
if( sfpos != lp->pos )
{
sfpos = lp->pos;
if( fseek( sfp, sfpos, SEEK_SET ) != 0 )
{
show_strerror( 0, errno );
set_error_msg( "Cannot seek temp file" );
return 0;
}
}
len = lp->len;
if( !resize_buffer( &buf, &bufsz, len + 1 ) ) return 0;
if( (int)fread( buf, 1, len, sfp ) != len )
{
show_strerror( 0, errno );
set_error_msg( "Cannot read temp file" );
return 0;
}
sfpos += len; /* update file position */
buf[len] = 0;
return buf;
}
bool CMonitorData::processHierarchyRequest( UdpConnection *con, short & sequence )
{
int x,size;
char temp[215];
if( m_count == 0 )
{
send(con,sequence,MON_MSG_REPLY_HIERARCHY,"NOTREADY");
return 0;
}
if( m_sort )
{
qsort(m_data,m_count,sizeof(MON_ELEMENT),compar);
m_sort = 0;
}
memset(m_buffer,0, 16);
size = 0;
for(x=0;x<m_count;x++)
{
snprintf(temp, sizeof(temp), "%s,%X,%d|", m_data[x].label, m_data[x].id, m_data[x].ping);
size += strlen(temp);
if( size >= m_nbuffer )
resize_buffer(size+BUFFER_RESIZE_VALUE);
strcat(m_buffer,temp);
}
send(con,sequence,MON_MSG_REPLY_HIERARCHY,m_buffer);
return 1;
}
int oa_serialize_buffer(struct oarchive *oa, const char *name,
const struct buffer *b)
{
struct buff_struct *priv = oa->priv;
int rc;
if (!b) {
return oa_serialize_int(oa, "len", &negone);
}
rc = oa_serialize_int(oa, "len", &b->len);
if (rc < 0)
return rc;
// this means a buffer of NUll
// with size of -1. This is
// waht we use in java serialization for NULL
if (b->len == -1) {
return rc;
}
if ((priv->len - priv->off) < b->len) {
rc = resize_buffer(priv, priv->len + b->len);
if (rc < 0)
return rc;
}
memcpy(priv->buffer+priv->off, b->buff, b->len);
priv->off += b->len;
return 0;
}
/* Return pointer to copy of filename in the command buffer */
static const char * get_filename( const char ** const ibufpp )
{
static char * buf = 0;
static int bufsz = 0;
const int pmax = path_max( 0 );
int n;
*ibufpp = skip_blanks( *ibufpp );
if( **ibufpp != '\n' )
{
int size = 0;
if( !get_extended_line( ibufpp, &size, true ) ) return 0;
if( **ibufpp == '!' )
{
++*ibufpp;
return get_shell_command( ibufpp );
}
else if( size > pmax )
{ set_error_msg( "Filename too long" ); return 0; }
}
else if( !traditional() && !def_filename[0] )
{ set_error_msg( "No current filename" ); return 0; }
if( !resize_buffer( &buf, &bufsz, pmax + 1 ) ) return 0;
for( n = 0; **ibufpp != '\n'; ++n, ++*ibufpp ) buf[n] = **ibufpp;
buf[n] = 0;
while( **ibufpp == '\n' ) ++*ibufpp; /* skip newline */
return ( may_access_filename( buf ) ? buf : 0 );
}
static void OutCharMem(R_outpstream_t stream, int c)
{
membuf_t mb = (membuf_t) stream->data;
if (mb->count >= mb->size)
resize_buffer(mb, mb->count + 1);
mb->buf[mb->count++] = (char) c;
}
/* copy a pattern string from the command buffer; return pointer to the copy */
static char *extract_pattern( const char **ibufpp, const int delimiter )
{
static char *buf = 0;
static int bufsz = 0;
const char *nd = *ibufpp;
int len;
while( *nd != delimiter && *nd != '\n' )
{
if( *nd == '[' )
{
nd = parse_char_class( ++nd );
if( !nd ) { set_error_msg( "Unbalanced brackets ([])" ); return 0; }
}
else if( *nd == '\\' && *++nd == '\n' )
{ set_error_msg( "Trailing backslash (\\)" ); return 0; }
++nd;
}
len = nd - *ibufpp;
if( !resize_buffer( &buf, &bufsz, len + 1 ) ) return 0;
memcpy( buf, *ibufpp, len );
buf[len] = 0;
*ibufpp = nd;
if( isbinary() ) nul_to_newline( buf, len );
return buf;
}
static int
send_buffer(char *aString, int32_t size, struct messaging *m)
{
int free;
int err = 0;
pthread_mutex_lock(&m->mutex);
if ((CEIL4(size) + 4) > m->capacity) {
err = resize_buffer(m, size);
}
free = m->is_full
? 0 : (m->free_end - m->free_start + (m->free_start >= m->free_end ? m->capacity : 0));
if ((CEIL4(size) + 4) > free) {
err = resize_buffer(m, size);
}
if (!err) {
int first_part_size, second_part_size;
m->buffer[m->free_start/4] = size;
m->free_start += 4;
if (m->free_start == m->capacity) {
m->free_start = 0;
}
first_part_size = (size < m->capacity - m->free_start)
? size : m->capacity - m->free_start;
second_part_size = size - first_part_size > 0 ? size - first_part_size : 0;
memcpy(&m->buffer[m->free_start/4], aString, first_part_size);
m->free_start += CEIL4(first_part_size);
if (second_part_size > 0) {
//assert(b2s_free_start == b2s_capacity);
m->free_start = 0;
memcpy(&m->buffer[m->free_start/4], aString + first_part_size, second_part_size);
m->free_start += CEIL4(second_part_size);
}
if (m->free_start == m->capacity) {
m->free_start = 0;
}
if (m->free_start == m->free_end) {
m->is_full = 1;
}
}
pthread_mutex_unlock(&m->mutex);
return err;
}
/* replace text matched by a pattern according to a substitution
template; return pointer to the modified text */
static int replace_matching_text( const line_t *lp, const int gflags,
const int snum )
{
const int se_max = 30; /* max subexpressions in a regular expression */
regmatch_t rm[se_max];
char *txt = get_sbuf_line( lp );
char *eot;
int i = 0, off = 0;
char changed = 0;
if( !txt ) return -1;
if( isbinary() ) nul_to_newline( txt, lp->len );
eot = txt + lp->len;
if( !regexec( global_pat, txt, se_max, rm, 0 ) )
{
int matchno = 0;
do {
if( !snum || snum == ++matchno )
{
changed = 1; i = rm[0].rm_so;
if( !resize_buffer( &rbuf, &rbufsz, off + i ) ) return -1;
if( isbinary() ) newline_to_nul( txt, rm[0].rm_eo );
memcpy( rbuf + off, txt, i ); off += i;
off = apply_subst_template( txt, rm, off, global_pat->re_nsub );
if( off < 0 ) return -1;
}
else
{
i = rm[0].rm_eo;
if( !resize_buffer( &rbuf, &rbufsz, off + i ) ) return -1;
if( isbinary() ) newline_to_nul( txt, i );
memcpy( rbuf + off, txt, i ); off += i;
}
txt += rm[0].rm_eo;
}
while( *txt && ( !changed || ( ( gflags & GSG ) && rm[0].rm_eo ) ) &&
!regexec( global_pat, txt, se_max, rm, REG_NOTBOL ) );
i = eot - txt;
if( !resize_buffer( &rbuf, &rbufsz, off + i + 2 ) ) return -1;
if( i > 0 && !rm[0].rm_eo && ( gflags & GSG ) )
{ set_error_msg( "Infinite substitution loop" ); return -1; }
if( isbinary() ) newline_to_nul( txt, i );
memcpy( rbuf + off, txt, i );
memcpy( rbuf + off + i, "\n", 2 );
}
return ( changed ? off + i + 1 : 0 );
}
void
buffer_append(struct buffer *b, const char *bytes, int length)
{
if (length >= (b->size - b->offset - 1))
resize_buffer(b, length);
memcpy(&b->buffer[b->offset], bytes, length);
b->offset += length;
b->buffer[b->offset] = '\0'; /* XXX - not too general, now is it? */
}
void
buffer_append(struct buffer *b, const char *bytes, int length)
{
if (length >= (b->size - b->offset))
resize_buffer(b, length);
/* XXX - assumes resize_buffer() always succeeds. */
memcpy(&b->buffer[b->offset], bytes, length);
b->offset += length;
}
/* Append the LEN bytes at ADDR to the buffer B. */
static void
appendmem (struct macro_buffer *b, char *addr, int len)
{
int new_len = b->len + len;
if (new_len > b->size)
resize_buffer (b, new_len);
memcpy (b->text + b->len, addr, len);
b->len = new_len;
}
/* Append the character C to the buffer B. */
static void
appendc (struct macro_buffer *b, int c)
{
int new_len = b->len + 1;
if (new_len > b->size)
resize_buffer (b, new_len);
b->text[b->len] = c;
b->len = new_len;
}
struct growable_buffer
fdrecorder_get_clean(struct fdrecorder* fdr)
{
fdrecorder_poll(fdr);
struct growable_buffer buffer = fdr->buffer;
assert(fdr->nr_bytes_recorded <= buffer.bufsz);
resize_buffer(&buffer, fdr->nr_bytes_recorded);
memset(&fdr->buffer, 0, sizeof (fdr->buffer));
fdr->nr_bytes_recorded = 0;
return buffer;
}
int oa_serialize_long(struct oarchive *oa, const char *tag, const int64_t *d)
{
const int64_t i = htonll(*d);
struct buff_struct *priv = oa->priv;
if ((priv->len - priv->off) < sizeof(i)) {
int rc = resize_buffer(priv, priv->len + sizeof(i));
if (rc < 0) return rc;
}
memcpy(priv->buffer+priv->off, &i, sizeof(i));
priv->off+=sizeof(i);
return 0;
}
/* return unescaped copy of escaped string */
const char * strip_escapes( const char * p )
{
static char * buf = 0;
static int bufsz = 0;
const int len = strlen( p );
int i = 0;
if( !resize_buffer( &buf, &bufsz, len + 1 ) ) return 0;
/* assert: no trailing escape */
while( ( buf[i++] = ( (*p == '\\' ) ? *++p : *p ) ) )
++p;
return buf;
}
static void OutBytesMem(R_outpstream_t stream, void *buf, int length)
{
membuf_t mb = (membuf_t) stream->data;
R_xlen_t needed = mb->count + (R_xlen_t) length;
#ifndef LONG_VECTOR_SUPPORT
/* There is a potential overflow here on 32-bit systems */
if ((double) mb->count + length > (double) INT_MAX)
error("serialization is too large to store in a raw vector");
#endif
if (needed > mb->size) resize_buffer(mb, needed);
memcpy(mb->buf + mb->count, buf, length);
mb->count = needed;
}
int oa_serialize_bool(struct oarchive *oa, const char *name, const int32_t *i)
{
//return oa_serialize_int(oa, name, i);
struct buff_struct *priv = oa->priv;
if ((priv->len - priv->off) < 1) {
int rc = resize_buffer(priv, priv->len + 1);
if (rc < 0)
return rc;
}
priv->buffer[priv->off] = (*i == 0 ? '\0' : '\1');
priv->off++;
return 0;
}
/* apply command list in the command buffer to the active lines in a
range; return false if error */
static bool exec_global( const char ** const ibufpp, const int gflags,
const bool interactive )
{
static char * buf = 0;
static int bufsz = 0;
const char * cmd = 0;
if( !interactive )
{
if( traditional() && !strcmp( *ibufpp, "\n" ) )
cmd = "p\n"; /* null cmd_list == 'p' */
else
{
if( !get_extended_line( ibufpp, 0, false ) ) return false;
cmd = *ibufpp;
}
}
clear_undo_stack();
while( true )
{
const line_t * const lp = next_active_node();
if( !lp ) break;
set_current_addr( get_line_node_addr( lp ) );
if( current_addr() < 0 ) return false;
if( interactive )
{
/* print current_addr; get a command in global syntax */
int len;
if( !display_lines( current_addr(), current_addr(), gflags ) )
return false;
do { *ibufpp = get_tty_line( &len ); }
while( *ibufpp && len > 0 && (*ibufpp)[len-1] != '\n' );
if( !*ibufpp ) return false;
if( len == 0 )
{ set_error_msg( "Unexpected end-of-file" ); return false; }
if( len == 1 && !strcmp( *ibufpp, "\n" ) ) continue;
if( len == 2 && !strcmp( *ibufpp, "&\n" ) )
{ if( !cmd ) { set_error_msg( "No previous command" ); return false; } }
else
{
if( !get_extended_line( ibufpp, &len, false ) ||
!resize_buffer( &buf, &bufsz, len + 1 ) ) return false;
memcpy( buf, *ibufpp, len + 1 );
cmd = buf;
}
}
*ibufpp = cmd;
while( **ibufpp ) if( exec_command( ibufpp, 0, true ) < 0 ) return false;
}
return true;
}
/* Return pointer to copy of shell command in the command buffer */
static const char * get_shell_command( const char ** const ibufpp )
{
static char * buf = 0;
static int bufsz = 0;
static char * shcmd = 0; /* shell command buffer */
static int shcmdsz = 0; /* shell command buffer size */
static int shcmdlen = 0; /* shell command length */
const char * p; /* substitution char pointer */
int i = 0, len;
if( restricted() ) { set_error_msg( "Shell access restricted" ); return 0; }
if( !get_extended_line( ibufpp, &len, true ) ) return 0;
p = *ibufpp;
if( !resize_buffer( &buf, &bufsz, len + 1 ) ) return 0;
buf[i++] = '!'; /* prefix command w/ bang */
while( **ibufpp != '\n' )
{
if( **ibufpp == '!' )
{
if( p != *ibufpp )
{
if( !resize_buffer( &buf, &bufsz, i + 1 ) ) return 0;
buf[i++] = *(*ibufpp)++;
}
else if( !shcmd || ( traditional() && !*( shcmd + 1 ) ) )
{ set_error_msg( "No previous command" ); return 0; }
else
{
if( !resize_buffer( &buf, &bufsz, i + shcmdlen ) ) return 0;
for( p = shcmd + 1; p < shcmd + shcmdlen; ) buf[i++] = *p++;
p = (*ibufpp)++;
}
}
else if( **ibufpp == '%' )
{
if( !def_filename[0] )
{ set_error_msg( "No current filename" ); return 0; }
p = strip_escapes( def_filename );
len = strlen( p );
if( !resize_buffer( &buf, &bufsz, i + len ) ) return 0;
while( len-- ) buf[i++] = *p++;
p = (*ibufpp)++;
}
else
{
if( !resize_buffer( &buf, &bufsz, i + 2 ) ) return 0;
buf[i++] = **ibufpp;
if( *(*ibufpp)++ == '\\' ) buf[i++] = *(*ibufpp)++;
}
}
while( **ibufpp == '\n' ) ++*ibufpp; /* skip newline */
if( !resize_buffer( &shcmd, &shcmdsz, i + 1 ) ) return 0;
memcpy( shcmd, buf, i );
shcmdlen = i; shcmd[i] = 0;
if( *p == '!' || *p == '%' ) printf( "%s\n", shcmd + 1 );
return shcmd;
}
// ------------------ Game Data Object ----------------------------
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CMonitorData::CMonitorData()
{
m_sequence = 1;
m_buffer = NULL;
m_nbuffer = 0;
m_count = 0;
m_max = ELEMENT_START_VALUE;
m_data = new MON_ELEMENT[m_max];
for(int x=0;x<m_max;x++)
{
memset(&m_data[x],0,sizeof(MON_ELEMENT));
}
resize_buffer(BUFFER_SIZE_START);
}
static void fullscreen_cb(void)
{
if (!isfullscreen)
{
window_geometry_valid = true;
GetWindowRect(window, &window_geometry);
write_window_geometry();
}
isfullscreen = !isfullscreen;
if (isfullscreen)
switch_to_full_screen();
else
switch_to_windowed();
resize_buffer();
}
void ci_cached_file_reset(ci_cached_file_t * body, int new_size)
{
if (body->fd > 0) {
do_close(body->fd);
unlink(body->filename); /*Comment out for debuging reasons */
}
body->endpos = 0;
body->readpos = 0;
body->flags = 0;
body->unlocked = 0;
body->fd = -1;
if (!resize_buffer(body, new_size)) {
/*free memory and open a file. */
}
}
FLAC__StreamDecoderWriteStatus flac_write(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data){
flac_file_t* flac = (flac_file_t*)client_data;
int samples = frame->header.blocksize;
int channels = frame->header.channels;
int bits_per_sample = frame->header.bits_per_sample;
int i, j;
//Create a buffer to hold the entire frame
resize_buffer(flac, channels, samples);
for (i = 0; i < channels; i++)
for (j = 0; j < samples; j++)
//Convert interger to float using fixed-point arithmetic where the scaller is equal to the 2 to the power of the bits per sample
flac->buf[i][j] = buffer[i][j] / (float) (1 << (bits_per_sample - 1));
flac->buffer_sample_count = samples;
return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
}
static void setfont_cb(void)
{
CHOOSEFONT cf;
memset(&cf, 0, sizeof(cf));
cf.lStructSize = sizeof(cf);
cf.hwndOwner = window;
cf.lpLogFont = &fontlf;
cf.Flags = CF_INITTOLOGFONTSTRUCT | CF_FIXEDPITCHONLY | CF_SCREENFONTS;
cf.nFontType = SCREEN_FONTTYPE;
if (ChooseFont(&cf))
{
write_default_font();
HDC dc = GetDC(window);
glyphcache_deinit();
glyphcache_init(dc, &fontlf);
ReleaseDC(window, dc);
resize_buffer();
}
}
int oa_serialize_string(struct oarchive *oa, const char *name, char **s)
{
struct buff_struct *priv = oa->priv;
int32_t len;
int rc;
if (!*s) {
oa_serialize_int(oa, "len", &negone);
return 0;
}
len = strlen(*s);
rc = oa_serialize_int(oa, "len", &len);
if (rc < 0)
return rc;
if ((priv->len - priv->off) < len) {
rc = resize_buffer(priv, priv->len + len);
if (rc < 0)
return rc;
}
memcpy(priv->buffer+priv->off, *s, len);
priv->off += len;
return 0;
}