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;
}
