Lines Matching defs:len
54 prefix. If that longest code has length len, then the table has size 1 <<
55 (len - root), to index the remaining bits in that set of codes. Each
119 size_t len; // allocated length of bit vector in octets
126 left: number of available bit patterns at length len
127 len: number of bits in the codes currently being assigned
133 len: 1..max - 1 (max == maximum code length in bits)
140 len is less than max, since the code completes immediately when len == max.
143 one (syms) being outermost, and the last one (len) being innermost. We build
144 the array with length max-1 lists for the len index, with syms-3 of those
156 to the num[] array as described above for the (syms, left, len) triplet.
177 size_t len; // length of string, not including terminating zero
183 s->len = 0;
199 s->len = 0;
207 size_t len = s->len;
208 int ret = vsnprintf(s->str + len, s->size - len, fmt, ap);
210 s->len += ret;
211 if (s->size < s->len + 1) {
215 } while (s->size < s->len + 1);
218 vsnprintf(s->str + len, s->size - len, fmt, ap);
237 local inline size_t map(int syms, int left, int len) {
240 len - 1;
247 if (g.done[n].len)
257 // Return the number of possible prefix codes using bit patterns of lengths len
259 // len unused -- return -1 if there is an overflow in the counting. Keep a
261 local big_t count(int syms, int left, int len) {
267 assert(syms > left && left > 0 && len < g.max);
270 size_t index = map(syms, left, len);
284 int most = (((code_t)left << (g.max - len)) - syms) /
285 (((code_t)1 << (g.max - len)) - 1);
290 got = count(syms - use, (left - use) << 1, len + 1);
305 // bit vector to indicate visiting this state. Each (syms,len,left) state has a
308 local int been_here(int syms, int left, int len, int mem, int rem) {
309 // point to vector for (syms,left,len), bit in vector for (mem,rem)
310 size_t index = map(syms, left, len);
319 size_t length = g.done[index].len;
335 memset(vector + g.done[index].len, 0, length - g.done[index].len);
348 g.done[index].len = length;
357 // Examine all possible codes from the given node (syms, len, left). Compute
361 local void examine(int syms, int left, int len, int mem, int rem) {
365 g.code[len] = left;
370 rem = 1 << (len - g.root);
404 g.code[len] = 0;
409 if (been_here(syms, left, len, mem, rem))
421 int most = (((code_t)left << (g.max - len)) - syms) /
422 (((code_t)1 << (g.max - len)) - 1);
428 rem = 1 << (len - g.root);
435 g.code[len] = use;
436 examine(syms - use, (left - use) << 1, len + 1,
437 mem + (rem ? 1 << (len - g.root) : 0), rem << 1);
439 rem = 1 << (len - g.root);
446 g.code[len] = 0;
450 // intermediate code states (syms, left, len). For each completed code,