int process_switchB(ea_t curr, ea_t start, ea_t func_end) { ea_t diff = start - curr, min = func_end, ptr; unsigned long i; if ( diff && diff < 4 ) { do_unknown_range(curr, diff, true); } #ifdef PIC_DEBUG RP_TRACE2("start %X, to %X\n", start, func_end); #endif ptr = get_next_code(start); if ( NULL == ptr ) do_unknown(start,false); else { if ( isTail(getFlags(start)) ) { do_unknown(prev_not_tail(start),false); } else do_unknown_range(start, ptr-start, true); } for ( i = 0; start+i < min; i += 4 ) { ptr = got_addr - get_long(start + i); #ifdef PIC_DEBUG RP_TRACE3("min is %X, ptr %X, i %d\n", min, ptr, i); #endif if ( ptr < func_end ) { if ( ptr < min ) min = ptr; #ifdef PIC_DEBUG RP_TRACE2("one_switch_entry %X, ptr %X\n", start+i, ptr ); #endif one_switch_entry(start+i, ptr); } else break; /* end ? */ } return (i>>2); }
ILboolean GifGetData(ILubyte *Data, ILuint ImageSize, ILuint Width, ILuint Height, ILuint Stride, GFXCONTROL *Gfx) { ILubyte *sp; ILint code, fc, oc; ILubyte DisposalMethod = 0; ILint c, size; ILuint i = 0, Read = 0; if (!Gfx->Used) DisposalMethod = (Gfx->Packed & 0x1C) >> 2; if((size = igetc()) == IL_EOF) return IL_FALSE; if (size < 2 || 9 < size) { return IL_FALSE; } stack = (ILubyte*)ialloc(MAX_CODES + 1); suffix = (ILubyte*)ialloc(MAX_CODES + 1); prefix = (ILshort*)ialloc(sizeof(*prefix) * (MAX_CODES + 1)); if (!stack || !suffix || !prefix) { ifree(stack); ifree(suffix); ifree(prefix); return IL_FALSE; } curr_size = size + 1; top_slot = 1 << curr_size; clear = 1 << size; ending = clear + 1; slot = newcodes = ending + 1; navail_bytes = nbits_left = 0; oc = fc = 0; sp = stack; success = IL_TRUE; while ((c = get_next_code()) != ending && Read < Height) { if (c == clear) { curr_size = size + 1; slot = newcodes; top_slot = 1 << curr_size; while ((c = get_next_code()) == clear); if (c == ending) break; if (c >= slot) c = 0; oc = fc = c; if (DisposalMethod == 1 && !Gfx->Used && Gfx->Transparent == c && (Gfx->Packed & 0x1) != 0) i++; else Data[i++] = c; if (i == Width) { Data += Stride; i = 0; Read += 1; } } else { code = c; if (code >= slot) { code = oc; *sp++ = fc; } while (code >= newcodes) { *sp++ = suffix[code]; code = prefix[code]; } *sp++ = (ILbyte)code; if (slot < top_slot) { fc = code; suffix[slot] = fc; prefix[slot++] = oc; oc = c; } if (slot >= top_slot && curr_size < 12) { top_slot <<= 1; curr_size++; } while (sp > stack) { sp--; if (DisposalMethod == 1 && !Gfx->Used && Gfx->Transparent == *sp && (Gfx->Packed & 0x1) != 0) i++; else Data[i++] = *sp; if (i == Width) { Data += Stride; i = 0; Read += 1; } } } } ifree(stack); ifree(suffix); ifree(prefix); return success; }
static short decoder( short linewidth, unsigned char far * buf, unsigned char far * stack, unsigned char far * suffix, unsigned short far * prefix) { unsigned char far *sp; unsigned char far *bufptr; register short code, fc, oc, bufcnt; short c, size, ret; /* * Initialize for decoding a new image... */ if ((size = gif_get_byte()) < 0) return (size); if (size < 2 || 9 < size) return (BAD_CODE_SIZE); init_exp(size); /* * Initialize in case they forgot to put in a clear code. (This * shouldn't happen, but we'll try and decode it anyway...) */ oc = fc = 0; /* * Set up the stack pointer and decode buffer pointer */ sp = stack; bufptr = buf; bufcnt = linewidth; /* * This is the main loop. For each code we get we pass through the * linked list of prefix codes, pushing the corresponding "character" * for each code onto the stack. When the list reaches a single * "character" we push that on the stack too, and then start * unstacking each character for output in the correct order. Special * handling is included for the clear code, and the whole thing ends * when we get an ending code. */ while ((c = get_next_code()) != ending) { /* * If we had a file error, return without completing the * decode */ if (c < 0) { return (c); } /* * If the code is a clear code, reinitialize all necessary * items. */ if (c == clear) { curr_size = size + 1; slot = newcodes; top_slot = 1 << curr_size; /* * Continue reading codes until we get a non-clear * code (Another unlikely, but possible case...) */ while ((c = get_next_code()) == clear) ; /* * If we get an ending code immediately after a clear * code (Yet another unlikely case), then break out * of the loop. */ if (c == ending) break; /* * Finally, if the code is beyond the range of * already set codes, (This one had better NOT * happen... I have no idea what will result from * this, but I doubt it will look good...) then set * it to color zero. */ if (c >= slot) c = 0; oc = fc = c; /* * And let us not forget to put the char into the * buffer... And if, on the off chance, we were * exactly one pixel from the end of the line, we * have to send the buffer to the gif_out_line() * routine... */ *bufptr++ = c; if (--bufcnt == 0) { if ((ret = gif_out_line(buf, linewidth)) < 0) { return (ret); } bufptr = buf; bufcnt = linewidth; } } else { /* * In this case, it's not a clear code or an ending * code, so it must be a code code... So we can now * decode the code into a stack of character codes. * (Clear as mud, right?) */ code = c; /* * Here we go again with one of those off chances... * If, on the off chance, the code we got is beyond * the range of those already set up (Another thing * which had better NOT happen...) we trick the * decoder into thinking it actually got the last * code read. (Hmmn... I'm not sure why this works... * But it does...) */ if (code >= slot) { if (code > slot) ++bad_code_count; code = oc; *sp++ = fc; } /* * Here we scan back along the linked list of * prefixes, pushing helpless characters (ie. * suffixes) onto the stack as we do so. */ while (code >= newcodes) { *sp++ = suffix[code]; code = prefix[code]; } /* * Push the last character on the stack, and set up * the new prefix and suffix, and if the required * slot number is greater than that allowed by the * current bit size, increase the bit size. (NOTE - * If we are all full, we *don't* save the new suffix * and prefix... I'm not certain if this is * correct... it might be more proper to overwrite * the last code... */ *sp++ = code; if (slot < top_slot) { suffix[slot] = fc = code; prefix[slot++] = oc; oc = c; } if (slot >= top_slot) if (curr_size < 12) { top_slot <<= 1; ++curr_size; } /* * Now that we've pushed the decoded string (in * reverse order) onto the stack, lets pop it off and * put it into our decode buffer... And when the * decode buffer is full, write another line... */ while (sp > stack) { *bufptr++ = *(--sp); if (--bufcnt == 0) { if ((ret = gif_out_line(buf, linewidth)) < 0) { return (ret); } bufptr = buf; bufcnt = linewidth; } } } } ret = 0; if (bufcnt != linewidth) ret = gif_out_line(buf, (linewidth - bufcnt)); return (ret); }
int main(int argc, char **argv) { struct option long_options[] = { { "gpio", 1, 0, 0 }, { "address", 1, 0, 0 }, { "command", 1, 0, 0 }, { NULL, 0, 0, 0 } }; unsigned char key; unsigned short address = 0; unsigned short code = 0; long int a2i; int gpio = -1, i, c; char command = UNKNOWN; char *progname, *end; if (setuid(0)) { perror("setuid"); return -1; } while (1) { c = getopt_long(argc, argv, "", long_options, &i); if (c == -1) break; switch (c) { case 0: if (strcmp(long_options[i].name, "gpio") == 0) { a2i = strtol(optarg, &end, 10); if (errno == ERANGE && (a2i == LONG_MAX || a2i == LONG_MIN)) { break; } gpio = a2i; } else if (strcmp(long_options[i].name, "address") == 0) { a2i = strtol(optarg, &end, 10); if (errno == ERANGE && (a2i == LONG_MAX || a2i == LONG_MIN)) { break; } address = a2i; } else if (strcmp(long_options[i].name, "command") == 0) { command = get_command_char(optarg); } break; default: usage(argv[0]); } } if (command == UNKNOWN || address == 0 || gpio == -1) { usage(argv[0]); } // store pid and lock it store_pid(); srand(time(NULL)); key = rand() % 255; if (wiringPiSetup() == -1) { fprintf(stderr, "Wiring Pi not installed"); return -1; } openlog("srts", LOG_PID | LOG_CONS, LOG_USER); progname = basename(argv[0]); code = get_next_code(progname, address); syslog(LOG_INFO, "remote: %d, command: %d, code: %d\n", address, command, code); closelog(); piHiPri (99); pinMode(gpio, OUTPUT); srts_transmit(gpio, key, address, command, code, 0); c = 7; if (command == PROG) { c = 20; } for (i = 0; i < c; i++) { srts_transmit(gpio, key, address, command, code, 1); } store_code(progname, address, code); return 0; }
ILboolean GifGetData(ILimage *Image, ILubyte *Data, ILuint ImageSize, ILuint Width, ILuint Height, ILuint Stride, ILuint PalOffset, GFXCONTROL *Gfx) { ILubyte *sp; ILint code, fc, oc; ILubyte DisposalMethod = 0; ILint c, size; ILuint i = 0, Read = 0, j = 0; ILubyte *DataPtr = Data; if (!Gfx->Used) DisposalMethod = (Gfx->Packed & 0x1C) >> 2; if((size = igetc()) == IL_EOF) return IL_FALSE; if (size < 2 || 9 < size) { return IL_FALSE; } stack = (ILubyte*)ialloc(MAX_CODES + 1); suffix = (ILubyte*)ialloc(MAX_CODES + 1); prefix = (ILshort*)ialloc(sizeof(*prefix) * (MAX_CODES + 1)); if (!stack || !suffix || !prefix) { cleanUpGifLoadState(); return IL_FALSE; } curr_size = size + 1; top_slot = 1 << curr_size; clear = 1 << size; ending = clear + 1; slot = newcodes = ending + 1; navail_bytes = nbits_left = 0; oc = fc = 0; sp = stack; while ((c = get_next_code()) != ending && Read < Height) { if (c == clear) { curr_size = size + 1; slot = newcodes; top_slot = 1 << curr_size; while ((c = get_next_code()) == clear); if (c == ending) break; if (c >= slot) c = 0; oc = fc = c; if (DisposalMethod == 1 && !Gfx->Used && Gfx->Transparent == c && (Gfx->Packed & 0x1) != 0) i++; else if (i < Width) DataPtr[i++] = c + PalOffset; if (i == Width) { DataPtr += Stride; i = 0; Read += 1; ++j; if (j >= Height) { cleanUpGifLoadState(); return IL_FALSE; } } } else { code = c; //BG-2007-01-10: several fixes for incomplete GIFs if (code >= slot) { code = oc; if (sp >= stack + MAX_CODES) { cleanUpGifLoadState(); return IL_FALSE; } *sp++ = fc; } if (code >= MAX_CODES) return IL_FALSE; while (code >= newcodes) { if (sp >= stack + MAX_CODES) { cleanUpGifLoadState(); return IL_FALSE; } *sp++ = suffix[code]; code = prefix[code]; } if (sp >= stack + MAX_CODES) { cleanUpGifLoadState(); return IL_FALSE; } *sp++ = (ILbyte)code; if (slot < top_slot) { fc = code; suffix[slot] = fc; prefix[slot++] = oc; oc = c; } if (slot >= top_slot && curr_size < 12) { top_slot <<= 1; curr_size++; } while (sp > stack) { sp--; if (DisposalMethod == 1 && !Gfx->Used && Gfx->Transparent == *sp && (Gfx->Packed & 0x1) != 0) i++; else if (i < Width) DataPtr[i++] = *sp + PalOffset; if (i == Width) { i = 0; Read += 1; j = (j+1) % Height; // Needs to start from Data, not Image->Data. DataPtr = Data + j * Stride; } } } } cleanUpGifLoadState(); return IL_TRUE; }
// Decode a single DU within an MCU int decode_du(byte id_component) { word bit_string = 0; byte cur_code = 0; memset(iceenv.block, 0, sizeof(int) * 64); jpeg_huffman_table cur_table = iceenv.huff_dc[UPR4(iceenv.components[id_component].id_dht)]; cur_code = get_next_code(cur_table); #ifdef _JPEG_DEBUG printf("Code found: %X\n", cur_code); #endif bit_string = fetch_bits(cur_code); #ifdef _JPEG_DEBUG printf("Bits fetched: %d\n", bit_string); #endif short value = get_signed_short(bit_string, cur_code); iceenv.components[id_component].prev_dc += value; //mcu->dus[id_component][(y*samp_x) + x][0] = cur_mcu > 0 ? (mcus[cur_mcu - 1].dus[id_component][(y*samp_x) + x][0] + dc_value) : dc_value; iceenv.block[0] = iceenv.components[id_component].prev_dc; #ifdef _JPEG_DEBUG printf("DC value: %d, absolute value: %d\n", block[0], value); #endif // Dequantize DC value iceenv.block[0] *= iceenv.qt_tables[iceenv.components[id_component].qt_table][0]; // Switch to AC table cur_table = iceenv.huff_ac[LWR4(iceenv.components[id_component].id_dht)]; byte block_index = 1; int had_eob = 0; while (block_index < 64) { cur_code = get_next_code(cur_table); if (cur_code == 0) { #ifdef _JPEG_DEBUG printf("\tEOB encountered\n"); #endif had_eob = 1; break; } #ifdef _JPEG_DEBUG printf("\tSkipping %d zeros\n", (cur_code & 0xF0) >> 4); #endif // Skip zeros block_index += UPR4(cur_code); if (block_index > 63) break; bit_string = fetch_bits(LWR4(cur_code)); #ifdef _JPEG_DEBUG printf("Fetched %d bits\n", cur_code & 0xF); #endif value = get_signed_short(bit_string, LWR4(cur_code)); #ifdef _JPEG_DEBUG printf("AC value: %d\n", value); #endif byte actual_index = jpeg_zzright[block_index]; // Dequantize and unzigzag at the same time iceenv.block[actual_index] = value * iceenv.qt_tables[iceenv.components[id_component].qt_table][block_index]; block_index++; #ifdef _JPEG_DEBUG printf("Dequantized AC value: %d\n", block[actual_index]); #endif } if (block_index > 64) { printf("CAUTION: Too many coefs in MCU [%d,%d]\n", iceenv.cur_mcu_x, iceenv.cur_mcu_y); getc(stdin); } #ifdef _JPEG_DEBUG printf("\n"); #endif /****************************************************/ /* Perform IDCT */ /****************************************************/ int rowscols; for (rowscols = 0; rowscols < 8; rowscols++) { idctrow(&iceenv.block[8 * rowscols]); } for (rowscols = 0; rowscols < 8; rowscols++) { int targetPos = ((iceenv.cur_mcu_y * (iceenv.components[id_component].sy << 3) + (iceenv.cur_du_y << 3)) * iceenv.components[id_component].stride) + (iceenv.cur_mcu_x * (iceenv.components[id_component].sx << 3) + (iceenv.cur_du_x << 3)); idctcol(&iceenv.block[rowscols], &iceenv.components[id_component].pixels[targetPos + rowscols], iceenv.components[id_component].stride); } return ERR_OK; }
ILboolean GifGetData(ILimage *Image, ILubyte *Data, ILuint ImageSize, ILuint OffX, ILuint OffY, ILuint Width, ILuint Height, ILuint Stride, GFXCONTROL *Gfx) { GifLoadState state; ILint code, fc, oc; ILubyte DisposalMethod = 0; ILint c, size; ILuint x = OffX, Read = 0, y = OffY; ILuint dataOffset = y * Stride + x; state.navail_bytes = 0; state.nbits_left = 0; if (!Gfx->Used) DisposalMethod = (Gfx->Packed & 0x1C) >> 2; if((size = iCurImage->io.getc(iCurImage->io.handle)) == IL_EOF) return IL_FALSE; if (size < 2 || 9 < size) { return IL_FALSE; } state.curr_size = size + 1; state.top_slot = 1 << state.curr_size; state.clear = 1 << size; state.ending = state.clear + 1; state.slot = state.newcodes = state.ending + 1; state.navail_bytes = state.nbits_left = 0; oc = fc = 0; while ((c = get_next_code(&state)) != state.ending && Read < Height && state.isValid()) { if (c == state.clear) { state.curr_size = size + 1; state.slot = state.newcodes; state.top_slot = 1 << state.curr_size; while ((c = get_next_code(&state)) == state.clear); if (c == state.ending) break; if (c >= state.slot) c = 0; oc = fc = c; if (DisposalMethod == 1 && !Gfx->Used && Gfx->Transparent == c && (Gfx->Packed & 0x1) != 0) x++; else if (x < Width) { Data[dataOffset+x] = c; ++x; } if (x >= Width) { //DataPtr += Stride; x = 0; Read += 1; ++y; dataOffset = y * Stride + OffX; if (y >= Height) { return IL_FALSE; } } } else { code = c; //BG-2007-01-10: several fixes for incomplete GIFs if (code >= state.slot) { code = oc; if (!state.stackIndexLegal()) { return IL_FALSE; } state.push(fc); } if (code >= MAX_CODES) return IL_FALSE; while (code >= state.newcodes) { if (!state.stackIndexLegal()) { return IL_FALSE; } state.push(state.getSuffix(code)); code = state.getPrefix(code); } if (!state.stackIndexLegal()) { return IL_FALSE; } state.push((ILbyte)code); if (state.slot < state.top_slot) { fc = code; state.setSuffix(fc); state.setPrefix(oc); oc = c; } if (state.slot >= state.top_slot && state.curr_size < 12) { state.top_slot <<= 1; state.curr_size++; } while (state.getStackIndex() > 0) { state.pop(); if (DisposalMethod == 1 && !Gfx->Used && Gfx->Transparent == state.getStack() && (Gfx->Packed & 0x1) != 0) { x++; } else if (x < Width) { Data[dataOffset+x] = state.getStack(); x++; } if (x >= Width) // end of line { x = OffX % Width; Read += 1; y = (y+1) % Height; // Needs to start from Data, not Image->Data. dataOffset = y * Stride + OffX; } } } } return state.isValid(); }
short decoder (int i_linewidth) { short linewidth; FAST UTINY *sp, *bufptr; UTINY *buf; FAST short code, fc, oc, bufcnt; short c, size, ret; linewidth = (short)i_linewidth; /* Initialize for decoding a new image... */ if ((size = gif_get_byte()) < 0) return(size); if (size < 2 || 9 < size) return(BAD_CODE_SIZE); init_exp((int)size); /* changed param to int */ dstack = (UTINY *)POV_MALLOC((MAX_CODES + 1)*sizeof(UTINY), "GIF dstack"); suffix = (UTINY *)POV_MALLOC((MAX_CODES + 1)*sizeof(UTINY), "GIF suffix"); prefix = (UWORD *)POV_MALLOC((MAX_CODES + 1)*sizeof(UWORD), "GIF prefix"); /* Initialize in case they forgot to put in a clear code. * (This shouldn't happen, but we'll try and decode it anyway...) */ oc = fc = 0; buf = decoderline; bad_code_count = 0; /* Set up the stack pointer and decode buffer pointer */ sp = dstack; bufptr = buf; bufcnt = linewidth; /* This is the main loop. For each code we get we pass through the * linked list of prefix codes, pushing the corresponding "character" for * each code onto the stack. When the list reaches a single "character" * we push that on the stack too, and then start unstacking each * character for output in the correct order. Special handling is * included for the clear code, and the whole thing ends when we get * an ending code. */ while ((c = get_next_code()) != ending) { Do_Cooperate(0); /* If we had a file error, return without completing the decode */ if (c < 0) { cleanup_gif_decoder(); return(0); } /* If the code is a clear code, reinitialize all necessary items. */ if (c == clear_code) { curr_size = size + 1; slot = newcodes; top_slot = 1 << curr_size; /* Continue reading codes until we get a non-clear code * (Another unlikely, but possible case...) */ while ((c = get_next_code()) == clear_code) ; /* If we get an ending code immediately after a clear code * (Yet another unlikely case), then break out of the loop. */ if (c == ending) break; /* Finally, if the code is beyond the range of already set codes, * (This one had better NOT happen... I have no idea what will * result from this, but I doubt it will look good...) then set it * to color zero. */ if (c >= slot) c = 0; oc = fc = c; /* And let us not forget to put the char into the buffer... And * if, on the off chance, we were exactly one pixel from the end * of the line, we have to send the buffer to the out_line() * routine... */ *bufptr++ = (UTINY) c; if (--bufcnt == 0) { Do_Cooperate(1); if ((ret = out_line(buf, linewidth)) < 0) { cleanup_gif_decoder(); return(ret); } bufptr = buf; bufcnt = linewidth; } } else { /* In this case, it's not a clear code or an ending code, so * it must be a code code... So we can now decode the code into * a stack of character codes. (Clear as mud, right?) */ code = c; /* Here we go again with one of those off chances... If, on the * off chance, the code we got is beyond the range of those already * set up (Another thing which had better NOT happen...) we trick * the decoder into thinking it actually got the last code read. * (Hmmn... I'm not sure why this works... But it does...) */ if (code >= slot) { if (code > slot) ++bad_code_count; code = oc; *sp++ = (UTINY) fc; } /* Here we scan back along the linked list of prefixes, pushing * helpless characters (ie. suffixes) onto the stack as we do so. */ while (code >= newcodes) { *sp++ = suffix[code]; code = prefix[code]; } /* Push the last character on the stack, and set up the new * prefix and suffix, and if the required slot number is greater * than that allowed by the current bit size, increase the bit * size. (NOTE - If we are all full, we *don't* save the new * suffix and prefix... I'm not certain if this is correct... * it might be more proper to overwrite the last code... */ *sp++ = (UTINY) code; if (slot < top_slot) { fc = code; suffix[slot] = (UTINY) fc; prefix[slot++] = oc; oc = c; } if (slot >= top_slot) if (curr_size < 12) { top_slot <<= 1; ++curr_size; } /* Now that we've pushed the decoded string (in reverse order) * onto the stack, lets pop it off and put it into our decode * buffer... And when the decode buffer is full, write another * line... */ while (sp > dstack) { *bufptr++ = *(--sp); if (--bufcnt == 0) { Do_Cooperate(1); if ((ret = out_line(buf, linewidth)) < 0) { cleanup_gif_decoder(); return(ret); } bufptr = buf; bufcnt = linewidth; } } } } ret = 0; if (bufcnt != linewidth) ret = out_line(buf, (linewidth - bufcnt)); cleanup_gif_decoder(); return(ret); }
short LZWReader::Decoder() { BYTE *sp, *bufptr; BYTE *buf; DWORD bufcnt; int c, oc, fc, code, size; /* Initialize for decoding a new image... */ /*if ((size = get_byte()) < 0) return (size); if (size < 2 || 9 < size) return (BAD_CODE_SIZE);*/ size = 8; init_exp(size); /* Initialize in case they forgot to put in a clear code. * (This shouldn't happen, but we'll try and decode it anyway...) */ oc = fc = 0; /* Allocate space for the decode buffer */ buf = NextLine(); /* Set up the stack pointer and decode buffer pointer */ sp = stack; bufptr = buf; bufcnt = m_width; /* This is the main loop. For each code we get we pass through the * linked list of prefix codes, pushing the corresponding "character" for * each code onto the stack. When the list reaches a single "character" * we push that on the stack too, and then start unstacking each * character for output in the correct order. Special handling is * included for the clear code, and the whole thing ends when we get * an ending code. */ while ((c = get_next_code()) != ending) { /* If we had a file error, return without completing the decode */ if (c < 0) { break; //return (0); } /* If the code is a clear code, reinitialize all necessary items. */ if (c == clear) { curr_size = size + 1; slot = newcodes; top_slot = 1 << curr_size; /* Continue reading codes until we get a non-clear code * (Another unlikely, but possible case...) */ while ((c = get_next_code()) == clear) ; /* If we get an ending code immediately after a clear code * (Yet another unlikely case), then break out of the loop. */ if (c == ending) break; /* Finally, if the code is beyond the range of already set codes, * (This one had better NOT happen... I have no idea what will * result from this, but I doubt it will look good...) then set it * to color zero. */ if (c >= slot) c = 0; oc = fc = c; /* And let us not forget to put the char into the buffer... And * if, on the off chance, we were exactly one pixel from the end * of the line, we have to send the buffer to the out_line() * routine... */ *bufptr++ = (BYTE) c; if (--bufcnt == 0) { buf = NextLine(); bufptr = buf; bufcnt = m_width; } } else { /* In this case, it's not a clear code or an ending code, so * it must be a code code... So we can now decode the code into * a stack of character codes. (Clear as mud, right?) */ code = c; /* Here we go again with one of those off chances... If, on the * off chance, the code we got is beyond the range of those already * set up (Another thing which had better NOT happen...) we trick * the decoder into thinking it actually got the last code read. * (Hmmn... I'm not sure why this works... But it does...) */ if (code >= slot) { if (code > slot) ++bad_code_count; code = oc; *sp++ = (BYTE) fc; } /* Here we scan back along the linked list of prefixes, pushing * helpless characters (ie. suffixes) onto the stack as we do so. */ while (code >= newcodes) { *sp++ = suffix[code]; code = prefix[code]; } /* Push the last character on the stack, and set up the new * prefix and suffix, and if the required slot number is greater * than that allowed by the current bit size, increase the bit * size. (NOTE - If we are all full, we *don't* save the new * suffix and prefix... I'm not certain if this is correct... * it might be more proper to overwrite the last code... */ *sp++ = (BYTE) code; if (slot < top_slot) { fc = code; suffix[slot] = (BYTE) fc; // = code; prefix[slot++] = (WCHAR) oc; oc = c; } if (slot >= top_slot) if (curr_size < 12) { top_slot <<= 1; ++curr_size; } /* Now that we've pushed the decoded string (in reverse order) * onto the stack, lets pop it off and put it into our decode * buffer... And when the decode buffer is full, write another * line... */ while (sp > stack) { *bufptr++ = *(--sp); if (--bufcnt == 0) { buf = NextLine(); bufptr = buf; bufcnt = m_width; } } } } // BUG - is all this necessary? Is it correct? int toofar = m_readahead - m_cfilebuffer; // bytes we already read that we shouldn't have toofar--; // m_readahead == the byte we just read, so we actually used up one more than the math shows LARGE_INTEGER li; li.QuadPart = -toofar; m_pstm->Seek(li, STREAM_SEEK_CUR, NULL); return (0); }