TakeV/dxx-rebirth
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Avoid use of C++ keyword as variable name

Browse source
This commit is contained in:
Kp 2012-11-18 18:21:50 +00:00
parent 9d361db592
commit d2bbdfd058
9 changed files with 108 additions and 108 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
2d/bitmap.c
View file

@ -43,12 +43,12 @@ grs_bitmap *gr_create_bitmap(int w, int h )
grs_bitmap *gr_create_bitmap_raw(int w, int h, unsigned char * raw_data )
{
grs_bitmap *new;
grs_bitmap *n;
new = (grs_bitmap *)d_malloc( sizeof(grs_bitmap) );
gr_init_bitmap (new, 0, 0, 0, w, h, w, raw_data);
n = (grs_bitmap *)d_malloc( sizeof(grs_bitmap) );
gr_init_bitmap (n, 0, 0, 0, w, h, w, raw_data);
return new;
return n;
}
@ -86,12 +86,12 @@ void gr_init_bitmap_data (grs_bitmap *bm) // TODO: virtulize
grs_bitmap *gr_create_sub_bitmap(grs_bitmap *bm, int x, int y, int w, int h )
{
grs_bitmap *new;
grs_bitmap *n;
new = (grs_bitmap *)d_malloc( sizeof(grs_bitmap) );
gr_init_sub_bitmap (new, bm, x, y, w, h);
n = (grs_bitmap *)d_malloc( sizeof(grs_bitmap) );
gr_init_sub_bitmap (n, bm, x, y, w, h);
return new;
return n;
}
void gr_free_bitmap(grs_bitmap *bm )

62
2d/canvas.c
View file

@ -26,36 +26,36 @@ grs_screen * grd_curscreen; //active screen
grs_canvas *gr_create_canvas(int w, int h)
{
grs_canvas *new;
grs_canvas *n;
new = (grs_canvas *)d_malloc( sizeof(grs_canvas) );
gr_init_bitmap_alloc (&new->cv_bitmap, BM_LINEAR, 0, 0, w, h, w);
n = (grs_canvas *)d_malloc( sizeof(grs_canvas) );
gr_init_bitmap_alloc (&n->cv_bitmap, BM_LINEAR, 0, 0, w, h, w);
new->cv_color = 0;
new->cv_fade_level = GR_FADE_OFF;
new->cv_blend_func = GR_BLEND_NORMAL;
new->cv_drawmode = 0;
new->cv_font = NULL;
new->cv_font_fg_color = 0;
new->cv_font_bg_color = 0;
return new;
n->cv_color = 0;
n->cv_fade_level = GR_FADE_OFF;
n->cv_blend_func = GR_BLEND_NORMAL;
n->cv_drawmode = 0;
n->cv_font = NULL;
n->cv_font_fg_color = 0;
n->cv_font_bg_color = 0;
return n;
}
grs_canvas *gr_create_sub_canvas(grs_canvas *canv, int x, int y, int w, int h)
{
grs_canvas *new;
grs_canvas *n;
new = (grs_canvas *)d_malloc( sizeof(grs_canvas) );
gr_init_sub_bitmap (&new->cv_bitmap, &canv->cv_bitmap, x, y, w, h);
n = (grs_canvas *)d_malloc( sizeof(grs_canvas) );
gr_init_sub_bitmap (&n->cv_bitmap, &canv->cv_bitmap, x, y, w, h);
new->cv_color = canv->cv_color;
new->cv_fade_level = canv->cv_fade_level;
new->cv_blend_func = canv->cv_blend_func;
new->cv_drawmode = canv->cv_drawmode;
new->cv_font = canv->cv_font;
new->cv_font_fg_color = canv->cv_font_fg_color;
new->cv_font_bg_color = canv->cv_font_bg_color;
return new;
n->cv_color = canv->cv_color;
n->cv_fade_level = canv->cv_fade_level;
n->cv_blend_func = canv->cv_blend_func;
n->cv_drawmode = canv->cv_drawmode;
n->cv_font = canv->cv_font;
n->cv_font_fg_color = canv->cv_font_fg_color;
n->cv_font_bg_color = canv->cv_font_bg_color;
return n;
}
void gr_init_canvas(grs_canvas *canv, unsigned char * pixdata, int pixtype, int w, int h)
@ -72,17 +72,17 @@ void gr_init_canvas(grs_canvas *canv, unsigned char * pixdata, int pixtype, int
gr_init_bitmap (&canv->cv_bitmap, pixtype, 0, 0, w, h, wreal, pixdata);
}
void gr_init_sub_canvas(grs_canvas *new, grs_canvas *src, int x, int y, int w, int h)
void gr_init_sub_canvas(grs_canvas *n, grs_canvas *src, int x, int y, int w, int h)
{
new->cv_color = src->cv_color;
new->cv_fade_level = src->cv_fade_level;
new->cv_blend_func = src->cv_blend_func;
new->cv_drawmode = src->cv_drawmode;
new->cv_font = src->cv_font;
new->cv_font_fg_color = src->cv_font_fg_color;
new->cv_font_bg_color = src->cv_font_bg_color;
n->cv_color = src->cv_color;
n->cv_fade_level = src->cv_fade_level;
n->cv_blend_func = src->cv_blend_func;
n->cv_drawmode = src->cv_drawmode;
n->cv_font = src->cv_font;
n->cv_font_fg_color = src->cv_font_fg_color;
n->cv_font_bg_color = src->cv_font_bg_color;
gr_init_sub_bitmap (&new->cv_bitmap, &src->cv_bitmap, x, y, w, h);
gr_init_sub_bitmap (&n->cv_bitmap, &src->cv_bitmap, x, y, w, h);
}
void gr_free_canvas(grs_canvas *canv)

