mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-04-18 05:43:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

(rzlib) Try to prevent internal_state from conflicting with

Browse Source 
internal_state from deflate later - requires us to turn 'state'
variable into void pointer
This commit is contained in:
twinaphex 2014-01-10 18:08:54 +01:00
parent 1884fe436c
commit 3746dcb4b0
2 changed files with 66 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

120
deps/rzlib/rzlib.c vendored
View File

@ -38,7 +38,7 @@ typedef enum {
inflate_mode; inflate_mode;
/* inflate private state */ /* inflate private state */
struct internal_state struct internal_state_inflate
{ {
/* mode */ /* mode */
inflate_mode mode; /* current inflate mode */ inflate_mode mode; /* current inflate mode */
@ -1367,21 +1367,27 @@ unsigned long crc32(unsigned long crc, const Bytef *buf, unsigned int len)
int inflateReset(z_streamp z) int inflateReset(z_streamp z)
{ {
struct internal_state_inflate *state = (struct internal_state_inflate*)z->state;
if (z == 0 || z->state == 0) if (z == 0 || z->state == 0)
return Z_STREAM_ERROR; return Z_STREAM_ERROR;
z->total_in = z->total_out = 0; z->total_in = z->total_out = 0;
z->msg = 0; z->msg = 0;
z->state->mode = z->state->nowrap ? BLOCKS_INFLATE : METHOD_INFLATE; state->mode = state->nowrap ? BLOCKS_INFLATE : METHOD_INFLATE;
inflate_blocks_reset(z->state->blocks, z, 0); inflate_blocks_reset(state->blocks, z, 0);
return Z_OK; return Z_OK;
} }
int inflateEnd(z_streamp z) int inflateEnd(z_streamp z)
{ {
struct internal_state_inflate *state = (struct internal_state_inflate*)z->state;
if (z == 0 || z->state == 0 || z->zfree == 0) if (z == 0 || z->state == 0 || z->zfree == 0)
return Z_STREAM_ERROR; return Z_STREAM_ERROR;
if (z->state->blocks != 0)
inflate_blocks_free(z->state->blocks, z); if (state->blocks != 0)
inflate_blocks_free(state->blocks, z);
ZFREE(z, z->state); ZFREE(z, z->state);
z->state = 0; z->state = 0;
return Z_OK; return Z_OK;
@ -1430,17 +1436,20 @@ int inflateInit2_(z_streamp z, int w, const char * version, int stream_size)
z->opaque = (voidpf)0; z->opaque = (voidpf)0;
} }
if (z->zfree == 0) z->zfree = zcfree; if (z->zfree == 0) z->zfree = zcfree;
if ((z->state = (struct internal_state *) if ((z->state = (struct internal_state_inflate *)
ZALLOC(z,1,sizeof(struct internal_state))) == 0) ZALLOC(z,1,sizeof(struct internal_state_inflate))) == 0)
return Z_MEM_ERROR; return Z_MEM_ERROR;
z->state->blocks = 0;
struct internal_state_inflate *state = (struct internal_state_inflate*)z->state;
state->blocks = 0;
/* handle undocumented nowrap option (no zlib header or check) */ /* handle undocumented nowrap option (no zlib header or check) */
z->state->nowrap = 0; state->nowrap = 0;
if (w < 0) if (w < 0)
{ {
w = - w; w = - w;
z->state->nowrap = 1; state->nowrap = 1;
} }
/* set window size */ /* set window size */
@ -1449,11 +1458,11 @@ int inflateInit2_(z_streamp z, int w, const char * version, int stream_size)
inflateEnd(z); inflateEnd(z);
return Z_STREAM_ERROR; return Z_STREAM_ERROR;
} }
z->state->wbits = (unsigned int)w; state->wbits = (unsigned int)w;
/* create inflate_blocks state */ /* create inflate_blocks state */
if ((z->state->blocks = if ((state->blocks =
inflate_blocks_new(z, z->state->nowrap ? 0 : adler32, (unsigned int)1 << w)) inflate_blocks_new(z, state->nowrap ? 0 : adler32, (unsigned int)1 << w))
== 0) == 0)
{ {
inflateEnd(z); inflateEnd(z);
@ -1478,75 +1487,76 @@ int inflate(z_streamp z, int f)
{ {
int r; int r;
unsigned int b; unsigned int b;
struct internal_state_inflate *state = (struct internal_state_inflate*)z->state;
if (z == 0 || z->state == 0 || z->next_in == 0) if (z == 0 || z->state == 0 || z->next_in == 0)
return Z_STREAM_ERROR; return Z_STREAM_ERROR;
f = f == Z_FINISH ? Z_BUF_ERROR : Z_OK; f = f == Z_FINISH ? Z_BUF_ERROR : Z_OK;
r = Z_BUF_ERROR; r = Z_BUF_ERROR;
while (1) switch (z->state->mode) while (1) switch (state->mode)
{ {
case METHOD_INFLATE: case METHOD_INFLATE:
NEEDBYTE_INFLATE NEEDBYTE_INFLATE
if (((z->state->sub.method = NEXTBYTE_INFLATE) & 0xf) != Z_DEFLATED) if (((state->sub.method = NEXTBYTE_INFLATE) & 0xf) != Z_DEFLATED)
{ {
z->state->mode = BAD_INFLATE; state->mode = BAD_INFLATE;
z->msg = (char*)"unknown compression method"; z->msg = (char*)"unknown compression method";
z->state->sub.marker = 5; /* can't try inflateSync */ state->sub.marker = 5; /* can't try inflateSync */
break; break;
} }
if ((z->state->sub.method >> 4) + 8 > z->state->wbits) if ((state->sub.method >> 4) + 8 > state->wbits)
{ {
z->state->mode = BAD_INFLATE; state->mode = BAD_INFLATE;
z->msg = (char*)"invalid window size"; z->msg = (char*)"invalid window size";
z->state->sub.marker = 5; /* can't try inflateSync */ state->sub.marker = 5; /* can't try inflateSync */
break; break;
} }
z->state->mode = FLAG_INFLATE; state->mode = FLAG_INFLATE;
case FLAG_INFLATE: case FLAG_INFLATE:
NEEDBYTE_INFLATE NEEDBYTE_INFLATE
b = NEXTBYTE_INFLATE; b = NEXTBYTE_INFLATE;
if (((z->state->sub.method << 8) + b) % 31) if (((state->sub.method << 8) + b) % 31)
{ {
z->state->mode = BAD_INFLATE; state->mode = BAD_INFLATE;
z->msg = (char*)"incorrect header check"; z->msg = (char*)"incorrect header check";
z->state->sub.marker = 5; /* can't try inflateSync */ state->sub.marker = 5; /* can't try inflateSync */
break; break;
} }
if (!(b & PRESET_DICT)) if (!(b & PRESET_DICT))
{ {
z->state->mode = BLOCKS_INFLATE; state->mode = BLOCKS_INFLATE;
break; break;
} }
z->state->mode = DICT4_INFLATE; state->mode = DICT4_INFLATE;
case DICT4_INFLATE: case DICT4_INFLATE:
NEEDBYTE_INFLATE NEEDBYTE_INFLATE
z->state->sub.check.need = (unsigned long)NEXTBYTE_INFLATE << 24; state->sub.check.need = (unsigned long)NEXTBYTE_INFLATE << 24;
z->state->mode = DICT3_INFLATE; state->mode = DICT3_INFLATE;
case DICT3_INFLATE: case DICT3_INFLATE:
NEEDBYTE_INFLATE NEEDBYTE_INFLATE
z->state->sub.check.need += (unsigned long)NEXTBYTE_INFLATE << 16; state->sub.check.need += (unsigned long)NEXTBYTE_INFLATE << 16;
z->state->mode = DICT2_INFLATE; state->mode = DICT2_INFLATE;
case DICT2_INFLATE: case DICT2_INFLATE:
NEEDBYTE_INFLATE NEEDBYTE_INFLATE
z->state->sub.check.need += (unsigned long)NEXTBYTE_INFLATE << 8; state->sub.check.need += (unsigned long)NEXTBYTE_INFLATE << 8;
z->state->mode = DICT1_INFLATE; state->mode = DICT1_INFLATE;
case DICT1_INFLATE: case DICT1_INFLATE:
NEEDBYTE_INFLATE NEEDBYTE_INFLATE
z->state->sub.check.need += (unsigned long)NEXTBYTE_INFLATE; state->sub.check.need += (unsigned long)NEXTBYTE_INFLATE;
z->adler = z->state->sub.check.need; z->adler = state->sub.check.need;
z->state->mode = DICT0_INFLATE; state->mode = DICT0_INFLATE;
return Z_NEED_DICT; return Z_NEED_DICT;
case DICT0_INFLATE: case DICT0_INFLATE:
z->state->mode = BAD_INFLATE; state->mode = BAD_INFLATE;
z->msg = (char*)"need dictionary"; z->msg = (char*)"need dictionary";
z->state->sub.marker = 0; /* can try inflateSync */ state->sub.marker = 0; /* can try inflateSync */
return Z_STREAM_ERROR; return Z_STREAM_ERROR;
case BLOCKS_INFLATE: case BLOCKS_INFLATE:
r = inflate_blocks(z->state->blocks, z, r); r = inflate_blocks(state->blocks, z, r);
if (r == Z_DATA_ERROR) if (r == Z_DATA_ERROR)
{ {
z->state->mode = BAD_INFLATE; state->mode = BAD_INFLATE;
z->state->sub.marker = 0; /* can try inflateSync */ state->sub.marker = 0; /* can try inflateSync */
break; break;
} }
if (r == Z_OK) if (r == Z_OK)
@ -1554,37 +1564,37 @@ int inflate(z_streamp z, int f)
if (r != Z_STREAM_END) if (r != Z_STREAM_END)
return r; return r;
r = f; r = f;
inflate_blocks_reset(z->state->blocks, z, &z->state->sub.check.was); inflate_blocks_reset(state->blocks, z, &state->sub.check.was);
if (z->state->nowrap) if (state->nowrap)
{ {
z->state->mode = DONE_INFLATE; state->mode = DONE_INFLATE;
break; break;
} }
z->state->mode = CHECK4_INFLATE; state->mode = CHECK4_INFLATE;
case CHECK4_INFLATE: case CHECK4_INFLATE:
NEEDBYTE_INFLATE NEEDBYTE_INFLATE
z->state->sub.check.need = (unsigned long)NEXTBYTE_INFLATE << 24; state->sub.check.need = (unsigned long)NEXTBYTE_INFLATE << 24;
z->state->mode = CHECK3_INFLATE; state->mode = CHECK3_INFLATE;
case CHECK3_INFLATE: case CHECK3_INFLATE:
NEEDBYTE_INFLATE NEEDBYTE_INFLATE
z->state->sub.check.need += (unsigned long)NEXTBYTE_INFLATE << 16; state->sub.check.need += (unsigned long)NEXTBYTE_INFLATE << 16;
z->state->mode = CHECK2_INFLATE; state->mode = CHECK2_INFLATE;
case CHECK2_INFLATE: case CHECK2_INFLATE:
NEEDBYTE_INFLATE NEEDBYTE_INFLATE
z->state->sub.check.need += (unsigned long)NEXTBYTE_INFLATE << 8; state->sub.check.need += (unsigned long)NEXTBYTE_INFLATE << 8;
z->state->mode = CHECK1_INFLATE; state->mode = CHECK1_INFLATE;
case CHECK1_INFLATE: case CHECK1_INFLATE:
NEEDBYTE_INFLATE NEEDBYTE_INFLATE
z->state->sub.check.need += (unsigned long)NEXTBYTE_INFLATE; state->sub.check.need += (unsigned long)NEXTBYTE_INFLATE;
if (z->state->sub.check.was != z->state->sub.check.need) if (state->sub.check.was != state->sub.check.need)
{ {
z->state->mode = BAD_INFLATE; state->mode = BAD_INFLATE;
z->msg = (char*)"incorrect data check"; z->msg = (char*)"incorrect data check";
z->state->sub.marker = 5; /* can't try inflateSync */ state->sub.marker = 5; /* can't try inflateSync */
break; break;
} }
z->state->mode = DONE_INFLATE; state->mode = DONE_INFLATE;
case DONE_INFLATE: case DONE_INFLATE:
return Z_STREAM_END; return Z_STREAM_END;
case BAD_INFLATE: case BAD_INFLATE:

2
deps/rzlib/zlib.h vendored
View File

@ -76,7 +76,7 @@ typedef struct z_stream_s {
unsigned long total_out; /* total nb of bytes output so far */ unsigned long total_out; /* total nb of bytes output so far */
char *msg; /* last error message, NULL if no error */ char *msg; /* last error message, NULL if no error */
struct internal_state *state; /* not visible by applications */ void *state; /* not visible by applications */
alloc_func zalloc; /* used to allocate the internal state */ alloc_func zalloc; /* used to allocate the internal state */
free_func zfree; /* used to free the internal state */ free_func zfree; /* used to free the internal state */