zstdlib 0.9.0-x64-mingw-ucrt → 0.10.0-x64-mingw-ucrt

Sign up to get free protection for your applications and to get access to all the features.
Files changed (33) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGES.md +5 -0
  3. data/ext/zstdlib_c/extconf.rb +1 -1
  4. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/adler32.c +0 -0
  5. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/compress.c +0 -0
  6. data/ext/zstdlib_c/zlib-1.2.12/crc32.c +1116 -0
  7. data/ext/zstdlib_c/zlib-1.2.12/crc32.h +9446 -0
  8. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/deflate.c +78 -30
  9. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/deflate.h +12 -15
  10. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/gzclose.c +0 -0
  11. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/gzguts.h +3 -2
  12. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/gzlib.c +5 -3
  13. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/gzread.c +5 -7
  14. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/gzwrite.c +25 -13
  15. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/infback.c +2 -1
  16. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/inffast.c +14 -14
  17. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/inffast.h +0 -0
  18. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/inffixed.h +0 -0
  19. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/inflate.c +39 -8
  20. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/inflate.h +3 -2
  21. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/inftrees.c +3 -3
  22. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/inftrees.h +0 -0
  23. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/trees.c +27 -48
  24. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/trees.h +0 -0
  25. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/uncompr.c +0 -0
  26. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/zconf.h +0 -0
  27. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/zlib.h +123 -100
  28. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/zutil.c +2 -2
  29. data/ext/zstdlib_c/{zlib-1.2.11 → zlib-1.2.12}/zutil.h +12 -9
  30. data/lib/3.1/zstdlib_c.so +0 -0
  31. metadata +28 -28
  32. data/ext/zstdlib_c/zlib-1.2.11/crc32.c +0 -442
  33. data/ext/zstdlib_c/zlib-1.2.11/crc32.h +0 -441
@@ -1,5 +1,5 @@
1
1
  /* inflate.c -- zlib decompression
2
- * Copyright (C) 1995-2016 Mark Adler
2
+ * Copyright (C) 1995-2022 Mark Adler
3
3
  * For conditions of distribution and use, see copyright notice in zlib.h
4
4
  */
5
5
 
@@ -130,6 +130,7 @@ z_streamp strm;
130
130
  state->mode = HEAD;
131
131
  state->last = 0;
132
132
  state->havedict = 0;
133
+ state->flags = -1;
133
134
  state->dmax = 32768U;
134
135
  state->head = Z_NULL;
135
136
  state->hold = 0;
@@ -447,10 +448,10 @@ unsigned copy;
447
448
 
448
449
  /* check function to use adler32() for zlib or crc32() for gzip */
449
450
  #ifdef GUNZIP
450
- # define UPDATE(check, buf, len) \
451
+ # define UPDATE_CHECK(check, buf, len) \
451
452
  (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
452
453
  #else
453
- # define UPDATE(check, buf, len) adler32(check, buf, len)
454
+ # define UPDATE_CHECK(check, buf, len) adler32(check, buf, len)
454
455
  #endif
455
456
 
456
457
  /* check macros for header crc */
@@ -670,7 +671,6 @@ int flush;
670
671
  state->mode = FLAGS;
671
672
  break;
672
673
  }
673
- state->flags = 0; /* expect zlib header */
674
674
  if (state->head != Z_NULL)
675
675
  state->head->done = -1;
676
676
  if (!(state->wrap & 1) || /* check if zlib header allowed */
@@ -697,6 +697,7 @@ int flush;
697
697
  break;
698
698
  }
699
699
  state->dmax = 1U << len;
700
+ state->flags = 0; /* indicate zlib header */
700
701
  Tracev((stderr, "inflate: zlib header ok\n"));
701
702
  strm->adler = state->check = adler32(0L, Z_NULL, 0);
702
703
  state->mode = hold & 0x200 ? DICTID : TYPE;
@@ -722,6 +723,7 @@ int flush;
722
723
  CRC2(state->check, hold);
723
724
  INITBITS();
724
725
  state->mode = TIME;
726
+ /* fallthrough */
725
727
  case TIME:
726
728
  NEEDBITS(32);
727
729
  if (state->head != Z_NULL)