4
2d/font.c
View file

@ -1187,9 +1187,9 @@ void gr_remap_font( grs_font *font, char * fontname, char *font_data )
#endif
}
void gr_set_curfont( grs_font * new )
void gr_set_curfont( grs_font * n)
{
grd_curcanv->cv_font = new;
grd_curcanv->cv_font = n;
}
void gr_set_fontcolor( int fg_color, int bg_color )

8
2d/pcx.c
View file

@ -257,7 +257,7 @@ int pcx_write_bitmap( char * filename, grs_bitmap * bmp, ubyte * palette )
// returns number of bytes written into outBuff, 0 if failed
int pcx_encode_line(ubyte *inBuff, int inLen, PHYSFS_file *fp)
{
ubyte this, last;
ubyte ub, last;
int srcIndex, i;
register int total;
register ubyte runCount; // max single runlength is 63
@ -266,8 +266,8 @@ int pcx_encode_line(ubyte *inBuff, int inLen, PHYSFS_file *fp)
runCount = 1;
for (srcIndex = 1; srcIndex < inLen; srcIndex++) {
this = *(++inBuff);
if (this == last) {
ub = *(++inBuff);
if (ub == last) {
runCount++; // it encodes
if (runCount == 63) {
if (!(i=pcx_encode_byte(last, runCount, fp)))
@ -281,7 +281,7 @@ int pcx_encode_line(ubyte *inBuff, int inLen, PHYSFS_file *fp)
return(0);
total += i;
}
last = this;
last = ub;
runCount = 1;
}
}

16
main/bm.c
View file

@ -434,32 +434,32 @@ void load_robot_replacements(char *level_name)
bitmap_index read_extra_bitmap_iff( char * filename )
{
bitmap_index bitmap_num;
grs_bitmap * new = &GameBitmaps[extra_bitmap_num];
grs_bitmap * n = &GameBitmaps[extra_bitmap_num];
ubyte newpal[256*3];
int iff_error; //reference parm to avoid warning message
bitmap_num.index = 0;
//MALLOC( new, grs_bitmap, 1 );
iff_error = iff_read_bitmap(filename,new,BM_LINEAR,newpal);
new->bm_handle=0;
iff_error = iff_read_bitmap(filename,n,BM_LINEAR,newpal);
n->bm_handle=0;
if (iff_error != IFF_NO_ERROR) {
con_printf(CON_DEBUG, "Error loading exit model bitmap <%s> - IFF error: %s\n", filename, iff_errormsg(iff_error));
return bitmap_num;
}
if ( iff_has_transparency )
gr_remap_bitmap_good( new, newpal, iff_transparent_color, 254 );
gr_remap_bitmap_good( n, newpal, iff_transparent_color, 254 );
else
gr_remap_bitmap_good( new, newpal, -1, 254 );
gr_remap_bitmap_good( n, newpal, -1, 254 );
new->avg_color = 0; //compute_average_pixel(new);
n->avg_color = 0; //compute_average_pixel(new);
bitmap_num.index = extra_bitmap_num;
GameBitmaps[extra_bitmap_num++] = *new;
GameBitmaps[extra_bitmap_num++] = *n;
//d_free( new );
//d_free( n );
return bitmap_num;
}

46
main/bmread.c
View file

@ -143,29 +143,29 @@ void verify_textures(void);
//---------------------------------------------------------------
int compute_average_pixel(grs_bitmap *new)
int compute_average_pixel(grs_bitmap *n)
{
int row, column, color;
char *pptr;
int total_red, total_green, total_blue;
pptr = (char *)new->bm_data;
pptr = (char *)n->bm_data;
total_red = 0;
total_green = 0;
total_blue = 0;
for (row=0; row<new->bm_h; row++)
for (column=0; column<new->bm_w; column++) {
for (row=0; row<n->bm_h; row++)
for (column=0; column<n->bm_w; column++) {
color = *pptr++;
total_red += gr_palette[color*3];
total_green += gr_palette[color*3+1];
total_blue += gr_palette[color*3+2];
}
total_red /= (new->bm_h * new->bm_w);
total_green /= (new->bm_h * new->bm_w);
total_blue /= (new->bm_h * new->bm_w);
total_red /= (n->bm_h * n->bm_w);
total_green /= (n->bm_h * n->bm_w);
total_blue /= (n->bm_h * n->bm_w);
return BM_XRGB(total_red/2, total_green/2, total_blue/2);
}
@ -177,7 +177,7 @@ int compute_average_pixel(grs_bitmap *new)
bitmap_index bm_load_sub(int skip, char * filename )
{
bitmap_index bitmap_num;
grs_bitmap * new;
grs_bitmap * n;
ubyte newpal[256*3];
int iff_error; //reference parm to avoid warning message
char fname[20];
@ -195,22 +195,22 @@ bitmap_index bm_load_sub(int skip, char * filename )
return bitmap_num;
}
MALLOC( new, grs_bitmap, 1 );
iff_error = iff_read_bitmap(filename,new,BM_LINEAR,newpal);
new->bm_handle=0;
MALLOC( n, grs_bitmap, 1 );
iff_error = iff_read_bitmap(filename,n,BM_LINEAR,newpal);
n->bm_handle=0;
if (iff_error != IFF_NO_ERROR) {
Error("File <%s> - IFF error: %s, line %d",filename,iff_errormsg(iff_error),linenum);
}
if ( iff_has_transparency )
gr_remap_bitmap_good( new, newpal, iff_transparent_color, SuperX );
gr_remap_bitmap_good( n, newpal, iff_transparent_color, SuperX );
else
gr_remap_bitmap_good( new, newpal, -1, SuperX );
gr_remap_bitmap_good( n, newpal, -1, SuperX );
new->avg_color = compute_average_pixel(new);
n->avg_color = compute_average_pixel(n);
bitmap_num = piggy_register_bitmap( new, fname, 0 );
d_free( new );
bitmap_num = piggy_register_bitmap( n, fname, 0 );
d_free( n );
return bitmap_num;
}
@ -278,7 +278,7 @@ void ab_load(int skip, char * filename, bitmap_index bmp[], int *nframes )
int ds_load(int skip, char * filename ) {
int i;
PHYSFS_file * cfp;
digi_sound new;
digi_sound n;
char fname[20];
char rawname[100];
@ -299,16 +299,16 @@ int ds_load(int skip, char * filename ) {
cfp = PHYSFSX_openReadBuffered(rawname);
if (cfp!=NULL) {
new.length = PHYSFS_fileLength( cfp );
MALLOC( new.data, ubyte, new.length );
PHYSFS_read( cfp, new.data, 1, new.length );
n.length = PHYSFS_fileLength( cfp );
MALLOC( n.data, ubyte, n.length );
PHYSFS_read( cfp, n.data, 1, n.length );
PHYSFS_close(cfp);
new.bits = 8;
new.freq = 11025;
n.bits = 8;
n.freq = 11025;
} else {
return 255;
}
i = piggy_register_sound( &new, fname, 0 );
i = piggy_register_sound( &n, fname, 0 );
return i;
}

16
main/multi.c
View file

@ -713,15 +713,15 @@ void multi_compute_kill(int killer, int killed)
if( Game_mode & GM_BOUNTY && killed_pnum == Bounty_target && multi_i_am_master() )
{
/* Select a random number */
int new = d_rand() % MAX_PLAYERS;
int n = d_rand() % MAX_PLAYERS;
/* Make sure they're valid: Don't check against kill flags,
* just in case everyone's dead! */
while( !Players[new].connected )
new = d_rand() % MAX_PLAYERS;
while( !Players[n].connected )
n = d_rand() % MAX_PLAYERS;
/* Select new target - it will be sent later when we're done with this function */
multi_new_bounty_target( new );
multi_new_bounty_target( n );
}
}
@ -1970,15 +1970,15 @@ void multi_disconnect_player(int pnum)
if( Game_mode & GM_BOUNTY && pnum == Bounty_target && multi_i_am_master() )
{
/* Select a random number */
int new = d_rand() % MAX_PLAYERS;
int n = d_rand() % MAX_PLAYERS;
/* Make sure they're valid: Don't check against kill flags,
* just in case everyone's dead! */
while( !Players[new].connected )
new = d_rand() % MAX_PLAYERS;
while( !Players[n].connected )
n = d_rand() % MAX_PLAYERS;
/* Select new target */
multi_new_bounty_target( new );
multi_new_bounty_target( n );
/* Send this new data */
multi_send_bounty();

42
main/piggy.c
View file

@ -667,18 +667,18 @@ void piggy_new_pigfile(char *pigname)
}
else { //this is a BBM
grs_bitmap * new;
grs_bitmap * n;
ubyte newpal[256*3];
int iff_error;
char bbmname[FILENAME_LEN];
int SuperX;
MALLOC( new, grs_bitmap, 1 );
MALLOC( n, grs_bitmap, 1 );
sprintf( bbmname, "%s.bbm", AllBitmaps[i].name );
iff_error = iff_read_bitmap(bbmname,new,BM_LINEAR,newpal);
iff_error = iff_read_bitmap(bbmname,n,BM_LINEAR,newpal);
new->bm_handle=0;
n->bm_handle=0;
if (iff_error != IFF_NO_ERROR) {
Error("File %s - IFF error: %s",bbmname,iff_errormsg(iff_error));
}
@ -687,30 +687,30 @@ void piggy_new_pigfile(char *pigname)
//above makes assumption that supertransparent color is 254
if ( iff_has_transparency )
gr_remap_bitmap_good( new, newpal, iff_transparent_color, SuperX );
gr_remap_bitmap_good( n, newpal, iff_transparent_color, SuperX );
else
gr_remap_bitmap_good( new, newpal, -1, SuperX );
gr_remap_bitmap_good( n, newpal, -1, SuperX );
new->avg_color = compute_average_pixel(new);
n->avg_color = compute_average_pixel(n);
if ( GameArg.EdiMacData )
swap_0_255( new );
swap_0_255( n );
if ( !GameArg.DbgBigPig ) gr_bitmap_rle_compress( new );
if ( !GameArg.DbgBigPig ) gr_bitmap_rle_compress( n );
if (new->bm_flags & BM_FLAG_RLE)
size = *((int *) new->bm_data);
if (n->bm_flags & BM_FLAG_RLE)
size = *((int *) n->bm_data);
else
size = new->bm_w * new->bm_h;
size = n->bm_w * n->bm_h;
memcpy( &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next],new->bm_data,size);
d_free(new->bm_data);
new->bm_data = &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next];
memcpy( &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next],n->bm_data,size);
d_free(n->bm_data);
n->bm_data = &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next];
Piggy_bitmap_cache_next += size;
GameBitmaps[i] = *new;
GameBitmaps[i] = *n;
d_free( new );
d_free( n );
}
}
@ -1973,7 +1973,7 @@ extern int extra_bitmap_num;
bitmap_index read_extra_bitmap_d1_pig(char *name)
{
bitmap_index bitmap_num;
grs_bitmap * new = &GameBitmaps[extra_bitmap_num];
grs_bitmap * n = &GameBitmaps[extra_bitmap_num];
bitmap_num.index = 0;
@ -2042,16 +2042,16 @@ bitmap_index read_extra_bitmap_d1_pig(char *name)
return bitmap_num;
}
bitmap_read_d1( new, d1_Piggy_fp, bitmap_data_start, &bmh, 0, d1_palette, colormap );
bitmap_read_d1( n, d1_Piggy_fp, bitmap_data_start, &bmh, 0, d1_palette, colormap );
PHYSFS_close(d1_Piggy_fp);
}
new->avg_color = 0; //compute_average_pixel(new);
n->avg_color = 0; //compute_average_pixel(n);
bitmap_num.index = extra_bitmap_num;
GameBitmaps[extra_bitmap_num++] = *new;
GameBitmaps[extra_bitmap_num++] = *n;
return bitmap_num;
}

6
misc/physfsx.c
View file

@ -317,11 +317,11 @@ int PHYSFSX_isNewPath(const char *path)
int PHYSFSX_rename(const char *oldpath, const char *newpath)
{
char old[PATH_MAX], new[PATH_MAX];
char old[PATH_MAX], n[PATH_MAX];
PHYSFSX_getRealPath(oldpath, old);
PHYSFSX_getRealPath(newpath, new);
return (rename(old, new) == 0);
PHYSFSX_getRealPath(newpath, n);
return (rename(old, n) == 0);
}
// Find files at path that have an extension listed in exts