| File: | src/usr.bin/lex/tables.c |
| Warning: | line 373, column 40 Use of zero-allocated memory |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 1 | /* $OpenBSD: tables.c,v 1.4 2017/08/17 19:27:09 tedu Exp $ */ | |||
| 2 | ||||
| 3 | /* tables.c - tables serialization code | |||
| 4 | * | |||
| 5 | * Copyright (c) 1990 The Regents of the University of California. | |||
| 6 | * All rights reserved. | |||
| 7 | * | |||
| 8 | * This code is derived from software contributed to Berkeley by | |||
| 9 | * Vern Paxson. | |||
| 10 | * | |||
| 11 | * The United States Government has rights in this work pursuant | |||
| 12 | * to contract no. DE-AC03-76SF00098 between the United States | |||
| 13 | * Department of Energy and the University of California. | |||
| 14 | * | |||
| 15 | * This file is part of flex. | |||
| 16 | * | |||
| 17 | * Redistribution and use in source and binary forms, with or without | |||
| 18 | * modification, are permitted provided that the following conditions | |||
| 19 | * are met: | |||
| 20 | * | |||
| 21 | * 1. Redistributions of source code must retain the above copyright | |||
| 22 | * notice, this list of conditions and the following disclaimer. | |||
| 23 | * 2. Redistributions in binary form must reproduce the above copyright | |||
| 24 | * notice, this list of conditions and the following disclaimer in the | |||
| 25 | * documentation and/or other materials provided with the distribution. | |||
| 26 | * | |||
| 27 | * Neither the name of the University nor the names of its contributors | |||
| 28 | * may be used to endorse or promote products derived from this software | |||
| 29 | * without specific prior written permission. | |||
| 30 | * | |||
| 31 | * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR | |||
| 32 | * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED | |||
| 33 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | |||
| 34 | * PURPOSE. | |||
| 35 | */ | |||
| 36 | ||||
| 37 | ||||
| 38 | #include "flexdef.h" | |||
| 39 | #include "tables.h" | |||
| 40 | ||||
| 41 | /** Convert size_t to t_flag. | |||
| 42 | * @param n in {1,2,4} | |||
| 43 | * @return YYTD_DATA*. | |||
| 44 | */ | |||
| 45 | #define BYTES2TFLAG(n)(((n) == sizeof(flex_int8_t)) ? YYTD_DATA8 :(((n)== sizeof(flex_int16_t )) ? YYTD_DATA16 : YYTD_DATA32))\ | |||
| 46 | (((n) == sizeof(flex_int8_t))\ | |||
| 47 | ? YYTD_DATA8\ | |||
| 48 | :(((n)== sizeof(flex_int16_t))\ | |||
| 49 | ? YYTD_DATA16\ | |||
| 50 | : YYTD_DATA32)) | |||
| 51 | ||||
| 52 | /** Clear YYTD_DATA* bit flags | |||
| 53 | * @return the flag with the YYTD_DATA* bits cleared | |||
| 54 | */ | |||
| 55 | #define TFLAGS_CLRDATA(flg)((flg) & ~(YYTD_DATA8 | YYTD_DATA16 | YYTD_DATA32)) ((flg) & ~(YYTD_DATA8 | YYTD_DATA16 | YYTD_DATA32)) | |||
| 56 | ||||
| 57 | int yytbl_write32 (struct yytbl_writer *wr, flex_uint32_t v); | |||
| 58 | int yytbl_write16 (struct yytbl_writer *wr, flex_uint16_t v); | |||
| 59 | int yytbl_write8 (struct yytbl_writer *wr, flex_uint8_t v); | |||
| 60 | int yytbl_writen (struct yytbl_writer *wr, void *v, flex_int32_t len); | |||
| 61 | static flex_int32_t yytbl_data_geti (const struct yytbl_data *tbl, int i); | |||
| 62 | ||||
| 63 | /** Initialize the table writer. | |||
| 64 | * @param wr an uninitialized writer | |||
| 65 | * @param the output file | |||
| 66 | * @return 0 on success | |||
| 67 | */ | |||
| 68 | int yytbl_writer_init (struct yytbl_writer *wr, FILE * out) | |||
| 69 | { | |||
| 70 | wr->out = out; | |||
| 71 | wr->total_written = 0; | |||
| 72 | return 0; | |||
| 73 | } | |||
| 74 | ||||
| 75 | /** Initialize a table header. | |||
| 76 | * @param th The uninitialized structure | |||
| 77 | * @param version_str the version string | |||
| 78 | * @param name the name of this table set | |||
| 79 | */ | |||
| 80 | int yytbl_hdr_init (struct yytbl_hdr *th, const char *version_str, | |||
| 81 | const char *name) | |||
| 82 | { | |||
| 83 | memset (th, 0, sizeof (struct yytbl_hdr)); | |||
| 84 | ||||
| 85 | th->th_magic = YYTBL_MAGIC0xF13C57B1; | |||
| 86 | th->th_hsize = 14 + strlen (version_str) + 1 + strlen (name) + 1; | |||
| 87 | th->th_hsize += yypad64 (th->th_hsize)((8-((th->th_hsize)%8))%8); | |||
| 88 | th->th_ssize = 0; // Not known at this point. | |||
| 89 | th->th_flags = 0; | |||
| 90 | th->th_version = copy_string (version_str); | |||
| 91 | th->th_name = copy_string (name); | |||
| 92 | return 0; | |||
| 93 | } | |||
| 94 | ||||
| 95 | /** Allocate and initialize a table data structure. | |||
| 96 | * @param tbl a pointer to an uninitialized table | |||
| 97 | * @param id the table identifier | |||
| 98 | * @return 0 on success | |||
| 99 | */ | |||
| 100 | int yytbl_data_init (struct yytbl_data *td, enum yytbl_id id) | |||
| 101 | { | |||
| 102 | ||||
| 103 | memset (td, 0, sizeof (struct yytbl_data)); | |||
| 104 | td->td_id = id; | |||
| 105 | td->td_flags = YYTD_DATA32; | |||
| 106 | return 0; | |||
| 107 | } | |||
| 108 | ||||
| 109 | /** Clean up table and data array. | |||
| 110 | * @param td will be destroyed | |||
| 111 | * @return 0 on success | |||
| 112 | */ | |||
| 113 | int yytbl_data_destroy (struct yytbl_data *td) | |||
| 114 | { | |||
| 115 | free(td->td_data); | |||
| 116 | td->td_data = 0; | |||
| 117 | free (td); | |||
| 118 | return 0; | |||
| 119 | } | |||
| 120 | ||||
| 121 | /** Write enough padding to bring the file pointer to a 64-bit boundary. */ | |||
| 122 | static int yytbl_write_pad64 (struct yytbl_writer *wr) | |||
| 123 | { | |||
| 124 | int pad, bwritten = 0; | |||
| 125 | ||||
| 126 | pad = yypad64 (wr->total_written)((8-((wr->total_written)%8))%8); | |||
| 127 | while (pad-- > 0) | |||
| 128 | if (yytbl_write8 (wr, 0) < 0) | |||
| 129 | return -1; | |||
| 130 | else | |||
| 131 | bwritten++; | |||
| 132 | return bwritten; | |||
| 133 | } | |||
| 134 | ||||
| 135 | /** write the header. | |||
| 136 | * @param out the output stream | |||
| 137 | * @param th table header to be written | |||
| 138 | * @return -1 on error, or bytes written on success. | |||
| 139 | */ | |||
| 140 | int yytbl_hdr_fwrite (struct yytbl_writer *wr, const struct yytbl_hdr *th) | |||
| 141 | { | |||
| 142 | int sz, rv; | |||
| 143 | int bwritten = 0; | |||
| 144 | ||||
| 145 | if (yytbl_write32 (wr, th->th_magic) < 0 | |||
| 146 | || yytbl_write32 (wr, th->th_hsize) < 0) | |||
| 147 | flex_die (_("th_magic|th_hsize write32 failed"))do{ fprintf ((&__sF[2]), "%s: fatal internal error at %s:%d (%s): %s\n" , program_name, "/usr/src/usr.bin/lex/tables.c", (int)147, __func__ ,"th_magic|th_hsize write32 failed"); longjmp(flex_main_jmp_buf ,(1)+1); }while(0); | |||
| 148 | bwritten += 8; | |||
| 149 | ||||
| 150 | if (fgetpos (wr->out, &(wr->th_ssize_pos)) != 0) | |||
| 151 | flex_die (_("fgetpos failed"))do{ fprintf ((&__sF[2]), "%s: fatal internal error at %s:%d (%s): %s\n" , program_name, "/usr/src/usr.bin/lex/tables.c", (int)151, __func__ ,"fgetpos failed"); longjmp(flex_main_jmp_buf,(1)+1); }while( 0); | |||
| 152 | ||||
| 153 | if (yytbl_write32 (wr, th->th_ssize) < 0 | |||
| 154 | || yytbl_write16 (wr, th->th_flags) < 0) | |||
| 155 | flex_die (_("th_ssize|th_flags write failed"))do{ fprintf ((&__sF[2]), "%s: fatal internal error at %s:%d (%s): %s\n" , program_name, "/usr/src/usr.bin/lex/tables.c", (int)155, __func__ ,"th_ssize|th_flags write failed"); longjmp(flex_main_jmp_buf ,(1)+1); }while(0); | |||
| 156 | bwritten += 6; | |||
| 157 | ||||
| 158 | sz = strlen (th->th_version) + 1; | |||
| 159 | if ((rv = yytbl_writen (wr, th->th_version, sz)) != sz) | |||
| 160 | flex_die (_("th_version writen failed"))do{ fprintf ((&__sF[2]), "%s: fatal internal error at %s:%d (%s): %s\n" , program_name, "/usr/src/usr.bin/lex/tables.c", (int)160, __func__ ,"th_version writen failed"); longjmp(flex_main_jmp_buf,(1)+1 ); }while(0); | |||
| 161 | bwritten += rv; | |||
| 162 | ||||
| 163 | sz = strlen (th->th_name) + 1; | |||
| 164 | if ((rv = yytbl_writen (wr, th->th_name, sz)) != sz) | |||
| 165 | flex_die (_("th_name writen failed"))do{ fprintf ((&__sF[2]), "%s: fatal internal error at %s:%d (%s): %s\n" , program_name, "/usr/src/usr.bin/lex/tables.c", (int)165, __func__ ,"th_name writen failed"); longjmp(flex_main_jmp_buf,(1)+1); } while(0); | |||
| 166 | bwritten += rv; | |||
| 167 | ||||
| 168 | /* add padding */ | |||
| 169 | if ((rv = yytbl_write_pad64 (wr)) < 0) | |||
| 170 | flex_die (_("pad64 failed"))do{ fprintf ((&__sF[2]), "%s: fatal internal error at %s:%d (%s): %s\n" , program_name, "/usr/src/usr.bin/lex/tables.c", (int)170, __func__ ,"pad64 failed"); longjmp(flex_main_jmp_buf,(1)+1); }while(0); | |||
| 171 | bwritten += rv; | |||
| 172 | ||||
| 173 | /* Sanity check */ | |||
| 174 | if (bwritten != (int) th->th_hsize) | |||
| 175 | flex_die (_("pad64 failed"))do{ fprintf ((&__sF[2]), "%s: fatal internal error at %s:%d (%s): %s\n" , program_name, "/usr/src/usr.bin/lex/tables.c", (int)175, __func__ ,"pad64 failed"); longjmp(flex_main_jmp_buf,(1)+1); }while(0); | |||
| 176 | ||||
| 177 | return bwritten; | |||
| 178 | } | |||
| 179 | ||||
| 180 | ||||
| 181 | /** Write this table. | |||
| 182 | * @param out the file writer | |||
| 183 | * @param td table data to be written | |||
| 184 | * @return -1 on error, or bytes written on success. | |||
| 185 | */ | |||
| 186 | int yytbl_data_fwrite (struct yytbl_writer *wr, struct yytbl_data *td) | |||
| 187 | { | |||
| 188 | int rv; | |||
| 189 | flex_int32_t bwritten = 0; | |||
| 190 | flex_int32_t i, total_len; | |||
| 191 | fpos_t pos; | |||
| 192 | ||||
| 193 | if ((rv = yytbl_write16 (wr, td->td_id)) < 0) | |||
| 194 | return -1; | |||
| 195 | bwritten += rv; | |||
| 196 | ||||
| 197 | if ((rv = yytbl_write16 (wr, td->td_flags)) < 0) | |||
| 198 | return -1; | |||
| 199 | bwritten += rv; | |||
| 200 | ||||
| 201 | if ((rv = yytbl_write32 (wr, td->td_hilen)) < 0) | |||
| 202 | return -1; | |||
| 203 | bwritten += rv; | |||
| 204 | ||||
| 205 | if ((rv = yytbl_write32 (wr, td->td_lolen)) < 0) | |||
| 206 | return -1; | |||
| 207 | bwritten += rv; | |||
| 208 | ||||
| 209 | total_len = yytbl_calc_total_len (td); | |||
| 210 | for (i = 0; i < total_len; i++) { | |||
| 211 | switch (YYTDFLAGS2BYTES (td->td_flags)(((td->td_flags) & YYTD_DATA8) ? sizeof(flex_int8_t) : (((td->td_flags) & YYTD_DATA16) ? sizeof(flex_int16_t) :sizeof(flex_int32_t)))) { | |||
| 212 | case sizeof (flex_int8_t): | |||
| 213 | rv = yytbl_write8 (wr, yytbl_data_geti (td, i)); | |||
| 214 | break; | |||
| 215 | case sizeof (flex_int16_t): | |||
| 216 | rv = yytbl_write16 (wr, yytbl_data_geti (td, i)); | |||
| 217 | break; | |||
| 218 | case sizeof (flex_int32_t): | |||
| 219 | rv = yytbl_write32 (wr, yytbl_data_geti (td, i)); | |||
| 220 | break; | |||
| 221 | default: | |||
| 222 | flex_die (_("invalid td_flags detected"))do{ fprintf ((&__sF[2]), "%s: fatal internal error at %s:%d (%s): %s\n" , program_name, "/usr/src/usr.bin/lex/tables.c", (int)222, __func__ ,"invalid td_flags detected"); longjmp(flex_main_jmp_buf,(1)+ 1); }while(0); | |||
| 223 | } | |||
| 224 | if (rv < 0) { | |||
| 225 | flex_die (_("error while writing tables"))do{ fprintf ((&__sF[2]), "%s: fatal internal error at %s:%d (%s): %s\n" , program_name, "/usr/src/usr.bin/lex/tables.c", (int)225, __func__ ,"error while writing tables"); longjmp(flex_main_jmp_buf,(1) +1); }while(0); | |||
| 226 | return -1; | |||
| 227 | } | |||
| 228 | bwritten += rv; | |||
| 229 | } | |||
| 230 | ||||
| 231 | /* Sanity check */ | |||
| 232 | if (bwritten != (int) (12 + total_len * YYTDFLAGS2BYTES (td->td_flags)(((td->td_flags) & YYTD_DATA8) ? sizeof(flex_int8_t) : (((td->td_flags) & YYTD_DATA16) ? sizeof(flex_int16_t) :sizeof(flex_int32_t))))) { | |||
| 233 | flex_die (_("insanity detected"))do{ fprintf ((&__sF[2]), "%s: fatal internal error at %s:%d (%s): %s\n" , program_name, "/usr/src/usr.bin/lex/tables.c", (int)233, __func__ ,"insanity detected"); longjmp(flex_main_jmp_buf,(1)+1); }while (0); | |||
| 234 | return -1; | |||
| 235 | } | |||
| 236 | ||||
| 237 | /* add padding */ | |||
| 238 | if ((rv = yytbl_write_pad64 (wr)) < 0) { | |||
| 239 | flex_die (_("pad64 failed"))do{ fprintf ((&__sF[2]), "%s: fatal internal error at %s:%d (%s): %s\n" , program_name, "/usr/src/usr.bin/lex/tables.c", (int)239, __func__ ,"pad64 failed"); longjmp(flex_main_jmp_buf,(1)+1); }while(0); | |||
| 240 | return -1; | |||
| 241 | } | |||
| 242 | bwritten += rv; | |||
| 243 | ||||
| 244 | /* Now go back and update the th_hsize member */ | |||
| 245 | if (fgetpos (wr->out, &pos) != 0 | |||
| 246 | || fsetpos (wr->out, &(wr->th_ssize_pos)) != 0 | |||
| 247 | || yytbl_write32 (wr, wr->total_written) < 0 | |||
| 248 | || fsetpos (wr->out, &pos)) { | |||
| 249 | flex_die (_("get|set|fwrite32 failed"))do{ fprintf ((&__sF[2]), "%s: fatal internal error at %s:%d (%s): %s\n" , program_name, "/usr/src/usr.bin/lex/tables.c", (int)249, __func__ ,"get|set|fwrite32 failed"); longjmp(flex_main_jmp_buf,(1)+1) ; }while(0); | |||
| 250 | return -1; | |||
| 251 | } | |||
| 252 | else | |||
| 253 | /* Don't count the int we just wrote. */ | |||
| 254 | wr->total_written -= sizeof (flex_int32_t); | |||
| 255 | return bwritten; | |||
| 256 | } | |||
| 257 | ||||
| 258 | /** Write n bytes. | |||
| 259 | * @param wr the table writer | |||
| 260 | * @param v data to be written | |||
| 261 | * @param len number of bytes | |||
| 262 | * @return -1 on error. number of bytes written on success. | |||
| 263 | */ | |||
| 264 | int yytbl_writen (struct yytbl_writer *wr, void *v, flex_int32_t len) | |||
| 265 | { | |||
| 266 | int rv; | |||
| 267 | ||||
| 268 | rv = fwrite (v, 1, len, wr->out); | |||
| 269 | if (rv != len) | |||
| 270 | return -1; | |||
| 271 | wr->total_written += len; | |||
| 272 | return len; | |||
| 273 | } | |||
| 274 | ||||
| 275 | /** Write four bytes in network byte order | |||
| 276 | * @param wr the table writer | |||
| 277 | * @param v a dword in host byte order | |||
| 278 | * @return -1 on error. number of bytes written on success. | |||
| 279 | */ | |||
| 280 | int yytbl_write32 (struct yytbl_writer *wr, flex_uint32_t v) | |||
| 281 | { | |||
| 282 | flex_uint32_t vnet; | |||
| 283 | size_t bytes, rv; | |||
| 284 | ||||
| 285 | vnet = htonl (v)(__uint32_t)(__builtin_constant_p(v) ? (__uint32_t)(((__uint32_t )(v) & 0xff) << 24 | ((__uint32_t)(v) & 0xff00) << 8 | ((__uint32_t)(v) & 0xff0000) >> 8 | ( (__uint32_t)(v) & 0xff000000) >> 24) : __swap32md(v )); | |||
| 286 | bytes = sizeof (flex_uint32_t); | |||
| 287 | rv = fwrite (&vnet, bytes, 1, wr->out); | |||
| 288 | if (rv != 1) | |||
| 289 | return -1; | |||
| 290 | wr->total_written += bytes; | |||
| 291 | return bytes; | |||
| 292 | } | |||
| 293 | ||||
| 294 | /** Write two bytes in network byte order. | |||
| 295 | * @param wr the table writer | |||
| 296 | * @param v a word in host byte order | |||
| 297 | * @return -1 on error. number of bytes written on success. | |||
| 298 | */ | |||
| 299 | int yytbl_write16 (struct yytbl_writer *wr, flex_uint16_t v) | |||
| 300 | { | |||
| 301 | flex_uint16_t vnet; | |||
| 302 | size_t bytes, rv; | |||
| 303 | ||||
| 304 | vnet = htons (v)(__uint16_t)(__builtin_constant_p(v) ? (__uint16_t)(((__uint16_t )(v) & 0xffU) << 8 | ((__uint16_t)(v) & 0xff00U ) >> 8) : __swap16md(v)); | |||
| 305 | bytes = sizeof (flex_uint16_t); | |||
| 306 | rv = fwrite (&vnet, bytes, 1, wr->out); | |||
| 307 | if (rv != 1) | |||
| 308 | return -1; | |||
| 309 | wr->total_written += bytes; | |||
| 310 | return bytes; | |||
| 311 | } | |||
| 312 | ||||
| 313 | /** Write a byte. | |||
| 314 | * @param wr the table writer | |||
| 315 | * @param v the value to be written | |||
| 316 | * @return -1 on error. number of bytes written on success. | |||
| 317 | */ | |||
| 318 | int yytbl_write8 (struct yytbl_writer *wr, flex_uint8_t v) | |||
| 319 | { | |||
| 320 | size_t bytes, rv; | |||
| 321 | ||||
| 322 | bytes = sizeof (flex_uint8_t); | |||
| 323 | rv = fwrite (&v, bytes, 1, wr->out); | |||
| 324 | if (rv != 1) | |||
| 325 | return -1; | |||
| 326 | wr->total_written += bytes; | |||
| 327 | return bytes; | |||
| 328 | } | |||
| 329 | ||||
| 330 | /** Extract data element [i] from array data tables treated as a single flat array of integers. | |||
| 331 | * Be careful for 2-dimensional arrays or for YYTD_ID_TRANSITION, which is an array | |||
| 332 | * of structs. | |||
| 333 | * @param tbl data table | |||
| 334 | * @param i index into array. | |||
| 335 | * @return data[i] | |||
| 336 | */ | |||
| 337 | static flex_int32_t yytbl_data_geti (const struct yytbl_data *tbl, int i) | |||
| 338 | { | |||
| 339 | ||||
| 340 | switch (YYTDFLAGS2BYTES (tbl->td_flags)(((tbl->td_flags) & YYTD_DATA8) ? sizeof(flex_int8_t) : (((tbl->td_flags) & YYTD_DATA16) ? sizeof(flex_int16_t ) :sizeof(flex_int32_t)))) { | |||
| 341 | case sizeof (flex_int8_t): | |||
| 342 | return ((flex_int8_t *) (tbl->td_data))[i]; | |||
| 343 | case sizeof (flex_int16_t): | |||
| 344 | return ((flex_int16_t *) (tbl->td_data))[i]; | |||
| 345 | case sizeof (flex_int32_t): | |||
| 346 | return ((flex_int32_t *) (tbl->td_data))[i]; | |||
| 347 | default: | |||
| 348 | flex_die (_("invalid td_flags detected"))do{ fprintf ((&__sF[2]), "%s: fatal internal error at %s:%d (%s): %s\n" , program_name, "/usr/src/usr.bin/lex/tables.c", (int)348, __func__ ,"invalid td_flags detected"); longjmp(flex_main_jmp_buf,(1)+ 1); }while(0); | |||
| 349 | break; | |||
| 350 | } | |||
| 351 | return 0; | |||
| 352 | } | |||
| 353 | ||||
| 354 | /** Set data element [i] in array data tables treated as a single flat array of integers. | |||
| 355 | * Be careful for 2-dimensional arrays or for YYTD_ID_TRANSITION, which is an array | |||
| 356 | * of structs. | |||
| 357 | * @param tbl data table | |||
| 358 | * @param i index into array. | |||
| 359 | * @param newval new value for data[i] | |||
| 360 | */ | |||
| 361 | static void yytbl_data_seti (const struct yytbl_data *tbl, int i, | |||
| 362 | flex_int32_t newval) | |||
| 363 | { | |||
| 364 | ||||
| 365 | switch (YYTDFLAGS2BYTES (tbl->td_flags)(((tbl->td_flags) & YYTD_DATA8) ? sizeof(flex_int8_t) : (((tbl->td_flags) & YYTD_DATA16) ? sizeof(flex_int16_t ) :sizeof(flex_int32_t)))) { | |||
| 366 | case sizeof (flex_int8_t): | |||
| 367 | ((flex_int8_t *) (tbl->td_data))[i] = (flex_int8_t) newval; | |||
| 368 | break; | |||
| 369 | case sizeof (flex_int16_t): | |||
| 370 | ((flex_int16_t *) (tbl->td_data))[i] = (flex_int16_t) newval; | |||
| 371 | break; | |||
| 372 | case sizeof (flex_int32_t): | |||
| 373 | ((flex_int32_t *) (tbl->td_data))[i] = (flex_int32_t) newval; | |||
| ||||
| 374 | break; | |||
| 375 | default: | |||
| 376 | flex_die (_("invalid td_flags detected"))do{ fprintf ((&__sF[2]), "%s: fatal internal error at %s:%d (%s): %s\n" , program_name, "/usr/src/usr.bin/lex/tables.c", (int)376, __func__ ,"invalid td_flags detected"); longjmp(flex_main_jmp_buf,(1)+ 1); }while(0); | |||
| 377 | break; | |||
| 378 | } | |||
| 379 | } | |||
| 380 | ||||
| 381 | /** Calculate the number of bytes needed to hold the largest | |||
| 382 | * absolute value in this data array. | |||
| 383 | * @param tbl the data table | |||
| 384 | * @return sizeof(n) where n in {flex_int8_t, flex_int16_t, flex_int32_t} | |||
| 385 | */ | |||
| 386 | static size_t min_int_size (struct yytbl_data *tbl) | |||
| 387 | { | |||
| 388 | flex_uint32_t i, total_len; | |||
| 389 | flex_int32_t max = 0; | |||
| 390 | ||||
| 391 | total_len = yytbl_calc_total_len (tbl); | |||
| 392 | ||||
| 393 | for (i = 0; i < total_len; i++) { | |||
| 394 | flex_int32_t n; | |||
| 395 | ||||
| 396 | n = abs (yytbl_data_geti (tbl, i)); | |||
| 397 | ||||
| 398 | if (n > max) | |||
| 399 | max = n; | |||
| 400 | } | |||
| 401 | ||||
| 402 | if (max <= INT8_MAX0x7f) | |||
| 403 | return sizeof (flex_int8_t); | |||
| 404 | else if (max <= INT16_MAX0x7fff) | |||
| 405 | return sizeof (flex_int16_t); | |||
| 406 | else | |||
| 407 | return sizeof (flex_int32_t); | |||
| 408 | } | |||
| 409 | ||||
| 410 | /** Transform data to smallest possible of (int32, int16, int8). | |||
| 411 | * For example, we may have generated an int32 array due to user options | |||
| 412 | * (e.g., %option align), but if the maximum value in that array | |||
| 413 | * is 80 (for example), then we can serialize it with only 1 byte per int. | |||
| 414 | * This is NOT the same as compressed DFA tables. We're just trying | |||
| 415 | * to save storage space here. | |||
| 416 | * | |||
| 417 | * @param tbl the table to be compressed | |||
| 418 | */ | |||
| 419 | void yytbl_data_compress (struct yytbl_data *tbl) | |||
| 420 | { | |||
| 421 | flex_int32_t i, newsz, total_len; | |||
| 422 | struct yytbl_data newtbl; | |||
| 423 | ||||
| 424 | yytbl_data_init (&newtbl, tbl->td_id); | |||
| 425 | newtbl.td_hilen = tbl->td_hilen; | |||
| 426 | newtbl.td_lolen = tbl->td_lolen; | |||
| 427 | newtbl.td_flags = tbl->td_flags; | |||
| 428 | ||||
| 429 | newsz = min_int_size (tbl); | |||
| 430 | ||||
| 431 | ||||
| 432 | if (newsz == (int) YYTDFLAGS2BYTES (tbl->td_flags)(((tbl->td_flags) & YYTD_DATA8) ? sizeof(flex_int8_t) : (((tbl->td_flags) & YYTD_DATA16) ? sizeof(flex_int16_t ) :sizeof(flex_int32_t)))) | |||
| ||||
| 433 | /* No change in this table needed. */ | |||
| 434 | return; | |||
| 435 | ||||
| 436 | if (newsz > (int) YYTDFLAGS2BYTES (tbl->td_flags)(((tbl->td_flags) & YYTD_DATA8) ? sizeof(flex_int8_t) : (((tbl->td_flags) & YYTD_DATA16) ? sizeof(flex_int16_t ) :sizeof(flex_int32_t)))) { | |||
| 437 | flex_die (_("detected negative compression"))do{ fprintf ((&__sF[2]), "%s: fatal internal error at %s:%d (%s): %s\n" , program_name, "/usr/src/usr.bin/lex/tables.c", (int)437, __func__ ,"detected negative compression"); longjmp(flex_main_jmp_buf, (1)+1); }while(0); | |||
| 438 | return; | |||
| 439 | } | |||
| 440 | ||||
| 441 | total_len = yytbl_calc_total_len (tbl); | |||
| 442 | newtbl.td_data = calloc (total_len, newsz); | |||
| 443 | newtbl.td_flags = | |||
| 444 | TFLAGS_CLRDATA (newtbl.td_flags)((newtbl.td_flags) & ~(YYTD_DATA8 | YYTD_DATA16 | YYTD_DATA32 )) | BYTES2TFLAG (newsz)(((newsz) == sizeof(flex_int8_t)) ? YYTD_DATA8 :(((newsz)== sizeof (flex_int16_t)) ? YYTD_DATA16 : YYTD_DATA32)); | |||
| 445 | ||||
| 446 | for (i = 0; i < total_len; i++) { | |||
| 447 | flex_int32_t g; | |||
| 448 | ||||
| 449 | g = yytbl_data_geti (tbl, i); | |||
| 450 | yytbl_data_seti (&newtbl, i, g); | |||
| 451 | } | |||
| 452 | ||||
| 453 | ||||
| 454 | /* Now copy over the old table */ | |||
| 455 | free (tbl->td_data); | |||
| 456 | *tbl = newtbl; | |||
| 457 | } |