Removed explicit usage of the 'register' keyword.

Signed-off-by: Michele Calgaro <[email protected]>

7 files changed, 64 insertions, 64 deletions

diff --git a/src/3rdparty/libpng/pnggccrd.c b/src/3rdparty/libpng/pnggccrd.c
index 8d81c3147..b218d34fe 100644
--- a/src/3rdparty/libpng/pnggccrd.c
+++ b/src/3rdparty/libpng/pnggccrd.c
@@ -694,16 +694,16 @@ png_combine_row(png_structp png_ptr, png_bytep row, int mask)
             else /* mmx _not supported - Use modified C routine */
 #endif /* PNG_ASSEMBLER_CODE_SUPPORTED */
             {
-               register png_uint_32 i;
+               png_uint_32 i;
                png_uint_32 initial_val = png_pass_start[png_ptr->pass];
                  /* png.c:  png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */
-               register int stride = png_pass_inc[png_ptr->pass];
+               int stride = png_pass_inc[png_ptr->pass];
                  /* png.c:  png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */
-               register int rep_bytes = png_pass_width[png_ptr->pass];
+               int rep_bytes = png_pass_width[png_ptr->pass];
                  /* png.c:  png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */
                png_uint_32 len = png_ptr->width &~7;  /* reduce to mult. of 8 */
                int diff = (int) (png_ptr->width & 7); /* amount lost */
-               register png_uint_32 final_val = len;  /* GRR bugfix */
+               png_uint_32 final_val = len;  /* GRR bugfix */
 
                srcptr = png_ptr->row_buf + 1 + initial_val;
                dstptr = row + initial_val;
@@ -848,16 +848,16 @@ png_combine_row(png_structp png_ptr, png_bytep row, int mask)
             else /* mmx _not supported - Use modified C routine */
 #endif /* PNG_ASSEMBLER_CODE_SUPPORTED */
             {
-               register png_uint_32 i;
+               png_uint_32 i;
                png_uint_32 initial_val = BPP2 * png_pass_start[png_ptr->pass];
                  /* png.c:  png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */
-               register int stride = BPP2 * png_pass_inc[png_ptr->pass];
+               int stride = BPP2 * png_pass_inc[png_ptr->pass];
                  /* png.c:  png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */
-               register int rep_bytes = BPP2 * png_pass_width[png_ptr->pass];
+               int rep_bytes = BPP2 * png_pass_width[png_ptr->pass];
                  /* png.c:  png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */
                png_uint_32 len = png_ptr->width &~7;  /* reduce to mult. of 8 */
                int diff = (int) (png_ptr->width & 7); /* amount lost */
-               register png_uint_32 final_val = BPP2 * len;   /* GRR bugfix */
+               png_uint_32 final_val = BPP2 * len;   /* GRR bugfix */
 
                srcptr = png_ptr->row_buf + 1 + initial_val;
                dstptr = row + initial_val;
@@ -1016,16 +1016,16 @@ png_combine_row(png_structp png_ptr, png_bytep row, int mask)
             else /* mmx _not supported - Use modified C routine */
 #endif /* PNG_ASSEMBLER_CODE_SUPPORTED */
             {
-               register png_uint_32 i;
+               png_uint_32 i;
                png_uint_32 initial_val = BPP3 * png_pass_start[png_ptr->pass];
                  /* png.c:  png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */
-               register int stride = BPP3 * png_pass_inc[png_ptr->pass];
+               int stride = BPP3 * png_pass_inc[png_ptr->pass];
                  /* png.c:  png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */
-               register int rep_bytes = BPP3 * png_pass_width[png_ptr->pass];
+               int rep_bytes = BPP3 * png_pass_width[png_ptr->pass];
                  /* png.c:  png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */
                png_uint_32 len = png_ptr->width &~7;  /* reduce to mult. of 8 */
                int diff = (int) (png_ptr->width & 7); /* amount lost */
-               register png_uint_32 final_val = BPP3 * len;   /* GRR bugfix */
+               png_uint_32 final_val = BPP3 * len;   /* GRR bugfix */
 
                srcptr = png_ptr->row_buf + 1 + initial_val;
                dstptr = row + initial_val;
@@ -1191,16 +1191,16 @@ png_combine_row(png_structp png_ptr, png_bytep row, int mask)
             else /* mmx _not supported - Use modified C routine */
 #endif /* PNG_ASSEMBLER_CODE_SUPPORTED */
             {
-               register png_uint_32 i;
+               png_uint_32 i;
                png_uint_32 initial_val = BPP4 * png_pass_start[png_ptr->pass];
                  /* png.c:  png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */
-               register int stride = BPP4 * png_pass_inc[png_ptr->pass];
+               int stride = BPP4 * png_pass_inc[png_ptr->pass];
                  /* png.c:  png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */
-               register int rep_bytes = BPP4 * png_pass_width[png_ptr->pass];
+               int rep_bytes = BPP4 * png_pass_width[png_ptr->pass];
                  /* png.c:  png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */
                png_uint_32 len = png_ptr->width &~7;  /* reduce to mult. of 8 */
                int diff = (int) (png_ptr->width & 7); /* amount lost */
-               register png_uint_32 final_val = BPP4 * len;   /* GRR bugfix */
+               png_uint_32 final_val = BPP4 * len;   /* GRR bugfix */
 
                srcptr = png_ptr->row_buf + 1 + initial_val;
                dstptr = row + initial_val;
@@ -1383,16 +1383,16 @@ png_combine_row(png_structp png_ptr, png_bytep row, int mask)
             else /* mmx _not supported - Use modified C routine */
 #endif /* PNG_ASSEMBLER_CODE_SUPPORTED */
             {
-               register png_uint_32 i;
+               png_uint_32 i;
                png_uint_32 initial_val = BPP6 * png_pass_start[png_ptr->pass];
                  /* png.c:  png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */
-               register int stride = BPP6 * png_pass_inc[png_ptr->pass];
+               int stride = BPP6 * png_pass_inc[png_ptr->pass];
                  /* png.c:  png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */
-               register int rep_bytes = BPP6 * png_pass_width[png_ptr->pass];
+               int rep_bytes = BPP6 * png_pass_width[png_ptr->pass];
                  /* png.c:  png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */
                png_uint_32 len = png_ptr->width &~7;  /* reduce to mult. of 8 */
                int diff = (int) (png_ptr->width & 7); /* amount lost */
-               register png_uint_32 final_val = BPP6 * len;   /* GRR bugfix */
+               png_uint_32 final_val = BPP6 * len;   /* GRR bugfix */
 
                srcptr = png_ptr->row_buf + 1 + initial_val;
                dstptr = row + initial_val;
@@ -1424,16 +1424,16 @@ png_combine_row(png_structp png_ptr, png_bytep row, int mask)
          {
             png_bytep srcptr;
             png_bytep dstptr;
-            register png_uint_32 i;
+            png_uint_32 i;
             png_uint_32 initial_val = BPP8 * png_pass_start[png_ptr->pass];
               /* png.c:  png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */
-            register int stride = BPP8 * png_pass_inc[png_ptr->pass];
+            int stride = BPP8 * png_pass_inc[png_ptr->pass];
               /* png.c:  png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */
-            register int rep_bytes = BPP8 * png_pass_width[png_ptr->pass];
+            int rep_bytes = BPP8 * png_pass_width[png_ptr->pass];
               /* png.c:  png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */
             png_uint_32 len = png_ptr->width &~7;  /* reduce to mult. of 8 */
             int diff = (int) (png_ptr->width & 7); /* amount lost */
-            register png_uint_32 final_val = BPP8 * len;   /* GRR bugfix */
+            png_uint_32 final_val = BPP8 * len;   /* GRR bugfix */
 
             srcptr = png_ptr->row_buf + 1 + initial_val;
             dstptr = row + initial_val;
diff --git a/src/3rdparty/libpng/pngvcrd.c b/src/3rdparty/libpng/pngvcrd.c
index 4f513eb4d..c75ebd09d 100644
--- a/src/3rdparty/libpng/pngvcrd.c
+++ b/src/3rdparty/libpng/pngvcrd.c
@@ -375,10 +375,10 @@ end8:
             }
             else /* mmx not supported - use modified C routine */
             {
-               register unsigned int incr1, initial_val, final_val;
+               unsigned int incr1, initial_val, final_val;
                png_size_t pixel_bytes;
                png_uint_32 i;
-               register int disp = png_pass_inc[png_ptr->pass];
+               int disp = png_pass_inc[png_ptr->pass];
                int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
 
                pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
@@ -487,10 +487,10 @@ end16:
             }
             else /* mmx not supported - use modified C routine */
             {
-               register unsigned int incr1, initial_val, final_val;
+               unsigned int incr1, initial_val, final_val;
                png_size_t pixel_bytes;
                png_uint_32 i;
-               register int disp = png_pass_inc[png_ptr->pass];
+               int disp = png_pass_inc[png_ptr->pass];
                int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
 
                pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
@@ -618,10 +618,10 @@ end24:
             }
             else /* mmx not supported - use modified C routine */
             {
-               register unsigned int incr1, initial_val, final_val;
+               unsigned int incr1, initial_val, final_val;
                png_size_t pixel_bytes;
                png_uint_32 i;
-               register int disp = png_pass_inc[png_ptr->pass];
+               int disp = png_pass_inc[png_ptr->pass];
                int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
 
                pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
@@ -758,10 +758,10 @@ end32:
             }
             else /* mmx _not supported - Use modified C routine */
             {
-               register unsigned int incr1, initial_val, final_val;
+               unsigned int incr1, initial_val, final_val;
                png_size_t pixel_bytes;
                png_uint_32 i;
-               register int disp = png_pass_inc[png_ptr->pass];
+               int disp = png_pass_inc[png_ptr->pass];
                int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
 
                pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
@@ -916,10 +916,10 @@ end48:
             }
             else /* mmx _not supported - Use modified C routine */
             {
-               register unsigned int incr1, initial_val, final_val;
+               unsigned int incr1, initial_val, final_val;
                png_size_t pixel_bytes;
                png_uint_32 i;
-               register int disp = png_pass_inc[png_ptr->pass];
+               int disp = png_pass_inc[png_ptr->pass];
                int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
 
                pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
@@ -947,8 +947,8 @@ end48:
             png_size_t pixel_bytes;
             int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
             unsigned int i;
-            register int disp = png_pass_inc[png_ptr->pass];  // get the offset
-            register unsigned int incr1, initial_val, final_val;
+            int disp = png_pass_inc[png_ptr->pass];  // get the offset
+            unsigned int incr1, initial_val, final_val;
 
             pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
             sptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*
diff --git a/src/3rdparty/sqlite/printf.c b/src/3rdparty/sqlite/printf.c
index 620578d76..dd7c1d172 100644
--- a/src/3rdparty/sqlite/printf.c
+++ b/src/3rdparty/sqlite/printf.c
@@ -360,8 +360,8 @@ static int vxprintf(
         }
         bufpt = &buf[etBUFSIZE-1];
         {
-          register char *cset;      /* Use registers for speed */
-          register int base;
+          char *cset;      /* Use registers for speed */
+          int base;
           cset = infop->charset;
           base = infop->base;
           do{                                           /* Convert to ascii */
@@ -602,7 +602,7 @@ static int vxprintf(
     ** the output.
     */
     if( !flag_leftjustify ){
-      register int nspace;
+      int nspace;
       nspace = width-length;
       if( nspace>0 ){
         count += nspace;
@@ -618,7 +618,7 @@ static int vxprintf(
       count += length;
     }
     if( flag_leftjustify ){
-      register int nspace;
+      int nspace;
       nspace = width-length;
       if( nspace>0 ){
         count += nspace;
diff --git a/src/3rdparty/sqlite/util.c b/src/3rdparty/sqlite/util.c
index 16b3b46a0..6dc07ec6d 100644
--- a/src/3rdparty/sqlite/util.c
+++ b/src/3rdparty/sqlite/util.c
@@ -500,14 +500,14 @@ int sqliteHashNoCase(const char *z, int n){
 ** there is no consistency, we will define our own.
 */
 int sqliteStrICmp(const char *zLeft, const char *zRight){
-  register unsigned char *a, *b;
+  unsigned char *a, *b;
   a = (unsigned char *)zLeft;
   b = (unsigned char *)zRight;
   while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
   return *a - *b;
 }
 int sqliteStrNICmp(const char *zLeft, const char *zRight, int N){
-  register unsigned char *a, *b;
+  unsigned char *a, *b;
   a = (unsigned char *)zLeft;
   b = (unsigned char *)zRight;
   while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
@@ -941,7 +941,7 @@ static int sqlite_utf8_to_int(const unsigned char *z){
 */
 int 
 sqliteGlobCompare(const unsigned char *zPattern, const unsigned char *zString){
-  register int c;
+  int c;
   int invert;
   int seen;
   int c2;
@@ -1030,7 +1030,7 @@ sqliteGlobCompare(const unsigned char *zPattern, const unsigned char *zString){
 */
 int 
 sqliteLikeCompare(const unsigned char *zPattern, const unsigned char *zString){
-  register int c;
+  int c;
   int c2;
 
   while( (c = UpperToLower[*zPattern])!=0 ){
diff --git a/src/3rdparty/zlib/crc32.c b/src/3rdparty/zlib/crc32.c
index b39c7e125..bbf30e386 100644
--- a/src/3rdparty/zlib/crc32.c
+++ b/src/3rdparty/zlib/crc32.c
@@ -260,8 +260,8 @@ local unsigned long crc32_little(crc, buf, len)
     const unsigned char FAR *buf;
     unsigned len;
 {
-    register u4 c;
-    register const u4 FAR *buf4;
+    u4 c;
+    const u4 FAR *buf4;
 
     c = (u4)crc;
     c = ~c;
@@ -300,8 +300,8 @@ local unsigned long crc32_big(crc, buf, len)
     const unsigned char FAR *buf;
     unsigned len;
 {
-    register u4 c;
-    register const u4 FAR *buf4;
+    u4 c;
+    const u4 FAR *buf4;
 
     c = REV((u4)crc);
     c = ~c;
diff --git a/src/3rdparty/zlib/deflate.c b/src/3rdparty/zlib/deflate.c
index 0fc53bc1e..16e30ce7c 100644
--- a/src/3rdparty/zlib/deflate.c
+++ b/src/3rdparty/zlib/deflate.c
@@ -862,9 +862,9 @@ local uInt longest_match(s, cur_match)
     IPos cur_match;                             /* current match */
 {
     unsigned chain_length = s->max_chain_length;/* max hash chain length */
-    register Bytef *scan = s->window + s->strstart; /* current string */
-    register Bytef *match;                       /* matched string */
-    register int len;                           /* length of current match */
+    Bytef *scan = s->window + s->strstart; /* current string */
+    Bytef *match;                       /* matched string */
+    int len;                           /* length of current match */
     int best_len = s->prev_length;              /* best match length so far */
     int nice_match = s->nice_match;             /* stop if match long enough */
     IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
@@ -879,13 +879,13 @@ local uInt longest_match(s, cur_match)
     /* Compare two bytes at a time. Note: this is not always beneficial.
      * Try with and without -DUNALIGNED_OK to check.
      */
-    register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
-    register ush scan_start = *(ushf*)scan;
-    register ush scan_end   = *(ushf*)(scan+best_len-1);
+    Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
+    ush scan_start = *(ushf*)scan;
+    ush scan_end   = *(ushf*)(scan+best_len-1);
 #else
-    register Bytef *strend = s->window + s->strstart + MAX_MATCH;
-    register Byte scan_end1  = scan[best_len-1];
-    register Byte scan_end   = scan[best_len];
+    Bytef *strend = s->window + s->strstart + MAX_MATCH;
+    Byte scan_end1  = scan[best_len-1];
+    Byte scan_end   = scan[best_len];
 #endif
 
     /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
@@ -1004,10 +1004,10 @@ local uInt longest_match_fast(s, cur_match)
     deflate_state *s;
     IPos cur_match;                             /* current match */
 {
-    register Bytef *scan = s->window + s->strstart; /* current string */
-    register Bytef *match;                       /* matched string */
-    register int len;                           /* length of current match */
-    register Bytef *strend = s->window + s->strstart + MAX_MATCH;
+    Bytef *scan = s->window + s->strstart; /* current string */
+    Bytef *match;                       /* matched string */
+    int len;                           /* length of current match */
+    Bytef *strend = s->window + s->strstart + MAX_MATCH;
 
     /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
      * It is easy to get rid of this optimization if necessary.
@@ -1094,8 +1094,8 @@ local void check_match(s, start, match, length)
 local void fill_window(s)
     deflate_state *s;
 {
-    register unsigned n, m;
-    register Posf *p;
+    unsigned n, m;
+    Posf *p;
     unsigned more;    /* Amount of free space at the end of the window. */
     uInt wsize = s->w_size;
 
diff --git a/src/3rdparty/zlib/trees.c b/src/3rdparty/zlib/trees.c
index 52c820fa2..c46b8dc5d 100644
--- a/src/3rdparty/zlib/trees.c
+++ b/src/3rdparty/zlib/trees.c
@@ -1143,7 +1143,7 @@ local unsigned bi_reverse(code, len)
     unsigned code; /* the value to invert */
     int len;       /* its bit length */
 {
-    register unsigned res = 0;
+    unsigned res = 0;
     do {
         res |= code & 1;
         code >>= 1, res <<= 1;