/** Transform data to smallest possible of (int32, int16, int8). * For example, we may have generated an int32 array due to user options * (e.g., %option align), but if the maximum value in that array * is 80 (for example), then we can serialize it with only 1 byte per int. * This is NOT the same as compressed DFA tables. We're just trying * to save storage space here. * * @param tbl the table to be compressed */ void yytbl_data_compress (struct yytbl_data *tbl) { flex_int32_t i, total_len; size_t newsz; struct yytbl_data newtbl; yytbl_data_init (&newtbl, tbl->td_id); newtbl.td_hilen = tbl->td_hilen; newtbl.td_lolen = tbl->td_lolen; newtbl.td_flags = tbl->td_flags; newsz = min_int_size (tbl); if (newsz == YYTDFLAGS2BYTES (tbl->td_flags)) /* No change in this table needed. */ return; if (newsz > YYTDFLAGS2BYTES (tbl->td_flags)) { flex_die (_("detected negative compression")); return; } total_len = yytbl_calc_total_len (tbl); newtbl.td_data = calloc ((size_t) total_len, newsz); newtbl.td_flags = (flex_uint16_t) (TFLAGS_CLRDATA (newtbl.td_flags) | BYTES2TFLAG (newsz)); for (i = 0; i < total_len; i++) { flex_int32_t g; g = yytbl_data_geti (tbl, i); yytbl_data_seti (&newtbl, i, g); } /* Now copy over the old table */ free (tbl->td_data); *tbl = newtbl; }
/** Calculate the number of bytes needed to hold the largest * absolute value in this data array. * @param tbl the data table * @return sizeof(n) where n in {flex_int8_t, flex_int16_t, flex_int32_t} */ static size_t min_int_size (struct yytbl_data *tbl) { flex_uint32_t i, total_len; flex_int32_t max = 0; total_len = yytbl_calc_total_len (tbl); for (i = 0; i < total_len; i++) { flex_int32_t n; n = abs (yytbl_data_geti (tbl, i)); if (n > max) max = n; } if (max <= INT8_MAX) return sizeof (flex_int8_t); else if (max <= INT16_MAX) return sizeof (flex_int16_t); else return sizeof (flex_int32_t); }
/** Write this table. * @param out the file writer * @param td table data to be written * @return -1 on error, or bytes written on success. */ int yytbl_data_fwrite (struct yytbl_writer *wr, struct yytbl_data *td) { int rv; flex_int32_t bwritten = 0; flex_int32_t i, total_len; fpos_t pos; if ((rv = yytbl_write16 (wr, td->td_id)) < 0) return -1; bwritten += rv; if ((rv = yytbl_write16 (wr, td->td_flags)) < 0) return -1; bwritten += rv; if ((rv = yytbl_write32 (wr, td->td_hilen)) < 0) return -1; bwritten += rv; if ((rv = yytbl_write32 (wr, td->td_lolen)) < 0) return -1; bwritten += rv; total_len = yytbl_calc_total_len (td); for (i = 0; i < total_len; i++) { switch (YYTDFLAGS2BYTES (td->td_flags)) { case sizeof (flex_int8_t): rv = yytbl_write8 (wr, yytbl_data_geti (td, i)); break; case sizeof (flex_int16_t): rv = yytbl_write16 (wr, yytbl_data_geti (td, i)); break; case sizeof (flex_int32_t): rv = yytbl_write32 (wr, yytbl_data_geti (td, i)); break; default: flex_die (_("invalid td_flags detected")); } if (rv < 0) { flex_die (_("error while writing tables")); return -1; } bwritten += rv; } /* Sanity check */ if (bwritten != (int) (12 + total_len * YYTDFLAGS2BYTES (td->td_flags))) { flex_die (_("insanity detected")); return -1; } /* add padding */ if ((rv = yytbl_write_pad64 (wr)) < 0) { flex_die (_("pad64 failed")); return -1; } bwritten += rv; /* Now go back and update the th_hsize member */ if (fgetpos (wr->out, &pos) != 0 || fsetpos (wr->out, &(wr->th_ssize_pos)) != 0 || yytbl_write32 (wr, wr->total_written) < 0 || fsetpos (wr->out, &pos)) { flex_die (_("get|set|fwrite32 failed")); return -1; } else /* Don't count the int we just wrote. */ wr->total_written -= sizeof (flex_int32_t); return bwritten; }