@@ -730,6 +732,7 @@ int flush;
730
732
  CRC4(state->check, hold);
731
733
  INITBITS();
732
734
  state->mode = OS;
735
+ /* fallthrough */
733
736
  case OS:
734
737
  NEEDBITS(16);
735
738
  if (state->head != Z_NULL) {
@@ -740,6 +743,7 @@ int flush;
740
743
  CRC2(state->check, hold);
741
744
  INITBITS();
742
745
  state->mode = EXLEN;
746
+ /* fallthrough */
743
747
  case EXLEN:
744
748
  if (state->flags & 0x0400) {
745
749
  NEEDBITS(16);
@@ -753,6 +757,7 @@ int flush;
753
757
  else if (state->head != Z_NULL)
754
758
  state->head->extra = Z_NULL;
755
759
  state->mode = EXTRA;
760
+ /* fallthrough */
756
761
  case EXTRA:
757
762
  if (state->flags & 0x0400) {
758
763
  copy = state->length;
@@ -775,6 +780,7 @@ int flush;
775
780
  }
776
781
  state->length = 0;
777
782
  state->mode = NAME;
783
+ /* fallthrough */
778
784
  case NAME:
779
785
  if (state->flags & 0x0800) {
780
786
  if (have == 0) goto inf_leave;
@@ -796,6 +802,7 @@ int flush;
796
802
  state->head->name = Z_NULL;
797
803
  state->length = 0;
798
804
  state->mode = COMMENT;
805
+ /* fallthrough */
799
806
  case COMMENT:
800
807
  if (state->flags & 0x1000) {
801
808
  if (have == 0) goto inf_leave;
@@ -816,6 +823,7 @@ int flush;
816
823
  else if (state->head != Z_NULL)
817
824
  state->head->comment = Z_NULL;
818
825
  state->mode = HCRC;
826
+ /* fallthrough */
819
827
  case HCRC:
820
828
  if (state->flags & 0x0200) {
821
829
  NEEDBITS(16);
@@ -839,6 +847,7 @@ int flush;
839
847
  strm->adler = state->check = ZSWAP32(hold);
840
848
  INITBITS();
841
849
  state->mode = DICT;
850
+ /* fallthrough */
842
851
  case DICT:
843
852
  if (state->havedict == 0) {
844
853
  RESTORE();
@@ -846,8 +855,10 @@ int flush;
846
855
  }
847
856
  strm->adler = state->check = adler32(0L, Z_NULL, 0);
848
857
  state->mode = TYPE;
858
+ /* fallthrough */
849
859
  case TYPE:
850
860
  if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave;
861
+ /* fallthrough */
851
862
  case TYPEDO:
852
863
  if (state->last) {
853
864
  BYTEBITS();
@@ -898,8 +909,10 @@ int flush;
898
909
  INITBITS();
899
910
  state->mode = COPY_;
900
911
  if (flush == Z_TREES) goto inf_leave;
912
+ /* fallthrough */
901
913
  case COPY_:
902
914
  state->mode = COPY;
915
+ /* fallthrough */
903
916
  case COPY:
904
917
  copy = state->length;
905
918
  if (copy) {
@@ -935,6 +948,7 @@ int flush;
935
948
  Tracev((stderr, "inflate: table sizes ok\n"));
936
949
  state->have = 0;
937
950
  state->mode = LENLENS;
951
+ /* fallthrough */
938
952
  case LENLENS:
939
953
  while (state->have < state->ncode) {
940
954
  NEEDBITS(3);
@@ -956,6 +970,7 @@ int flush;
956
970
  Tracev((stderr, "inflate: code lengths ok\n"));
957
971
  state->have = 0;
958
972
  state->mode = CODELENS;
973
+ /* fallthrough */
959
974
  case CODELENS:
960
975
  while (state->have < state->nlen + state->ndist) {
961
976
  for (;;) {
@@ -1039,8 +1054,10 @@ int flush;
1039
1054
  Tracev((stderr, "inflate: codes ok\n"));
1040
1055
  state->mode = LEN_;
1041
1056
  if (flush == Z_TREES) goto inf_leave;
1057
+ /* fallthrough */
1042
1058
  case LEN_:
1043
1059
  state->mode = LEN;
1060
+ /* fallthrough */
1044
1061
  case LEN:
1045
1062
  if (have >= 6 && left >= 258) {
1046
1063
  RESTORE();
@@ -1090,6 +1107,7 @@ int flush;
1090
1107
  }
1091
1108
  state->extra = (unsigned)(here.op) & 15;
1092
1109
  state->mode = LENEXT;
1110
+ /* fallthrough */
1093
1111
  case LENEXT:
1094
1112
  if (state->extra) {
1095
1113
  NEEDBITS(state->extra);
@@ -1100,6 +1118,7 @@ int flush;
1100
1118
  Tracevv((stderr, "inflate: length %u\n", state->length));
1101
1119
  state->was = state->length;
1102
1120
  state->mode = DIST;
1121
+ /* fallthrough */
1103
1122
  case DIST:
1104
1123
  for (;;) {
1105
1124
  here = state->distcode[BITS(state->distbits)];
@@ -1127,6 +1146,7 @@ int flush;
1127
1146
  state->offset = (unsigned)here.val;
1128
1147
  state->extra = (unsigned)(here.op) & 15;
1129
1148
  state->mode = DISTEXT;
1149
+ /* fallthrough */
1130
1150
  case DISTEXT:
1131
1151
  if (state->extra) {
1132
1152
  NEEDBITS(state->extra);
@@ -1143,6 +1163,7 @@ int flush;
1143
1163
  #endif
1144
1164
  Tracevv((stderr, "inflate: distance %u\n", state->offset));
1145
1165
  state->mode = MATCH;
1166
+ /* fallthrough */
1146
1167
  case MATCH:
1147
1168
  if (left == 0) goto inf_leave;
1148
1169
  copy = out - left;
@@ -1202,7 +1223,7 @@ int flush;
1202
1223
  state->total += out;
1203
1224
  if ((state->wrap & 4) && out)
1204
1225
  strm->adler = state->check =
1205
- UPDATE(state->check, put - out, out);
1226
+ UPDATE_CHECK(state->check, put - out, out);
1206
1227
  out = left;
1207
1228
  if ((state->wrap & 4) && (
1208
1229
  #ifdef GUNZIP
@@ -1218,10 +1239,11 @@ int flush;
1218
1239
  }
1219
1240
  #ifdef GUNZIP
1220
1241
  state->mode = LENGTH;
1242
+ /* fallthrough */
1221
1243
  case LENGTH:
1222
1244
  if (state->wrap && state->flags) {
1223
1245
  NEEDBITS(32);
1224
- if (hold != (state->total & 0xffffffffUL)) {
1246
+ if ((state->wrap & 4) && hold != (state->total & 0xffffffff)) {
1225
1247
  strm->msg = (char *)"incorrect length check";
1226
1248
  state->mode = BAD;
1227
1249
  break;
@@ -1231,6 +1253,7 @@ int flush;
1231
1253
  }
1232
1254
  #endif
1233
1255
  state->mode = DONE;
1256
+ /* fallthrough */
1234
1257
  case DONE:
1235
1258
  ret = Z_STREAM_END;
1236
1259
  goto inf_leave;
@@ -1240,6 +1263,7 @@ int flush;
1240
1263
  case MEM:
1241
1264
  return Z_MEM_ERROR;
1242
1265
  case SYNC:
1266
+ /* fallthrough */
1243
1267
  default:
1244
1268
  return Z_STREAM_ERROR;
1245
1269
  }
@@ -1265,7 +1289,7 @@ int flush;
1265
1289
  state->total += out;
1266
1290
  if ((state->wrap & 4) && out)
1267
1291
  strm->adler = state->check =
1268
- UPDATE(state->check, strm->next_out - out, out);
1292
+ UPDATE_CHECK(state->check, strm->next_out - out, out);
1269
1293
  strm->data_type = (int)state->bits + (state->last ? 64 : 0) +
1270
1294
  (state->mode == TYPE ? 128 : 0) +
1271
1295
  (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0);
@@ -1401,6 +1425,7 @@ int ZEXPORT inflateSync(strm)
1401
1425
  z_streamp strm;
1402
1426
  {
1403
1427
  unsigned len; /* number of bytes to look at or looked at */
1428
+ int flags; /* temporary to save header status */
1404
1429
  unsigned long in, out; /* temporary to save total_in and total_out */
1405
1430
  unsigned char buf[4]; /* to restore bit buffer to byte string */
1406
1431
  struct inflate_state FAR *state;
@@ -1433,9 +1458,15 @@ z_streamp strm;
1433
1458
 
1434
1459
  /* return no joy or set up to restart inflate() on a new block */
1435
1460
  if (state->have != 4) return Z_DATA_ERROR;
1461
+ if (state->flags == -1)
1462
+ state->wrap = 0; /* if no header yet, treat as raw */
1463
+ else
1464
+ state->wrap &= ~4; /* no point in computing a check value now */
1465
+ flags = state->flags;
1436
1466
  in = strm->total_in; out = strm->total_out;
1437
1467
  inflateReset(strm);
1438
1468
  strm->total_in = in; strm->total_out = out;
1469
+ state->flags = flags;
1439
1470
  state->mode = TYPE;
1440
1471
  return Z_OK;
1441
1472
  }
@@ -1531,7 +1562,7 @@ int check;
1531
1562
 
1532
1563
  if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
1533
1564
  state = (struct inflate_state FAR *)strm->state;
1534
- if (check)
1565
+ if (check && state->wrap)
1535
1566
  state->wrap |= 4;
1536
1567
  else
1537
1568
  state->wrap &= ~4;
@@ -1,5 +1,5 @@
1
1
  /* inflate.h -- internal inflate state definition
2
- * Copyright (C) 1995-2016 Mark Adler
2
+ * Copyright (C) 1995-2019 Mark Adler
3
3
  * For conditions of distribution and use, see copyright notice in zlib.h
4
4
  */
5
5
 
@@ -86,7 +86,8 @@ struct inflate_state {
86
86
  int wrap; /* bit 0 true for zlib, bit 1 true for gzip,
87
87
  bit 2 true to validate check value */
88
88
  int havedict; /* true if dictionary provided */
89
- int flags; /* gzip header method and flags (0 if zlib) */
89
+ int flags; /* gzip header method and flags, 0 if zlib, or
90
+ -1 if raw or no header yet */
90
91
  unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */
91
92
  unsigned long check; /* protected copy of check value */
92
93
  unsigned long total; /* protected copy of output count */
@@ -1,5 +1,5 @@
1
1
  /* inftrees.c -- generate Huffman trees for efficient decoding
2
- * Copyright (C) 1995-2017 Mark Adler
2
+ * Copyright (C) 1995-2022 Mark Adler
3
3
  * For conditions of distribution and use, see copyright notice in zlib.h
4
4
  */
5
5
 
@@ -9,7 +9,7 @@
9
9
  #define MAXBITS 15
10
10
 
11
11
  const char inflate_copyright[] =
12
- " inflate 1.2.11 Copyright 1995-2017 Mark Adler ";
12
+ " inflate 1.2.12 Copyright 1995-2022 Mark Adler ";
13
13
  /*
14
14
  If you use the zlib library in a product, an acknowledgment is welcome
15
15
  in the documentation of your product. If for some reason you cannot
@@ -62,7 +62,7 @@ unsigned short FAR *work;
62
62
  35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
63
63
  static const unsigned short lext[31] = { /* Length codes 257..285 extra */
64
64
  16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
65
- 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 77, 202};
65
+ 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 199, 202};
66
66
  static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
67
67
  1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
68
68
  257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
@@ -1,5 +1,5 @@
1
1
  /* trees.c -- output deflated data using Huffman coding
2
- * Copyright (C) 1995-2017 Jean-loup Gailly
2
+ * Copyright (C) 1995-2021 Jean-loup Gailly
3
3
  * detect_data_type() function provided freely by Cosmin Truta, 2006
4
4
  * For conditions of distribution and use, see copyright notice in zlib.h
5
5
  */
@@ -149,7 +149,7 @@ local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes,
149
149
  local void compress_block OF((deflate_state *s, const ct_data *ltree,
150
150
  const ct_data *dtree));
151
151
  local int detect_data_type OF((deflate_state *s));
152
- local unsigned bi_reverse OF((unsigned value, int length));
152
+ local unsigned bi_reverse OF((unsigned code, int len));
153
153
  local void bi_windup OF((deflate_state *s));
154
154
  local void bi_flush OF((deflate_state *s));
155
155
 
@@ -416,7 +416,7 @@ local void init_block(s)
416
416
 
417
417
  s->dyn_ltree[END_BLOCK].Freq = 1;
418
418
  s->opt_len = s->static_len = 0L;
419
- s->last_lit = s->matches = 0;
419
+ s->sym_next = s->matches = 0;
420
420
  }
421
421
 
422
422
  #define SMALLEST 1
@@ -870,7 +870,8 @@ void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last)
870
870
  bi_windup(s); /* align on byte boundary */
871
871
  put_short(s, (ush)stored_len);
872
872
  put_short(s, (ush)~stored_len);
873
- zmemcpy(s->pending_buf + s->pending, (Bytef *)buf, stored_len);
873
+ if (stored_len)
874
+ zmemcpy(s->pending_buf + s->pending, (Bytef *)buf, stored_len);
874
875
  s->pending += stored_len;
875
876
  #ifdef ZLIB_DEBUG
876
877
  s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
@@ -947,7 +948,7 @@ void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)
947
948
 
948
949
  Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
949
950
  opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
950
- s->last_lit));
951
+ s->sym_next / 3));
951
952
 
952
953
  if (static_lenb <= opt_lenb) opt_lenb = static_lenb;
953
954
 
@@ -1016,8 +1017,9 @@ int ZLIB_INTERNAL _tr_tally (s, dist, lc)
1016
1017
  unsigned dist; /* distance of matched string */
1017
1018
  unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */
1018
1019
  {
1019
- s->d_buf[s->last_lit] = (ush)dist;
1020
- s->l_buf[s->last_lit++] = (uch)lc;
1020
+ s->sym_buf[s->sym_next++] = dist;
1021
+ s->sym_buf[s->sym_next++] = dist >> 8;
1022
+ s->sym_buf[s->sym_next++] = lc;
1021
1023
  if (dist == 0) {
1022
1024
  /* lc is the unmatched char */
1023
1025
  s->dyn_ltree[lc].Freq++;
@@ -1032,30 +1034,7 @@ int ZLIB_INTERNAL _tr_tally (s, dist, lc)
1032
1034
  s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++;
1033
1035
  s->dyn_dtree[d_code(dist)].Freq++;
1034
1036
  }
1035
-
1036
- #ifdef TRUNCATE_BLOCK
1037
- /* Try to guess if it is profitable to stop the current block here */
1038
- if ((s->last_lit & 0x1fff) == 0 && s->level > 2) {
1039
- /* Compute an upper bound for the compressed length */
1040
- ulg out_length = (ulg)s->last_lit*8L;
1041
- ulg in_length = (ulg)((long)s->strstart - s->block_start);
1042
- int dcode;
1043
- for (dcode = 0; dcode < D_CODES; dcode++) {
1044
- out_length += (ulg)s->dyn_dtree[dcode].Freq *
1045
- (5L+extra_dbits[dcode]);
1046
- }
1047
- out_length >>= 3;
1048
- Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
1049
- s->last_lit, in_length, out_length,
1050
- 100L - out_length*100L/in_length));
1051
- if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1;
1052
- }
1053
- #endif
1054
- return (s->last_lit == s->lit_bufsize-1);
1055
- /* We avoid equality with lit_bufsize because of wraparound at 64K
1056
- * on 16 bit machines and because stored blocks are restricted to
1057
- * 64K-1 bytes.
1058
- */
1037
+ return (s->sym_next == s->sym_end);
1059
1038
  }
1060
1039
 
1061
1040
  /* ===========================================================================
@@ -1068,13 +1047,14 @@ local void compress_block(s, ltree, dtree)
1068
1047
  {
1069
1048
  unsigned dist; /* distance of matched string */
1070
1049
  int lc; /* match length or unmatched char (if dist == 0) */
1071
- unsigned lx = 0; /* running index in l_buf */
1050
+ unsigned sx = 0; /* running index in sym_buf */
1072
1051
  unsigned code; /* the code to send */
1073
1052
  int extra; /* number of extra bits to send */
1074
1053
 
1075
- if (s->last_lit != 0) do {
1076
- dist = s->d_buf[lx];
1077
- lc = s->l_buf[lx++];
1054
+ if (s->sym_next != 0) do {
1055
+ dist = s->sym_buf[sx++] & 0xff;
1056
+ dist += (unsigned)(s->sym_buf[sx++] & 0xff) << 8;
1057
+ lc = s->sym_buf[sx++];
1078
1058
  if (dist == 0) {
1079
1059
  send_code(s, lc, ltree); /* send a literal byte */
1080
1060
  Tracecv(isgraph(lc), (stderr," '%c' ", lc));
@@ -1099,11 +1079,10 @@ local void compress_block(s, ltree, dtree)
1099
1079
  }
1100
1080
  } /* literal or match pair ? */
1101
1081
 
1102
- /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
1103
- Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,
1104
- "pendingBuf overflow");
1082
+ /* Check that the overlay between pending_buf and sym_buf is ok: */
1083
+ Assert(s->pending < s->lit_bufsize + sx, "pendingBuf overflow");
1105
1084
 
1106
- } while (lx < s->last_lit);
1085
+ } while (sx < s->sym_next);
1107
1086
 
1108
1087
  send_code(s, END_BLOCK, ltree);
1109
1088
  }
@@ -1112,9 +1091,9 @@ local void compress_block(s, ltree, dtree)
1112
1091
  * Check if the data type is TEXT or BINARY, using the following algorithm:
1113
1092
  * - TEXT if the two conditions below are satisfied:
1114
1093
  * a) There are no non-portable control characters belonging to the
1115
- * "black list" (0..6, 14..25, 28..31).
1094
+ * "block list" (0..6, 14..25, 28..31).
1116
1095
  * b) There is at least one printable character belonging to the
