static void
conversionview_scale_cb( GtkWidget *wid, Conversionview *cv )
{
Imagemodel *imagemodel = cv->imagemodel;
double min, max;
progress_begin();
if( !conversionview_findmaxmin( imagemodel, &min, &max ) ) {
progress_end();
iwindow_alert( wid, GTK_MESSAGE_ERROR );
return;
}
progress_end();
if( max - min < 1e-20 ) {
error_top( _( "Unable to scale image." ) );
error_sub( _( "Maximum and minimum pixel values are equal." ) );
iwindow_alert( wid, GTK_MESSAGE_ERROR );
return;
}
imagemodel->scale = 255.0 / (max - min);
imagemodel->offset = -(min * imagemodel->scale);
iobject_changed( IOBJECT( imagemodel ) );
}
void analyze_masters(int argc, char *argv[],
import_options_t *analyzer,
forest_t *forest)
/* main entry point; collect and parse CVS masters */
{
char name[PATH_MAX];
const char *last = NULL;
char *file;
size_t i, j = 1;
int c;
#ifdef THREADS
pthread_attr_t attr;
/* Initialize and reinforce default thread non-detached attribute */
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
#endif /* THREADS */
striplen = analyzer->striplen;
forest->textsize = forest->filecount = 0;
progress_begin("Reading file list...", NO_MAX);
for (;;)
{
struct stat stb;
int l;
if (argc < 2) {
/* coverity[tainted_data] Safe, never handed to exec */
if (fgets(name, sizeof(name), stdin) == NULL)
break;
l = strlen(name);
if (name[l-1] == '\n')
name[l-1] = '\0';
file = name;
} else {
file = argv[j++];
if (!file)
break;
}
if (stat(file, &stb) != 0)
continue;
else if (S_ISDIR(stb.st_mode) != 0)
continue;
else if (!analyzer->promiscuous)
{
char *end = file + strlen(file);
if (end - file < 2 || end[-1] != 'v' || end[-2] != ',')
continue;
if (strstr(file, "CVSROOT") != NULL)
continue;
}
forest->textsize += stb.st_size;
fn = xcalloc(1, sizeof(rev_filename), "filename gathering");
*fn_tail = fn;
fn_tail = (rev_filename **)&fn->next;
if (striplen > 0 && last != NULL) {
c = strcommonendingwith(file, last, '/');
if (c < striplen)
striplen = c;
} else if (striplen < 0) {
striplen = 0;
for (i = 0; i < strlen(file); i++)
if (file[i] == '/')
striplen = i + 1;
}
fn->file = atom(file);
last = fn->file;
total_files++;
if (progress && total_files % 100 == 0)
progress_jump(total_files);
}
forest->filecount = total_files;
generators = xcalloc(sizeof(generator_t), total_files, "Generators");
sorted_files = xmalloc(sizeof(rev_file) * total_files, "sorted_files");
cvs_masters = xcalloc(total_files, sizeof(cvs_master), "cvs_masters");
rev_masters = xmalloc(sizeof(rev_master) * total_files, "rev_masters");
fn_n = total_files;
i = 0;
rev_filename *tn;
for (fn = fn_head; fn; fn = tn) {
tn = fn->next;
sorted_files[i].name = fn->file;
sorted_files[i++].rectified = atom_rectify_name(fn->file);
free(fn);
}
#ifdef FILESORT
/*
* Sort list of files in path_deep_compare order of output name.
* cvs_masters and rev_masters will be mainteined in this order.
* This causes commits to come out in correct pack order.
* It also causes operations to come out in correct fileop_sort order.
* Note some output names are different to input names.
* e.g. .cvsignore becomes .gitignore
*/
qsort(sorted_files, total_files, sizeof(rev_file), file_compare);
#endif /*FILESORT */
progress_end("done, %.3fKB in %d files",
(forest->textsize/1024.0), forest->filecount);
/* things that must be visible to inner functions */
load_current_file = 0;
verbose = analyzer->verbose;
/*
* Analyze the files for CVS revision structure.
*
* The result of this analysis is a rev_list, each element of
* which corresponds to a CVS master and points at a list of named
* CVS branch heads (rev_refs), each one of which points at a list
* of CVS commit structures (cvs_commit).
*/
#ifdef THREADS
if (threads > 1)
snprintf(name, sizeof(name),
"Analyzing masters with %d threads...", threads);
else
#endif /* THREADS */
strcpy(name, "Analyzing masters...");
progress_begin(name, total_files);
#ifdef THREADS
if (threads > 1)
{
int i;
workers = (pthread_t *)xcalloc(threads, sizeof(pthread_t), __func__);
for (i = 0; i < threads; i++)
pthread_create(&workers[i], &attr, worker, NULL);
/* Wait for all the threads to die off. */
for (i = 0; i < threads; i++)
pthread_join(workers[i], NULL);
pthread_mutex_destroy(&enqueue_mutex);
pthread_mutex_destroy(&revlist_mutex);
}
else
#endif /* THREADS */
worker(NULL);
progress_end("done, %d revisions", (int)total_revisions);
free(sorted_files);
forest->errcount = err;
forest->total_revisions = total_revisions;
forest->skew_vulnerable = skew_vulnerable;
forest->cvs = cvs_masters;
forest->generators = (generator_t *)generators;
}