const char *mkpath(const char *fmt, ...)
{
va_list args;
struct strbuf *pathname = get_pathname();
va_start(args, fmt);
strbuf_vaddf(pathname, fmt, args);
va_end(args);
return cleanup_path(pathname->buf);
}
static void
show_sharedir(bool all)
{
char path[MAXPGPATH];
if (all)
printf("SHAREDIR = ");
get_share_path(mypath, path);
cleanup_path(path);
printf("%s\n", path);
}
static void
show_sysconfdir(bool all)
{
char path[MAXPGPATH];
if (all)
printf("SYSCONFDIR = ");
get_etc_path(mypath, path);
cleanup_path(path);
printf("%s\n", path);
}
static void
show_localedir(bool all)
{
char path[MAXPGPATH];
if (all)
printf("LOCALEDIR = ");
get_locale_path(mypath, path);
cleanup_path(path);
printf("%s\n", path);
}
static void
show_mandir(bool all)
{
char path[MAXPGPATH];
if (all)
printf("MANDIR = ");
get_man_path(mypath, path);
cleanup_path(path);
printf("%s\n", path);
}
static void
show_pkglibdir(bool all)
{
char path[MAXPGPATH];
if (all)
printf("PKGLIBDIR = ");
get_pkglib_path(mypath, path);
cleanup_path(path);
printf("%s\n", path);
}
static void
show_includedir_server(bool all)
{
char path[MAXPGPATH];
if (all)
printf("INCLUDEDIR-SERVER = ");
get_includeserver_path(mypath, path);
cleanup_path(path);
printf("%s\n", path);
}
static void
show_pkgincludedir(bool all)
{
char path[MAXPGPATH];
if (all)
printf("PKGINCLUDEDIR = ");
get_pkginclude_path(mypath, path);
cleanup_path(path);
printf("%s\n", path);
}
static void
show_htmldir(bool all)
{
char path[MAXPGPATH];
if (all)
printf("HTMLDIR = ");
get_html_path(mypath, path);
cleanup_path(path);
printf("%s\n", path);
}
static void
show_docdir(bool all)
{
char path[MAXPGPATH];
if (all)
printf("DOCDIR = ");
get_doc_path(mypath, path);
cleanup_path(path);
printf("%s\n", path);
}
static void
show_pgxs(bool all)
{
char path[MAXPGPATH];
if (all)
printf("PGXS = ");
get_pkglib_path(mypath, path);
strlcat(path, "/pgxs/src/makefiles/pgxs.mk", sizeof(path));
cleanup_path(path);
printf("%s\n", path);
}
char *mkpath(const char *fmt, ...)
{
va_list args;
unsigned len;
char *pathname = get_pathname();
va_start(args, fmt);
len = vsnprintf(pathname, PATH_MAX, fmt, args);
va_end(args);
if (len >= PATH_MAX)
return bad_path;
return cleanup_path(pathname);
}
char *mksnpath(char *buf, size_t n, const char *fmt, ...)
{
va_list args;
unsigned len;
va_start(args, fmt);
len = vsnprintf(buf, n, fmt, args);
va_end(args);
if (len >= n) {
strlcpy(buf, bad_path, n);
return buf;
}
return cleanup_path(buf);
}
char *mkpathdup(const char *fmt, ...)
{
char *path;
struct strbuf sb = STRBUF_INIT;
va_list args;
va_start(args, fmt);
strbuf_vaddf(&sb, fmt, args);
va_end(args);
path = xstrdup(cleanup_path(sb.buf));
strbuf_release(&sb);
return path;
}
static void
show_bindir(bool all)
{
char path[MAXPGPATH];
char *lastsep;
if (all)
printf("BINDIR = ");
/* assume we are located in the bindir */
strcpy(path, mypath);
lastsep = strrchr(path, '/');
if (lastsep)
*lastsep = '\0';
cleanup_path(path);
printf("%s\n", path);
}
static char *git_vsnpath(char *buf, size_t n, const char *fmt, va_list args)
{
const char *git_dir = get_git_dir();
size_t len;
len = strlen(git_dir);
if (n < len + 1)
goto bad;
memcpy(buf, git_dir, len);
if (len && !is_dir_sep(git_dir[len-1]))
buf[len++] = '/';
len += vsnprintf(buf + len, n - len, fmt, args);
if (len >= n)
goto bad;
return cleanup_path(buf);
bad:
strlcpy(buf, bad_path, n);
return buf;
}
char *git_path(const char *fmt, ...)
{
const char *git_dir = get_git_dir();
char *pathname = get_pathname();
va_list args;
unsigned len;
len = strlen(git_dir);
if (len > PATH_MAX-100)
return bad_path;
memcpy(pathname, git_dir, len);
if (len && git_dir[len-1] != '/')
pathname[len++] = '/';
va_start(args, fmt);
len += vsnprintf(pathname + len, PATH_MAX - len, fmt, args);
va_end(args);
if (len >= PATH_MAX)
return bad_path;
return cleanup_path(pathname);
}
char *git_path_submodule(const char *path, const char *fmt, ...)
{
char *pathname = get_pathname();
struct strbuf buf = STRBUF_INIT;
const char *git_dir;
va_list args;
unsigned len;
len = strlen(path);
if (len > PATH_MAX-100)
return bad_path;
strbuf_addstr(&buf, path);
if (len && path[len-1] != '/')
strbuf_addch(&buf, '/');
strbuf_addstr(&buf, ".git");
git_dir = read_gitfile(buf.buf);
if (git_dir) {
strbuf_reset(&buf);
strbuf_addstr(&buf, git_dir);
}
strbuf_addch(&buf, '/');
if (buf.len >= PATH_MAX)
return bad_path;
memcpy(pathname, buf.buf, buf.len + 1);
strbuf_release(&buf);
len = strlen(pathname);
va_start(args, fmt);
len += vsnprintf(pathname + len, PATH_MAX - len, fmt, args);
va_end(args);
if (len >= PATH_MAX)
return bad_path;
return cleanup_path(pathname);
}
/*
* get_configdata(const char *my_exec_path, size_t *configdata_len)
*
* Get configure-time constants. The caller is responsible
* for pfreeing the result.
*/
ConfigData *
get_configdata(const char *my_exec_path, size_t *configdata_len)
{
ConfigData *configdata;
char path[MAXPGPATH];
char *lastsep;
int i = 0;
/* Adjust this to match the number of items filled below */
*configdata_len = 23;
configdata = (ConfigData *) palloc(*configdata_len * sizeof(ConfigData));
configdata[i].name = pstrdup("BINDIR");
strlcpy(path, my_exec_path, sizeof(path));
lastsep = strrchr(path, '/');
if (lastsep)
*lastsep = '\0';
cleanup_path(path);
configdata[i].setting = pstrdup(path);
i++;
configdata[i].name = pstrdup("DOCDIR");
get_doc_path(my_exec_path, path);
cleanup_path(path);
configdata[i].setting = pstrdup(path);
i++;
configdata[i].name = pstrdup("HTMLDIR");
get_html_path(my_exec_path, path);
cleanup_path(path);
configdata[i].setting = pstrdup(path);
i++;
configdata[i].name = pstrdup("INCLUDEDIR");
get_include_path(my_exec_path, path);
cleanup_path(path);
configdata[i].setting = pstrdup(path);
i++;
configdata[i].name = pstrdup("PKGINCLUDEDIR");
get_pkginclude_path(my_exec_path, path);
cleanup_path(path);
configdata[i].setting = pstrdup(path);
i++;
configdata[i].name = pstrdup("INCLUDEDIR-SERVER");
get_includeserver_path(my_exec_path, path);
cleanup_path(path);
configdata[i].setting = pstrdup(path);
i++;
configdata[i].name = pstrdup("LIBDIR");
get_lib_path(my_exec_path, path);
cleanup_path(path);
configdata[i].setting = pstrdup(path);
i++;
configdata[i].name = pstrdup("PKGLIBDIR");
get_pkglib_path(my_exec_path, path);
cleanup_path(path);
configdata[i].setting = pstrdup(path);
i++;
configdata[i].name = pstrdup("LOCALEDIR");
get_locale_path(my_exec_path, path);
cleanup_path(path);
configdata[i].setting = pstrdup(path);
i++;
configdata[i].name = pstrdup("MANDIR");
get_man_path(my_exec_path, path);
cleanup_path(path);
configdata[i].setting = pstrdup(path);
i++;
configdata[i].name = pstrdup("SHAREDIR");
get_share_path(my_exec_path, path);
cleanup_path(path);
configdata[i].setting = pstrdup(path);
i++;
configdata[i].name = pstrdup("SYSCONFDIR");
get_etc_path(my_exec_path, path);
cleanup_path(path);
configdata[i].setting = pstrdup(path);
i++;
configdata[i].name = pstrdup("PGXS");
get_pkglib_path(my_exec_path, path);
strlcat(path, "/pgxs/src/makefiles/pgxs.mk", sizeof(path));
cleanup_path(path);
configdata[i].setting = pstrdup(path);
i++;
configdata[i].name = pstrdup("CONFIGURE");
#ifdef VAL_CONFIGURE
configdata[i].setting = pstrdup(VAL_CONFIGURE);
#else
configdata[i].setting = pstrdup(_("not recorded"));
#endif
i++;
configdata[i].name = pstrdup("CC");
#ifdef VAL_CC
configdata[i].setting = pstrdup(VAL_CC);
#else
configdata[i].setting = pstrdup(_("not recorded"));
#endif
i++;
configdata[i].name = pstrdup("CPPFLAGS");
#ifdef VAL_CPPFLAGS
configdata[i].setting = pstrdup(VAL_CPPFLAGS);
#else
configdata[i].setting = pstrdup(_("not recorded"));
#endif
i++;
configdata[i].name = pstrdup("CFLAGS");
#ifdef VAL_CFLAGS
configdata[i].setting = pstrdup(VAL_CFLAGS);
#else
configdata[i].setting = pstrdup(_("not recorded"));
#endif
i++;
configdata[i].name = pstrdup("CFLAGS_SL");
#ifdef VAL_CFLAGS_SL
configdata[i].setting = pstrdup(VAL_CFLAGS_SL);
#else
configdata[i].setting = pstrdup(_("not recorded"));
#endif
i++;
configdata[i].name = pstrdup("LDFLAGS");
#ifdef VAL_LDFLAGS
configdata[i].setting = pstrdup(VAL_LDFLAGS);
#else
configdata[i].setting = pstrdup(_("not recorded"));
#endif
i++;
configdata[i].name = pstrdup("LDFLAGS_EX");
#ifdef VAL_LDFLAGS_EX
configdata[i].setting = pstrdup(VAL_LDFLAGS_EX);
#else
configdata[i].setting = pstrdup(_("not recorded"));
#endif
i++;
configdata[i].name = pstrdup("LDFLAGS_SL");
#ifdef VAL_LDFLAGS_SL
configdata[i].setting = pstrdup(VAL_LDFLAGS_SL);
#else
configdata[i].setting = pstrdup(_("not recorded"));
#endif
i++;
configdata[i].name = pstrdup("LIBS");
#ifdef VAL_LIBS
configdata[i].setting = pstrdup(VAL_LIBS);
#else
configdata[i].setting = pstrdup(_("not recorded"));
#endif
i++;
configdata[i].name = pstrdup("VERSION");
configdata[i].setting = pstrdup("PostgreSQL " PG_VERSION);
i++;
Assert(i == *configdata_len);
return configdata;
}
static void strbuf_cleanup_path(struct strbuf *sb)
{
char *path = cleanup_path(sb->buf);
if (path > sb->buf)
strbuf_remove(sb, 0, path - sb->buf);
}
int
main(int argc, char *argv[])
{
long pagesize, npages;
int c, ret;
char hw_provider[SYS_NMLN];
setpname(argv[0]);
opts.o_promdev = "/dev/openprom";
while ((c = getopt(argc, argv, optstring)) != -1) {
switch (c) {
case 'a':
++opts.o_ancestors;
break;
case 'b':
++opts.o_productinfo;
break;
case 'c':
++opts.o_children;
break;
case 'd':
++opts.o_pciid;
break;
case 'D':
++opts.o_drv_name;
break;
case 'v':
++opts.o_verbose;
break;
case 'm':
++opts.o_memory;
break;
case 'p':
++opts.o_prominfo;
break;
case 'f':
opts.o_promdev = optarg;
break;
case 'V':
++opts.o_promversion;
break;
case 'x':
++opts.o_prom_ready64;
break;
case 'F':
++opts.o_fbname;
++opts.o_noheader;
break;
case 'P':
++opts.o_pseudodevs;
break;
case 'C':
++opts.o_forcecache;
break;
#ifdef DEBUG
case 'M':
dbg.d_drivername = optarg;
++dbg.d_bydriver;
break;
case 'L':
++dbg.d_forceload;
break;
#endif /* DEBUG */
default:
(void) fprintf(stderr, usage, opts.o_progname);
return (1);
}
}
(void) uname(&opts.o_uts);
if (opts.o_fbname)
return (do_fbname());
if (opts.o_promversion)
return (do_promversion());
if (opts.o_prom_ready64)
return (do_prom_version64());
if (opts.o_productinfo)
return (do_productinfo());
opts.o_devices_path = NULL;
opts.o_devt = DDI_DEV_T_NONE;
opts.o_target = 0;
if (optind < argc) {
struct stat sinfo;
char *path = argv[optind];
int error;
if (opts.o_prominfo) {
/* PROM tree cannot be used with path */
(void) fprintf(stderr, "%s: path and -p option are "
"mutually exclusive\n", opts.o_progname);
return (1);
}
if (strlen(path) >= MAXPATHLEN) {
(void) fprintf(stderr, "%s: "
"path specified is too long\n", opts.o_progname);
return (1);
}
if (error = stat(path, &sinfo)) {
/* an invalid path was specified */
(void) fprintf(stderr, "%s: invalid path specified\n",
opts.o_progname);
return (1);
} else if (((sinfo.st_mode & S_IFMT) == S_IFCHR) ||
((sinfo.st_mode & S_IFMT) == S_IFBLK)) {
opts.o_devt = sinfo.st_rdev;
error = 0;
} else if ((sinfo.st_mode & S_IFMT) == S_IFDIR) {
size_t len, plen;
/* clean up the path */
cleanup_path(path, new_path);
len = strlen(new_path);
plen = strlen("/devices");
if (len < plen) {
/* This is not a valid /devices path */
error = 1;
} else if ((len == plen) &&
(strcmp(new_path, "/devices") == 0)) {
/* /devices is the root nexus */
opts.o_devices_path = "/";
error = 0;
} else if (strncmp(new_path, "/devices/", plen + 1)) {
/* This is not a valid /devices path */
error = 1;
} else {
/* a /devices/ path was specified */
opts.o_devices_path = new_path + plen;
error = 0;
}
} else {
/* an invalid device path was specified */
error = 1;
}
if (error) {
(void) fprintf(stderr, "%s: "
"invalid device path specified\n",
opts.o_progname);
return (1);
}
opts.o_target = 1;
}
if ((opts.o_ancestors || opts.o_children) && (!opts.o_target)) {
(void) fprintf(stderr, "%s: options require a device path\n",
opts.o_progname);
return (1);
}
if (opts.o_target) {
prtconf_devinfo();
return (0);
}
if (!opts.o_memory) {
ret = sysinfo(SI_HW_PROVIDER, hw_provider,
sizeof (hw_provider));
/*
* If 0 bytes are returned (the system returns '1', for the \0),
* we're probably on x86, and there has been no si-hw-provider
* set in /etc/bootrc, default to Joyent.
*/
if (ret <= 1) {
(void) strncpy(hw_provider, "Joyent",
sizeof (hw_provider));
}
(void) printf("System Configuration: %s %s\n", hw_provider,
opts.o_uts.machine);
}
pagesize = sysconf(_SC_PAGESIZE);
npages = sysconf(_SC_PHYS_PAGES);
if (pagesize == -1 || npages == -1)
if (opts.o_memory) {
(void) printf("0\n");
return (1);
} else {
(void) printf("Memory size: unable to determine\n");
}
else {
const int64_t kbyte = 1024;
const int64_t mbyte = 1024 * 1024;
int64_t ii = (int64_t)pagesize * npages;
if (opts.o_memory) {
(void) printf("%ld\n", (long)((ii+mbyte-1) / mbyte));
return (0);
} else {
(void) printf("Memory size: %ld Megabytes\n",
(long)((ii+mbyte-1) / mbyte));
}
}
if (opts.o_prominfo) {
(void) printf("System Peripherals (PROM Nodes):\n\n");
if (do_prominfo() == 0)
return (0);
(void) fprintf(stderr, "%s: Defaulting to non-PROM mode...\n",
opts.o_progname);
}
(void) printf("System Peripherals (Software Nodes):\n\n");
(void) prtconf_devinfo();
return (0);
}
static PyObject *Py_cleanup_path(PyObject *self, PyObject *args, PyObject *kwds)
{
py::PathIterator path;
agg::trans_affine trans;
bool remove_nans;
agg::rect_d clip_rect;
e_snap_mode snap_mode;
double stroke_width;
PyObject *simplifyobj;
bool simplify = false;
bool return_curves;
SketchParams sketch;
if (!PyArg_ParseTuple(args,
"O&O&O&O&O&dOO&O&:cleanup_path",
&convert_path,
&path,
&convert_trans_affine,
&trans,
&convert_bool,
&remove_nans,
&convert_rect,
&clip_rect,
&convert_snap,
&snap_mode,
&stroke_width,
&simplifyobj,
&convert_bool,
&return_curves,
&convert_sketch_params,
&sketch)) {
return NULL;
}
if (simplifyobj == Py_None) {
simplify = path.should_simplify();
} else if (PyObject_IsTrue(simplifyobj)) {
simplify = true;
}
bool do_clip = (clip_rect.x1 < clip_rect.x2 && clip_rect.y1 < clip_rect.y2);
std::vector<double> vertices;
std::vector<npy_uint8> codes;
CALL_CPP("cleanup_path",
(cleanup_path(path,
trans,
remove_nans,
do_clip,
clip_rect,
snap_mode,
stroke_width,
simplify,
return_curves,
sketch,
vertices,
codes)));
size_t length = codes.size();
npy_intp vertices_dims[] = {(npy_intp)length, 2 };
numpy::array_view<double, 2> pyvertices(vertices_dims);
npy_intp codes_dims[] = {(npy_intp)length };
numpy::array_view<unsigned char, 1> pycodes(codes_dims);
memcpy(pyvertices.data(), &vertices[0], sizeof(double) * 2 * length);
memcpy(pycodes.data(), &codes[0], sizeof(unsigned char) * length);
return Py_BuildValue("NN", pyvertices.pyobj(), pycodes.pyobj());
}
int collisionfinding(parameters_type& parameters)
{
bool usetunnelbitconditions = parameters.usetunnelbitconditions;
sha1messagespace tmpspace;
vector< vector<uint32> > bitrels, tmpbitrel, tmpbitrel2;
for (unsigned i = 0; i < parameters.rnd234_m_bitrelationfiles.size(); ++i) {
try {
cout << "Loading '" << parameters.rnd234_m_bitrelationfiles[i] << "'..." << flush;
load_bz2(tmpspace, text_archive, parameters.rnd234_m_bitrelationfiles[i]);
cout << "done" << flush;
tmpspace.tobitrelations_80(tmpbitrel);
bitrels.insert(bitrels.end(), tmpbitrel.begin(), tmpbitrel.end());
cout << " (" << tmpbitrel.size() << " bitrels, new total: " << bitrels.size() << ")" << endl;
} catch (std::exception& e) {
cerr << "Exception:" << endl << e.what() << endl;
return 1;
}
}
vector< sha1differentialpath > paths;
cout << "Loading round 1 paths from '" << parameters.rnd1_pathsfile << "'..." << flush;
try {
load_bz2(paths, text_archive, parameters.rnd1_pathsfile);
cout << "done (" << paths.size() << " paths)." << endl;
} catch (std::exception& e) {
cerr << "Exception:" << endl << e.what() << endl;
return 1;
}
if (paths.size() == 0) exit(0);
vector< vector<uint32> > bitrelsbu = bitrels;
for (unsigned pi = 0; pi < paths.size(); ++pi) { try {
bitrels = bitrelsbu;
sha1differentialpath upperpath;
cout << "Loading round 2,3,4 path from '" << parameters.rnd234_pathfile << "'..." << flush;
try {
load_bz2(upperpath, text_archive, parameters.rnd234_pathfile);
cout << "done." << endl;
} catch (std::exception& e) {
cerr << "Exception:" << endl << e.what() << endl;
return 1;
}
for (int t = paths[pi].tbegin(); t < paths[pi].tend(); ++t)
upperpath[t] = paths[pi][t];
for (unsigned t = 0; t < paths[pi].tend()-1; ++t)
upperpath.getme(t) = paths[pi].getme(t);
cleanup_path(upperpath);
maindiffpath = upperpath;
bool bad = false;
for (int t = maindiffpath.tbegin()+4; t < maindiffpath.tend()-1; ++t) {
if (maindiffpath.getme(t).mask != parameters.m_mask[t]) {
uint32 dm = maindiffpath.getme(t).adddiff();
uint32 mcur = 0;
uint32 mmask = parameters.m_mask[t];
uint32 madd = (~mmask)+1;
sdr msdr;
msdr.mask = mmask;
do {
mcur += madd; mcur &= mmask;
msdr.sign = mcur;
if (msdr.adddiff() == dm) {
cout << "corrected: \t" << t << ":\t" << msdr << " == " << sdr(parameters.m_mask[t]) << endl;
break;
}
} while (mcur != 0);
if (msdr.adddiff() == dm) {
maindiffpath.getme(t) = msdr;
} else {
bad = true;
cout << "failed: \t" << t << ":\t" << maindiffpath.getme(t) << " != " << sdr(parameters.m_mask[t]) << endl;
}
}
}
if (bad) exit(0);
show_path(maindiffpath);
// remove bitrelations possibly limiting me[0],...,me[19]
const unsigned tend_fix_me = parameters.tend_rnd1_me;
cout << "Fixed me diffs for t=[0," << tend_fix_me << "): (" << bitrels.size() << "=>" << flush;
filter_bitconditions(bitrels, tend_fix_me, 80);
cout << bitrels.size() << ")" << endl;
for (unsigned i = 0; i < bitrels.size(); ++i) {
cout << " - ";
bool firstone = true;
for (unsigned t = 0; t < 80; ++t)
for (unsigned b = 0; b < 32; ++b)
if (bitrels[i][t] & (1<<b)) {
if (firstone)
firstone = false;
else
cout << " + ";
cout << "M[" << t << "," << b << "]";
}
cout << " = " << (bitrels[i][80]&1) << endl;
}
tmpspace.clear();
for (unsigned t = 0; t < 80; ++t) {
if (t < tend_fix_me) {
for (unsigned b = 0; b < 31; ++b) {
int bit = maindiffpath.getme(t).get(b);
if (bit == 0)
tmpspace.buildbasis_addfreebit(t,b);
else
tmpspace.buildbasis_setbit(t,b,bit==-1);
}
tmpspace.buildbasis_addfreebit(t,31);
} else {
for (unsigned b = 0; b < 32; ++b)
tmpspace.buildbasis_addfreebit(t,b);
}
}
tmpspace.tobitrelations_80(tmpbitrel);
bitrels.insert(bitrels.end(), tmpbitrel.begin(), tmpbitrel.end());
cout << "Extra me [0," << tend_fix_me << ") bitrelations: " << tmpbitrel.size() << endl;
{
cout << "Extra tunnel me bitrelations: " << endl;
ifstream ifs("tunnel_bitconditions.txt");
read_message_bitconditions(ifs, tmpbitrel);
for (unsigned i = 0; i < tmpbitrel.size(); ++i) {
bool firstone = true;
for (unsigned t = 0; t < 80; ++t)
if (tmpbitrel[i][t]) {
if (firstone) firstone = false;
else cout << "+ ";
cout << "m" << t << sdr(tmpbitrel[i][t]) << " ";
}
cout << "= " << (tmpbitrel[i][80]&1) << endl;
}
bitrels.insert(bitrels.end(), tmpbitrel.begin(), tmpbitrel.end());
}
tmpspace.frombitrelations_80(bitrels);
mainmespace = tmpspace;
tmpspace.tobitrelations_16(bitrels);
cout << "Total bitrelations: " << bitrels.size() << endl;
#if 0
cout << "Independent message bits: " << endl;
uint32 meindep[16];
for (unsigned i = 0; i < 16; ++i)
meindep[16] = ~uint32(0);
for (unsigned i = 0; i < bitrels.size(); ++i)
for (unsigned t = 0; t < 16; ++t)
meindep[t] &= ~bitrels[i][t];
for (unsigned i = 0; i < 16; ++i) {
cout << "m[" << i << "] indep:\t";
for (int b = 31; b >= 0; --b)
cout << ((meindep[i]&(1<<b))?"1":"0");
cout << endl;
}
#endif
pathbitrelations = bitrels;
pathbitrelationsmatrix.clear();
pathbitrelationsmatrix.resize(16);
for (unsigned i = 0; i < 16; ++i)
pathbitrelationsmatrix[i].resize(32);
for (unsigned i = 0; i < pathbitrelations.size(); ++i) {
int lastcol = -1;
for (int col = 16*32-1; col >= 0; --col)
if (pathbitrelations[i][col>>5]&(1<<(col&31))) {
lastcol = col;
unsigned t = lastcol>>5;
unsigned b = lastcol&31;
pathbitrelationsmatrix[t][b] = pathbitrelations[i];
break;
}
if (lastcol == -1) throw;
}
#if 0
//needs diffpath & pathbitrelationsmatrix
analyze_indepsection_prob();
#endif
if (parameters.tunnelfile.size()) {
vector<sha1differentialpath> tunnels;
cout << "Loading tunnels from '" << parameters.tunnelfile << "'..." << flush;
try {
load_bz2(tunnels, text_archive, parameters.tunnelfile);
}
catch (std::exception &e) { tunnels.clear(); cout << "failed:" << endl << e.what() << endl; }
catch (...) { tunnels.clear(); cout << "failed." << endl; }
if (tunnels.size())
analyze_tunnels_diffpath(maindiffpath, bitrels, tunnels);
exit(0);
}
if (!usetunnelbitconditions) {
// if not using tunnel bit conditions then we'll assume we want to analyze tunnels
analyze_tunnels_diffpath(maindiffpath, bitrels);
exit(0);
}
// if we're using tunnel bit conditions we'll assume we want to generate the collision finding program
generate_program();
break;
} catch (std::exception& e) { cerr << "c: " << e.what() << endl; } catch (...) {}
} // for (unsigned pi = 0; pi < paths.size(); ++pi)
}
