Lines Matching defs:table
411 uInt hash_size; /* number of elements in hash table */
458 * Insert new strings in the hash table only if the match
525 * string table.) Smaller buffer sizes give fast adaptation
828 * Initialize the hash table (avoiding 64K overflow for 16 bit systems).
981 * Insert all strings in the hash table (except for the last
1761 * Slide the hash table (could be avoided with
1764 * keep the hash table consistent if we switch
2003 * Insert new strings in the hash table only
2010 /* string at strstart already in hash table */
2142 /* Do not insert strings in hash table beyond this. */
2151 * Insert in hash table all strings up to the
2155 * not inserted in the hash table.
3440 * method would use a table)
4045 * Huffman code lookup table entry--this entry is four bytes for
4061 /* literal, length base, distance base, or table offset */
4153 TABLE, /* get table lengths */
4172 uInt table; /* table lengths (14 bits) */
4254 * 3. There is an implied maximum of 7 bits for the bit length table and
4456 s->sub.trees.table = t = (uInt)b & 0x3fff;
4477 Tracev((stderr, "inflate: table sizes ok\n"));
4481 while (s->sub.trees.index < 4 + (s->sub.trees.table >> 10))
4508 while (t = s->sub.trees.table,
4533 t = s->sub.trees.table;
4562 t = s->sub.trees.table;
4769 inflate_huft * FAR*, /* result: starting table */
4794 * Huffman code decoding is performed using a multi-level table
4796 * table whose size is determined by the longest code. However, the
4797 * time it takes to build this table can also be a factor if the data
4801 * shorter table that decodes the shorter, more probable codes, and
4807 * below. lbits is the number of bits the first level table for
4813 * than the requested table size, in which case the length of the
4817 * a different number of possibilities each. The literal/length table
4819 * bits. The distance table codes 30 possible values, or a little
4838 inflate_huft * FAR *t; /* result: starting table */
4844 * Given a list of code lengths and a maximum table size, make a set
4854 uInt c[BMAX+1]; /* bit length count table */
4855 uInt f; /* i repeats in table every f entries */
4857 int h; /* table level */
4861 int l; /* bits per table (returned in m) */
4863 inflate_huft *q; /* points to current table */
4864 struct inflate_huft_s r; /* table entry for structure assignment */
4865 inflate_huft *u[BMAX]; /* table stack */
4867 register int w; /* bits before this table == (l * h) */
4871 uInt z; /* number of entries in current table */
4918 /* Generate starting offsets into the value table for each length */
4926 /* Make a table of values in order of bit lengths */
4935 /* Generate the Huffman codes and for each, make the table entries */
4955 w += l; /* previous table always l bits */
4958 * compute minimum size table less
4962 /* table size upper limit */
4964 /* try a k-w bit table */
4966 /* too few codes for k-w bit table */
4992 /* table entries for j-bit table */
4995 /* allocate new table */
5003 /* connect to last table, if there is one */
5007 /* bits to dump before this table */
5009 /* bits in this table */
5012 /* offset to this table */
5014 /* connect to last table */
5017 /* first table is returned result */
5021 /* set up table entry in r */
5062 /* Return Z_BUF_ERROR if we were given an incomplete table */
5190 /* literal table */
5203 /* distance table */
5394 if ((e & 64) == 0) { /* next table */
5432 if ((e & 64) == 0) { /* next table */
5939 local ptr_table table[MAX_PTR];
5941 * This table is used to remember the original form of pointers to
5944 * table is not protected from concurrent access. This hack doesn't
5969 table[next_ptr].org_ptr = buf;
5974 table[next_ptr++].new_ptr = buf;
5988 if (ptr != table[n].new_ptr)
5991 farfree(table[n].org_ptr);
5993 table[n-1] = table[n];