void amqp_dump(void const *buffer, size_t len) { unsigned char *buf = (unsigned char *) buffer; long count = 0; int numinrow = 0; int chs[16]; int oldchs[16] = {0}; int showed_dots = 0; size_t i; for (i = 0; i < len; i++) { int ch = buf[i]; if (numinrow == 16) { int i; if (rows_eq(oldchs, chs)) { if (!showed_dots) { showed_dots = 1; printf(" .. .. .. .. .. .. .. .. : .. .. .. .. .. .. .. ..\n"); } } else { showed_dots = 0; dump_row(count, numinrow, chs); } for (i=0; i<16; i++) { oldchs[i] = chs[i]; } numinrow = 0; } count++; chs[numinrow++] = ch; } dump_row(count, numinrow, chs); if (numinrow != 0) { printf("%08lX:\n", count); } }
static int get_next_line(void) { char *p; nBuffer = 0; nTokenStart = -1; nTokenNextStart = 1; eof = false; p = fgets(buffer, lMaxBuffer, file); if (p == NULL) { if (ferror(file)) return -1; eof = true; return 1; } nRow += 1; lBuffer = strlen(buffer); if(debug){ dump_row(); } return 0; }
static void dump_tables (const basic_state_machine<char_type, id_type> &sm_, const std::size_t tabs_, const bool pointers_, std::ostream &os_) { const typename detail::basic_internals<id_type> &internals_ = sm_.data (); const std::size_t lookup_divisor_ = 8; // Lookup is always 256 entries long now const std::size_t lookup_quotient_ = 256 / lookup_divisor_; const std::size_t dfas_ = internals_._lookup->size (); std::size_t col_ = 1; std::size_t row_ = 1; output_tabs (tabs_, os_); os_ << "static const id_type lookup"; if (dfas_ > 1) { os_ << "s_[][" << 256; } else { os_ << "_["; } os_ << "] = \n"; output_tabs (tabs_ + 1, os_); if (dfas_ > 1) { os_ << '{'; } for (std::size_t l_ = 0; l_ < dfas_; ++l_) { const id_type *ptr_ = &internals_._lookup[l_]->front (); // We want numbers regardless of id_type. os_ << "{0x" << std::hex << static_cast<std::size_t>(*ptr_++); for (col_ = 1; col_ < lookup_divisor_; ++col_) { // We want numbers regardless of id_type. os_ << ", 0x" << std::hex << static_cast<std::size_t>(*ptr_++); } for (row_ = 1; row_ < lookup_quotient_; ++row_) { os_ << ",\n"; output_tabs (tabs_ + 1, os_); // We want numbers regardless of id_type. os_ << "0x" << std::hex << static_cast<std::size_t>(*ptr_++); for (col_ = 1; col_ < lookup_divisor_; ++col_) { // We want numbers regardless of id_type. os_ << ", 0x" << std::hex << static_cast<std::size_t>(*ptr_++); } } os_ << '}'; if (l_ + 1 < dfas_) { os_ << ",\n"; output_tabs (tabs_ + 1, os_); } } if (dfas_ > 1) { os_ << '}'; } os_ << ";\n"; output_tabs (tabs_, os_); os_ << "static const id_type dfa_alphabet"; if (dfas_ > 1) { os_ << "s_[" << dfas_ << "] = {"; } else { os_ << "_ = "; } // We want numbers regardless of id_type. os_ << "0x" << std::hex << static_cast<std::size_t> (internals_._dfa_alphabet[0]); for (col_ = 1; col_ < dfas_; ++col_) { // We want numbers regardless of id_type. os_ << ", 0x" << std::hex << static_cast<std::size_t>(internals_. _dfa_alphabet[col_]); } if (dfas_ > 1) { os_ << '}'; } os_ << ";\n"; // DFAs are usually different sizes, so dump separately for (std::size_t dfa_ = 0; dfa_ < dfas_; ++dfa_) { const id_type dfa_alphabet_ = internals_._dfa_alphabet[dfa_]; const std::size_t rows_ = internals_._dfa[dfa_]->size () / dfa_alphabet_; const id_type *ptr_ = &internals_._dfa[dfa_]->front (); std::string dfa_name_ = "dfa"; output_tabs (tabs_, os_); os_ << "static const "; if (pointers_) { os_ << "void *"; } else { os_ << "id_type "; } os_ << dfa_name_; if (dfas_ > 1) { std::ostringstream ss_; ss_ << dfa_; dfa_name_ += ss_.str (); os_ << dfa_; } dfa_name_ += '_'; os_ << "_[] = {"; for (std::size_t row_ = 0; row_ < rows_; ++row_) { dump_row (row_ == 0, ptr_, dfa_name_, dfa_alphabet_, pointers_, os_); if (row_ + 1 < rows_) { os_ << ",\n"; output_tabs (tabs_ + 1, os_); } } os_ << "};\n"; } if (dfas_ > 1) { output_tabs (tabs_, os_); os_ << "static const "; if (pointers_) { os_ << "void * const"; } else { os_ << "id_type"; } os_ << " *dfas_[] = {dfa0_"; for (col_ = 1; col_ < dfas_; ++col_) { os_ << ", dfa" << col_ << '_'; } os_ << "};\n"; } }
void bin_diff(const int verbose, const char *oldn, const char *newn, const char *outf) { FILE *out; int oldh, newh; unsigned long olds, news; int oldr, newr; time_t clock; struct MD5Context md5c; unsigned char checksum[16]; char *oldb, *newb, *oldrow = NULL, *newrow; unsigned long now, pos, last = -2; int i; unsigned long rowidx = 0; int rowlen = 0; int len; char *basename; if ((oldh = open(oldn, O_RDONLY | O_BINARY, 0644)) == -1) { perror(oldn); return; } if ((newh = open(newn, O_RDONLY | O_BINARY, 0644)) == -1) { perror(newn); return; } get_size(oldh, olds); get_size(newh, news); if (olds <= 0 || news <= 0) { perror("get file size"); return; } if (olds != news) { fprintf(stderr, "can't compare files with different sizes!\n"); return; } if ((out = fopen(outf, "wt")) == NULL) { perror("output"); return; } MD5Init(&md5c); oldb = (char *) malloc(BUFSIZE); newb = (char *) malloc(BUFSIZE); newrow = (char *) malloc(LINELEN); if (verbose) oldrow = (char *) malloc(LINELEN); // groovy ;) for ( \ basename = (char *) oldn + strlen(oldn); \ basename > oldn && !(crk_isslash(*basename) && basename++); \ basename-- \ ); fprintf(out, "[%-32s %s]\n", "", basename); time(&clock); fprintf(out, "# Patch generated at %s", asctime(localtime(&clock))); do { now = lseek(oldh, 0, SEEK_CUR); oldr = read(oldh, oldb, BUFSIZE); newr = read(newh, newb, BUFSIZE); if (oldr != newr) { set_me_free(); perror("compare"); return; } MD5Update(&md5c, oldb, oldr); for (i = 0; i < oldr; i++) { if (oldb[i] != newb[i]) { pos = now + i; if (pos - last != 1 || rowlen >= LINELEN) { dump_row(out, rowidx, oldrow, newrow, rowlen); rowidx = pos; rowlen = 0; } if (oldrow != NULL) oldrow[rowlen] = oldb[i]; newrow[rowlen++] = newb[i]; last = pos; } } } while (newr != 0); dump_row(out, rowidx, oldrow, newrow, rowlen); MD5Final(checksum, &md5c); set_me_free(); fprintf(out, "# Patch length: %-8s", ""); len = ftell(out); fseek(out, -8, SEEK_END); fprintf(out, "%08x", len); fseek(out, 1, SEEK_SET); for (i = 0; i < 16; i++) fprintf(out, "%02x", checksum[i]); fclose(out); return; }