1117
- * "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).
1096
+ * "allow list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).
1118
1097
  * - BINARY otherwise.
1119
1098
  * - The following partially-portable control characters form a
1120
1099
  * "gray list" that is ignored in this detection algorithm:
@@ -1124,19 +1103,19 @@ local void compress_block(s, ltree, dtree)
1124
1103
  local int detect_data_type(s)
1125
1104
  deflate_state *s;
1126
1105
  {
1127
- /* black_mask is the bit mask of black-listed bytes
1106
+ /* block_mask is the bit mask of block-listed bytes
1128
1107
  * set bits 0..6, 14..25, and 28..31
1129
1108
  * 0xf3ffc07f = binary 11110011111111111100000001111111
1130
1109
  */
1131
- unsigned long black_mask = 0xf3ffc07fUL;
1110
+ unsigned long block_mask = 0xf3ffc07fUL;
1132
1111
  int n;
1133
1112
 
1134
- /* Check for non-textual ("black-listed") bytes. */
1135
- for (n = 0; n <= 31; n++, black_mask >>= 1)
1136
- if ((black_mask & 1) && (s->dyn_ltree[n].Freq != 0))
1113
+ /* Check for non-textual ("block-listed") bytes. */
1114
+ for (n = 0; n <= 31; n++, block_mask >>= 1)
1115
+ if ((block_mask & 1) && (s->dyn_ltree[n].Freq != 0))
1137
1116
  return Z_BINARY;
1138
1117
 
1139
- /* Check for textual ("white-listed") bytes. */
1118
+ /* Check for textual ("allow-listed") bytes. */
1140
1119
  if (s->dyn_ltree[9].Freq != 0 || s->dyn_ltree[10].Freq != 0
1141
1120
  || s->dyn_ltree[13].Freq != 0)
1142
1121
  return Z_TEXT;
@@ -1144,7 +1123,7 @@ local int detect_data_type(s)
1144
1123
  if (s->dyn_ltree[n].Freq != 0)
1145
1124
  return Z_TEXT;
1146
1125
 
1147
- /* There are no "black-listed" or "white-listed" bytes:
1126
+ /* There are no "block-listed" or "allow-listed" bytes:
1148
1127
  * this stream either is empty or has tolerated ("gray-listed") bytes only.
1149
1128
  */
1150
1129
  return Z_BINARY;
File without changes
File without changes