SAL_IMPLEMENT_MAIN_WITH_ARGS( argc, argv )
{
sal_Bool bSentArgs = sal_False;
const char* pUsePlugin;
rtl_uString *pPipePath = NULL;
Args *args;
int status = 0;
struct splash* splash = NULL;
struct sigaction sigpipe_action;
struct sigaction sigterm_action;
/* turn SIGPIPE into an error */
memset(&sigpipe_action, 0, sizeof(struct sigaction));
sigpipe_action.sa_handler = SIG_IGN;
sigemptyset(&sigpipe_action.sa_mask);
sigaction(SIGPIPE, &sigpipe_action, NULL);
memset(&sigterm_action, 0, sizeof(struct sigaction));
sigterm_action.sa_handler = &sigterm_handler;
sigemptyset(&sigterm_action.sa_mask);
sigaction(SIGTERM, &sigterm_action, NULL);
args = args_parse ();
args->pAppPath = get_app_path( argv[0] );
if ( !args->pAppPath )
{
fprintf( stderr, "ERROR: Can't read app link\n" );
exit( 1 );
}
#ifndef ENABLE_QUICKSTART_LIBPNG
/* we can't load and render it anyway */
args->bInhibitSplash = sal_True;
#endif
pUsePlugin = getenv( "SAL_USE_VCLPLUGIN" );
if ( pUsePlugin && !strcmp(pUsePlugin, "svp") )
args->bInhibitSplash = sal_True;
if ( !args->bInhibitPipe && getenv("LIBO_XDGAPP") == NULL )
{
int fd = 0;
pPipePath = get_pipe_path( args->pAppPath );
if ( ( fd = connect_pipe( pPipePath ) ) >= 0 )
{
// Wait for answer
char resp[ strlen( "InternalIPC::SendArguments" ) + 1];
ssize_t n = read( fd, resp, SAL_N_ELEMENTS( resp ) );
if (n == (ssize_t) SAL_N_ELEMENTS( resp )
&& (memcmp(
resp, "InternalIPC::SendArguments",
SAL_N_ELEMENTS( resp ) - 1) == 0)) {
rtl_uString *pCwdPath = NULL;
osl_getProcessWorkingDir( &pCwdPath );
// Then send args
bSentArgs = send_args( fd, pCwdPath );
}
close( fd );
}
}
if ( !bSentArgs )
{
/* we have to prepare for, and exec the binary */
int nPercent = 0;
ChildInfo *info;
sal_Bool bAllArgs = sal_True;
sal_Bool bShortWait, bRestart;
/* sanity check pieces */
system_checks();
/* load splash image and create window */
if ( !args->bInhibitSplash )
{
splash = splash_create(args->pAppPath, argc, argv);
}
/* pagein */
if (!args->bInhibitPagein)
exec_pagein (args);
/* javaldx */
#if HAVE_FEATURE_JAVA
if (!args->bInhibitJavaLdx)
exec_javaldx (args);
#endif
do
{
bRestart = sal_False;
/* fast updates if we have somewhere to update it to */
bShortWait = splash ? sal_True : sal_False;
/* Periodically update the splash & the percent according
to what status_fd says, poll quickly only while starting */
info = child_spawn (args, bAllArgs, bShortWait);
g_pProcess = info->child;
while (!child_exited_wait (info, bShortWait))
{
ProgressStatus eResult;
splash_draw_progress( splash, nPercent );
eResult = read_percent( info, &nPercent );
if (eResult != ProgressContinue)
{
splash_destroy(splash);
splash = NULL;
bShortWait = sal_False;
}
}
status = child_get_exit_code(info);
g_pProcess = NULL; // reset
switch (status) {
case EXITHELPER_CRASH_WITH_RESTART: // re-start with just -env: parameters
bRestart = sal_True;
bAllArgs = sal_False;
break;
case EXITHELPER_NORMAL_RESTART: // re-start with all arguments
bRestart = sal_True;
bAllArgs = sal_True;
break;
default:
break;
}
child_info_destroy (info);
} while (bRestart);
}
/* cleanup */
if ( pPipePath )
rtl_uString_release( pPipePath );
args_free (args);
return status;
}
GimpInitStatusFunc
gui_init (Gimp *gimp,
gboolean no_splash)
{
GimpInitStatusFunc status_callback = NULL;
gchar *abort_message;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (the_gui_gimp == NULL, NULL);
abort_message = gui_sanity_check ();
if (abort_message)
gui_abort (abort_message);
the_gui_gimp = gimp;
/* TRANSLATORS: there is no need to translate this in GIMP. This uses
* "gtk20" domain as a special trick to determine language direction,
* but xgettext extracts it anyway mistakenly into GIMP po files.
* Leave an empty string as translation. It does not matter.
*/
if (g_strcmp0 (dgettext ("gtk20", "default:LTR"), "default:RTL") == 0)
/* Normally this should have been taken care of during command line
* parsing as a post-parse hook of gtk_get_option_group(), using the
* system locales.
* But user config may have overriden the language, therefore we must
* check the widget directions again.
*/
gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
else
gtk_widget_set_default_direction (GTK_TEXT_DIR_LTR);
gui_unique_init (gimp);
gimp_language_store_parser_init ();
gimp_widgets_init (gui_help_func,
gui_get_foreground_func,
gui_get_background_func,
NULL);
g_type_class_ref (GIMP_TYPE_COLOR_SELECT);
/* disable automatic startup notification */
gtk_window_set_auto_startup_notification (FALSE);
gimp_dnd_init (gimp);
themes_init (gimp);
initial_monitor = gimp_get_monitor_at_pointer (&initial_screen);
gtk_widget_set_default_colormap (gdk_screen_get_rgb_colormap (initial_screen));
if (! no_splash)
{
splash_create (gimp->be_verbose, initial_screen, initial_monitor);
status_callback = splash_update;
}
g_signal_connect_after (gimp, "initialize",
G_CALLBACK (gui_initialize_after_callback),
NULL);
g_signal_connect (gimp, "restore",
G_CALLBACK (gui_restore_callback),
NULL);
g_signal_connect_after (gimp, "restore",
G_CALLBACK (gui_restore_after_callback),
NULL);
g_signal_connect (gimp, "exit",
G_CALLBACK (gui_exit_callback),
NULL);
g_signal_connect_after (gimp, "exit",
G_CALLBACK (gui_exit_after_callback),
NULL);
return status_callback;
}
/*
* mainline
*/
TimeType ae2_main(char *fname, char *skip_start, char *skip_end)
{
int i;
int match_idx;
struct Node *n;
struct symbol *s;
TimeType first_cycle, last_cycle /* , total_cycles */; /* scan-build */
int total_rows = 0;
int mono_row_offset = 0;
struct Node *monolithic_node = NULL;
struct symbol *monolithic_sym = NULL;
#ifdef AET2_ALIASDB_IS_PRESENT
unsigned long kw = 0;
unsigned char *missing = NULL;
#endif
char buf[AE2_MAX_NAME_LENGTH+1];
ae2_read_set_max_section_cycle(65536);
ae2_initialize(error_fn, msg_fn, alloc_fn, free_fn);
if ( (!(GLOBALS->ae2_f=fopen(fname, "rb"))) || (!(GLOBALS->ae2 = ae2_read_initialize(GLOBALS->ae2_f))) )
{
if(GLOBALS->ae2_f)
{
fclose(GLOBALS->ae2_f);
GLOBALS->ae2_f = NULL;
}
return(LLDescriptor(0)); /* look at GLOBALS->ae2 in caller for success status... */
}
GLOBALS->time_dimension = 'n';
if(!GLOBALS->fast_tree_sort)
{
GLOBALS->do_hier_compress = 0;
}
init_facility_pack();
/* SPLASH */ splash_create();
sym_hash_initialize(GLOBALS);
#ifdef AET2_ALIASDB_IS_PRESENT
if(!GLOBALS->disable_ae2_alias) { kw = ae2_read_locate_keyword(GLOBALS->ae2, "aliasdb"); }
if(kw)
{
GLOBALS->adb_alias_stream_file = ae2_read_keyword_stream(GLOBALS->ae2, kw);
GLOBALS->adb = adb_open_embed(GLOBALS->adb_alias_stream_file, NULL, alloc_fn, free_fn, adb_msg_fn, error_fn);
if(GLOBALS->adb)
{
unsigned long fn;
GLOBALS->ae2_num_aliases = adb_num_aliases(GLOBALS->adb);
GLOBALS->adb_max_terms = adb_max_alias_terms(GLOBALS->adb);
GLOBALS->adb_terms = calloc_2(GLOBALS->adb_max_terms + 1, sizeof(ADB_TERM));
GLOBALS->adb_aliases = calloc_2(GLOBALS->ae2_num_aliases, sizeof(ADB_TERM *));
GLOBALS->adb_num_terms = calloc_2(GLOBALS->ae2_num_aliases, sizeof(unsigned short));
GLOBALS->adb_idx_first = calloc_2(GLOBALS->ae2_num_aliases, sizeof(unsigned short));
GLOBALS->adb_idx_last = calloc_2(GLOBALS->ae2_num_aliases, sizeof(unsigned short));
fn = adb_map_ids (GLOBALS->adb, symbol_fn, GLOBALS->ae2); /* iteratively replaces all .id with FACIDX */
fprintf(stderr, AET2_RDLOAD"Encountered %lu aliases referencing %lu facs.\n", GLOBALS->ae2_num_aliases, fn);
}
}
#endif
GLOBALS->ae2_num_sections=ae2_read_num_sections(GLOBALS->ae2);
GLOBALS->ae2_num_facs = ae2_read_num_symbols(GLOBALS->ae2);
GLOBALS->numfacs = GLOBALS->ae2_num_facs + GLOBALS->ae2_num_aliases;
GLOBALS->ae2_process_mask = calloc_2(1, GLOBALS->numfacs/8+1);
GLOBALS->ae2_fr=calloc_2(GLOBALS->numfacs, sizeof(AE2_FACREF));
GLOBALS->ae2_lx2_table=(struct lx2_entry **)calloc_2(GLOBALS->numfacs, sizeof(struct lx2_entry *));
match_idx = 0;
for(i=0;i<GLOBALS->ae2_num_facs;i++)
{
int idx = i+1;
GLOBALS->ae2_fr[match_idx].facname = NULL;
GLOBALS->ae2_fr[match_idx].s = idx;
GLOBALS->ae2_fr[match_idx].row = ae2_read_symbol_rows(GLOBALS->ae2, idx);
if(GLOBALS->ae2_fr[match_idx].row > AE2_MAX_ROWS)
{
GLOBALS->ae2_fr[match_idx].row = AE2_MAX_ROWS;
ae2_read_find_symbol(GLOBALS->ae2, buf, &GLOBALS->ae2_fr[match_idx]);
fprintf(stderr, AET2_RDLOAD"Warning: Reduced array %s to %d rows.\n", buf, AE2_MAX_ROWS);
}
total_rows += (GLOBALS->ae2_fr[match_idx].row > 0) ? GLOBALS->ae2_fr[match_idx].row : 1;
if(GLOBALS->ae2_fr[match_idx].row == 1) GLOBALS->ae2_fr[match_idx].row = 0;
GLOBALS->ae2_fr[match_idx].length = ae2_read_symbol_length(GLOBALS->ae2, idx);
GLOBALS->ae2_fr[match_idx].row_high = 0;
GLOBALS->ae2_fr[match_idx].offset = 0;
match_idx++;
}
#ifdef AET2_ALIASDB_IS_PRESENT
missing = calloc_2(1, (GLOBALS->ae2_num_aliases + 7 + 1) / 8); /* + 1 to mirror idx value */
for(i=0;i<GLOBALS->ae2_num_aliases;i++)
{
unsigned long numTerms;
int idx = i+1;
int ii;
int midx, mbit;
int mcnt;
total_rows++;
if((numTerms = adb_load_alias_def(GLOBALS->adb, idx, GLOBALS->adb_terms)))
{
if(GLOBALS->adb_terms[0].first > GLOBALS->adb_terms[0].last)
{
GLOBALS->ae2_fr[match_idx].length = GLOBALS->adb_terms[0].first - GLOBALS->adb_terms[0].last + 1;
}
else
{
GLOBALS->ae2_fr[match_idx].length = GLOBALS->adb_terms[0].last - GLOBALS->adb_terms[0].first + 1;
}
GLOBALS->adb_idx_first[i] = GLOBALS->adb_terms[0].first;
GLOBALS->adb_idx_last[i] = GLOBALS->adb_terms[0].last;
GLOBALS->ae2_fr[match_idx].s = idx + GLOBALS->ae2_num_facs; /* bias aliases after regular facs */
GLOBALS->ae2_fr[match_idx].facname = NULL;
GLOBALS->ae2_fr[match_idx].row = 0;
GLOBALS->ae2_fr[match_idx].row_high = 0;
GLOBALS->ae2_fr[match_idx].offset = 0;
GLOBALS->adb_num_terms[i] = numTerms;
GLOBALS->adb_aliases[i] = adb_alloc_2(numTerms * sizeof(ADB_TERM));
mcnt = 0;
for(ii=0;ii<(numTerms);ii++)
{
GLOBALS->adb_aliases[i][ii].id = GLOBALS->adb_terms[ii+1].id;
if(!GLOBALS->adb_aliases[i][ii].id)
{
mcnt++;
}
GLOBALS->adb_aliases[i][ii].first = GLOBALS->adb_terms[ii+1].first;
GLOBALS->adb_aliases[i][ii].last = GLOBALS->adb_terms[ii+1].last;
}
if(mcnt)
{
midx = idx / 8;
mbit = idx & 7;
missing[midx] |= (1 << mbit);
}
}
else
{
unsigned long id = GLOBALS->adb_terms[0].id;
if(id)
{
memcpy(&GLOBALS->ae2_fr[match_idx], &GLOBALS->ae2_fr[id-1], sizeof(AE2_FACREF));
GLOBALS->adb_idx_first[i] = 0;
GLOBALS->adb_idx_last[i] = GLOBALS->ae2_fr[match_idx].length - 1;
}
else /* not in model */
{
midx = idx / 8;
mbit = idx & 7;
missing[midx] |= (1 << mbit);
GLOBALS->ae2_fr[match_idx].length = 1;
GLOBALS->adb_idx_first[i] = 0;
GLOBALS->adb_idx_last[i] = 0;
GLOBALS->ae2_fr[match_idx].s = idx + GLOBALS->ae2_num_facs; /* bias aliases after regular facs */
GLOBALS->ae2_fr[match_idx].facname = NULL;
GLOBALS->ae2_fr[match_idx].row = 0;
GLOBALS->ae2_fr[match_idx].row_high = 0;
GLOBALS->ae2_fr[match_idx].offset = 0;
GLOBALS->adb_num_terms[i] = 0;
}
}
match_idx++;
}
#endif
monolithic_node = calloc_2(total_rows, sizeof(struct Node));
monolithic_sym = calloc_2(match_idx, sizeof(struct symbol));
fprintf(stderr, AET2_RDLOAD"Finished building %d facs.\n", match_idx);
/* SPLASH */ splash_sync(1, 5);
first_cycle = (TimeType) ae2_read_start_cycle(GLOBALS->ae2);
last_cycle = (TimeType) ae2_read_end_cycle(GLOBALS->ae2);
/* total_cycles = last_cycle - first_cycle + 1; */ /* scan-build */
/* do your stuff here..all useful info has been initialized by now */
if(!GLOBALS->hier_was_explicitly_set) /* set default hierarchy split char */
{
GLOBALS->hier_delimeter='.';
}
match_idx = 0;
for(i=0;i<GLOBALS->numfacs;i++)
{
char *str;
int idx;
int typ;
unsigned long len, clen;
int row_iter, mx_row, mx_row_adjusted;
#ifdef AET2_ALIASDB_IS_PRESENT
if(i < GLOBALS->ae2_num_facs)
#endif
{
idx = i+1;
len = ae2_read_symbol_name(GLOBALS->ae2, idx, buf);
typ = (GLOBALS->ae2_fr[match_idx].row <= 1) ? ND_GEN_NET : ND_VCD_ARRAY;
}
#ifdef AET2_ALIASDB_IS_PRESENT
else
{
idx = i - GLOBALS->ae2_num_facs + 1;
typ = (missing[idx/8] & (1 << (idx & 7))) ? ND_GEN_MISSING : ND_GEN_ALIAS;
len = adb_alias_name(GLOBALS->adb, idx, buf) - 1; /* it counts the null character */
}
#endif
if(GLOBALS->ae2_fr[match_idx].length>1)
{
int len2;
#ifdef AET2_ALIASDB_IS_PRESENT
if(i < GLOBALS->ae2_num_facs)
#endif
{
len2 = sprintf_2_1d(buf+len, GLOBALS->ae2_fr[match_idx].length-1);
}
#ifdef AET2_ALIASDB_IS_PRESENT
else
{
len2 = sprintf_2_2d(buf+len, GLOBALS->adb_idx_first[i - GLOBALS->ae2_num_facs], GLOBALS->adb_idx_last[i - GLOBALS->ae2_num_facs]);
}
#endif
clen = (len + len2 + 1);
if(!GLOBALS->do_hier_compress)
{
str=malloc_2(clen);
}
else
{
str = buf;
}
if(clen > GLOBALS->longestname) GLOBALS->longestname = clen;
if(!GLOBALS->alt_hier_delimeter)
{
if(!GLOBALS->do_hier_compress) strcpy(str, buf);
}
else
{
strcpy_vcdalt(str, buf, GLOBALS->alt_hier_delimeter);
}
s = &monolithic_sym[match_idx];
symadd_name_exists_sym_exists(s, str,0);
}
else
{
clen = (len+1);
if(!GLOBALS->do_hier_compress)
{
str=malloc_2(clen);
}
else
{
str = buf;
}
if(clen > GLOBALS->longestname) GLOBALS->longestname = clen;
if(!GLOBALS->alt_hier_delimeter)
{
if(!GLOBALS->do_hier_compress) strcpy(str, buf);
}
else
{
strcpy_vcdalt(str, buf, GLOBALS->alt_hier_delimeter);
}
s = &monolithic_sym[match_idx];
symadd_name_exists_sym_exists(s, str,0);
}
mx_row = (GLOBALS->ae2_fr[match_idx].row < 1) ? 1 : GLOBALS->ae2_fr[match_idx].row;
mx_row_adjusted = (mx_row < 2) ? 0 : mx_row;
n=&monolithic_node[mono_row_offset];
s->n = n;
mono_row_offset += mx_row;
if(GLOBALS->do_hier_compress)
{
s->name = compress_facility((unsigned char *)str, clen - 1);
}
for(row_iter = 0; row_iter < mx_row; row_iter++)
{
n[row_iter].vartype = typ;
n[row_iter].nname=s->name;
n[row_iter].mv.mvlfac = (struct fac *)(GLOBALS->ae2_fr+match_idx); /* to keep from having to allocate duplicate mvlfac struct */
/* use the info in the AE2_FACREF array instead */
n[row_iter].array_height = mx_row_adjusted;
n[row_iter].this_row = row_iter;
if(GLOBALS->ae2_fr[match_idx].length>1)
{
#ifdef AET2_ALIASDB_IS_PRESENT
if(i < GLOBALS->ae2_num_facs)
#endif
{
n[row_iter].msi = 0;
n[row_iter].lsi = GLOBALS->ae2_fr[match_idx].length-1;
}
#ifdef AET2_ALIASDB_IS_PRESENT
else
{
n[row_iter].msi = GLOBALS->adb_idx_first[i - GLOBALS->ae2_num_facs];
n[row_iter].lsi = GLOBALS->adb_idx_last[i - GLOBALS->ae2_num_facs];
}
#endif
n[row_iter].extvals = 1;
}
n[row_iter].head.time=-1; /* mark 1st node as negative time */
n[row_iter].head.v.h_val=AN_X;
}
match_idx++;
}
#ifdef AET2_ALIASDB_IS_PRESENT
if(GLOBALS->adb_idx_last) { free_2(GLOBALS->adb_idx_last); GLOBALS->adb_idx_last = NULL; }
if(GLOBALS->adb_idx_first) { free_2(GLOBALS->adb_idx_first); GLOBALS->adb_idx_first = NULL; }
if(missing) { free_2(missing); missing = NULL; }
#endif
freeze_facility_pack();
/* SPLASH */ splash_sync(2, 5);
GLOBALS->facs=(struct symbol **)malloc_2(GLOBALS->numfacs*sizeof(struct symbol *));
if(GLOBALS->fast_tree_sort)
{
for(i=0;i<GLOBALS->numfacs;i++)
{
GLOBALS->facs[i]=&monolithic_sym[i];
}
/* SPLASH */ splash_sync(3, 5);
fprintf(stderr, AET2_RDLOAD"Building facility hierarchy tree.\n");
init_tree();
for(i=0;i<GLOBALS->numfacs;i++)
{
int was_packed = HIER_DEPACK_STATIC; /* no need to free_2() afterward then */
char *sb = hier_decompress_flagged(GLOBALS->facs[i]->name, &was_packed);
build_tree_from_name(sb, i);
}
/* SPLASH */ splash_sync(4, 5);
treegraft(&GLOBALS->treeroot);
fprintf(stderr, AET2_RDLOAD"Sorting facility hierarchy tree.\n");
treesort(GLOBALS->treeroot, NULL);
/* SPLASH */ splash_sync(5, 5);
order_facs_from_treesort(GLOBALS->treeroot, &GLOBALS->facs);
GLOBALS->facs_are_sorted=1;
}
else
{
for(i=0;i<GLOBALS->numfacs;i++)
{
#ifdef WAVE_HIERFIX
char *subst;
char ch;
#endif
GLOBALS->facs[i]=&monolithic_sym[i];
#ifdef WAVE_HIERFIX
while((ch=(*subst)))
{
if(ch==GLOBALS->hier_delimeter) { *subst=VCDNAM_HIERSORT; } /* forces sort at hier boundaries */
subst++;
}
#endif
}
/* SPLASH */ splash_sync(3, 5);
fprintf(stderr, AET2_RDLOAD"Sorting facilities at hierarchy boundaries.\n");
wave_heapsort(GLOBALS->facs,GLOBALS->numfacs);
#ifdef WAVE_HIERFIX
for(i=0;i<GLOBALS->numfacs;i++)
{
char *subst, ch;
subst=GLOBALS->facs[i]->name;
while((ch=(*subst)))
{
if(ch==VCDNAM_HIERSORT) { *subst=GLOBALS->hier_delimeter; } /* restore back to normal */
subst++;
}
}
#endif
GLOBALS->facs_are_sorted=1;
/* SPLASH */ splash_sync(4, 5);
fprintf(stderr, AET2_RDLOAD"Building facility hierarchy tree.\n");
init_tree();
for(i=0;i<GLOBALS->numfacs;i++)
{
build_tree_from_name(GLOBALS->facs[i]->name, i);
}
/* SPLASH */ splash_sync(5, 5);
treegraft(&GLOBALS->treeroot);
treesort(GLOBALS->treeroot, NULL);
}
if(GLOBALS->ae2_time_xlate) /* GLOBALS->ae2_time_xlate is currently unused, but could be again in the future */
{
GLOBALS->min_time = GLOBALS->ae2_time_xlate[0];
GLOBALS->max_time = GLOBALS->ae2_time_xlate[last_cycle - first_cycle];
}
else
{
GLOBALS->min_time = first_cycle; GLOBALS->max_time=last_cycle;
}
GLOBALS->ae2_start_cyc = GLOBALS->ae2_start_limit_cyc = first_cycle;
GLOBALS->ae2_end_cyc = GLOBALS->ae2_end_limit_cyc = last_cycle;
GLOBALS->is_lx2 = LXT2_IS_AET2;
if(skip_start || skip_end)
{
TimeType b_start, b_end;
TimeType lim_idx;
if(!skip_start) b_start = GLOBALS->min_time; else b_start = unformat_time(skip_start, GLOBALS->time_dimension);
if(!skip_end) b_end = GLOBALS->max_time; else b_end = unformat_time(skip_end, GLOBALS->time_dimension);
if(b_start<GLOBALS->min_time) b_start = GLOBALS->min_time;
else if(b_start>GLOBALS->max_time) b_start = GLOBALS->max_time;
if(b_end<GLOBALS->min_time) b_end = GLOBALS->min_time;
else if(b_end>GLOBALS->max_time) b_end = GLOBALS->max_time;
if(b_start > b_end)
{
TimeType tmp_time = b_start;
b_start = b_end;
b_end = tmp_time;
}
GLOBALS->min_time = b_start;
GLOBALS->max_time = b_end;
if(GLOBALS->ae2_time_xlate) /* GLOBALS->ae2_time_xlate is currently unused, but could be again in the future */
{
for(lim_idx = first_cycle; lim_idx <= last_cycle; lim_idx++)
{
if(GLOBALS->ae2_time_xlate[lim_idx - first_cycle] <= GLOBALS->min_time)
{
GLOBALS->ae2_start_limit_cyc = lim_idx;
}
if(GLOBALS->ae2_time_xlate[lim_idx - first_cycle] >= GLOBALS->min_time)
{
break;
}
}
for(; lim_idx <= last_cycle; lim_idx++)
{
if(GLOBALS->ae2_time_xlate[lim_idx - first_cycle] >= GLOBALS->max_time)
{
GLOBALS->ae2_end_limit_cyc = lim_idx;
break;
}
}
}
}
fprintf(stderr, AET2_RDLOAD"["TTFormat"] start time.\n"AET2_RDLOAD"["TTFormat"] end time.\n", GLOBALS->min_time, GLOBALS->max_time);
/* SPLASH */ splash_finalize();
return(GLOBALS->max_time);
}
GimpInitStatusFunc
gui_init (Gimp *gimp,
gboolean no_splash)
{
GimpInitStatusFunc status_callback = NULL;
GdkScreen *screen;
gchar *abort_message;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (the_gui_gimp == NULL, NULL);
abort_message = gui_sanity_check ();
if (abort_message)
gui_abort (abort_message);
the_gui_gimp = gimp;
gui_unique_init (gimp);
gimp_widgets_init (gui_help_func,
gui_get_foreground_func,
gui_get_background_func,
NULL);
g_type_class_ref (GIMP_TYPE_COLOR_SELECT);
/* disable automatic startup notification */
gtk_window_set_auto_startup_notification (FALSE);
gimp_dnd_init (gimp);
themes_init (gimp);
screen = gdk_screen_get_default ();
gtk_widget_set_default_colormap (gdk_screen_get_rgb_colormap (screen));
if (! no_splash)
{
splash_create (gimp->be_verbose);
status_callback = splash_update;
}
g_signal_connect_after (gimp, "initialize",
G_CALLBACK (gui_initialize_after_callback),
NULL);
g_signal_connect (gimp, "restore",
G_CALLBACK (gui_restore_callback),
NULL);
g_signal_connect_after (gimp, "restore",
G_CALLBACK (gui_restore_after_callback),
NULL);
g_signal_connect (gimp, "exit",
G_CALLBACK (gui_exit_callback),
NULL);
g_signal_connect_after (gimp, "exit",
G_CALLBACK (gui_exit_after_callback),
NULL);
return status_callback;
}
/*
* mainline
*/
TimeType vzt_main(char *fname, char *skip_start, char *skip_end)
{
int i;
struct Node *n;
struct symbol *s, *prevsymroot=NULL, *prevsym=NULL;
signed char scale;
unsigned int numalias = 0;
struct symbol *sym_block = NULL;
struct Node *node_block = NULL;
char **f_name = NULL;
GLOBALS->vzt_vzt_c_1 = vzt_rd_init_smp(fname, GLOBALS->num_cpus);
if(!GLOBALS->vzt_vzt_c_1)
{
return(LLDescriptor(0)); /* look at GLOBALS->vzt_vzt_c_1 in caller for success status... */
}
/* SPLASH */ splash_create();
vzt_rd_process_blocks_linearly(GLOBALS->vzt_vzt_c_1, 1);
/* vzt_rd_set_max_block_mem_usage(vzt, 0); */
scale=(signed char)vzt_rd_get_timescale(GLOBALS->vzt_vzt_c_1);
exponent_to_time_scale(scale);
GLOBALS->global_time_offset = vzt_rd_get_timezero(GLOBALS->vzt_vzt_c_1);
GLOBALS->numfacs=vzt_rd_get_num_facs(GLOBALS->vzt_vzt_c_1);
GLOBALS->mvlfacs_vzt_c_3=(struct fac *)calloc_2(GLOBALS->numfacs,sizeof(struct fac));
f_name = calloc_2(F_NAME_MODULUS+1,sizeof(char *));
GLOBALS->vzt_table_vzt_c_1=(struct lx2_entry *)calloc_2(GLOBALS->numfacs, sizeof(struct lx2_entry));
sym_block = (struct symbol *)calloc_2(GLOBALS->numfacs, sizeof(struct symbol));
node_block=(struct Node *)calloc_2(GLOBALS->numfacs,sizeof(struct Node));
for(i=0;i<GLOBALS->numfacs;i++)
{
GLOBALS->mvlfacs_vzt_c_3[i].node_alias=vzt_rd_get_fac_rows(GLOBALS->vzt_vzt_c_1, i);
node_block[i].msi=vzt_rd_get_fac_msb(GLOBALS->vzt_vzt_c_1, i);
node_block[i].lsi=vzt_rd_get_fac_lsb(GLOBALS->vzt_vzt_c_1, i);
GLOBALS->mvlfacs_vzt_c_3[i].flags=vzt_rd_get_fac_flags(GLOBALS->vzt_vzt_c_1, i);
GLOBALS->mvlfacs_vzt_c_3[i].len=vzt_rd_get_fac_len(GLOBALS->vzt_vzt_c_1, i);
}
fprintf(stderr, VZT_RDLOAD"Finished building %d facs.\n", GLOBALS->numfacs);
/* SPLASH */ splash_sync(1, 5);
GLOBALS->first_cycle_vzt_c_3 = (TimeType) vzt_rd_get_start_time(GLOBALS->vzt_vzt_c_1) * GLOBALS->time_scale;
GLOBALS->last_cycle_vzt_c_3 = (TimeType) vzt_rd_get_end_time(GLOBALS->vzt_vzt_c_1) * GLOBALS->time_scale;
GLOBALS->total_cycles_vzt_c_3 = GLOBALS->last_cycle_vzt_c_3 - GLOBALS->first_cycle_vzt_c_3 + 1;
/* do your stuff here..all useful info has been initialized by now */
if(!GLOBALS->hier_was_explicitly_set) /* set default hierarchy split char */
{
GLOBALS->hier_delimeter='.';
}
if(GLOBALS->numfacs)
{
char *fnam = vzt_rd_get_facname(GLOBALS->vzt_vzt_c_1, 0);
int flen = strlen(fnam);
f_name[0]=malloc_2(flen+1);
strcpy(f_name[0], fnam);
}
for(i=0;i<GLOBALS->numfacs;i++)
{
char buf[65537];
char *str;
struct fac *f;
if(i!=(GLOBALS->numfacs-1))
{
char *fnam = vzt_rd_get_facname(GLOBALS->vzt_vzt_c_1, i+1);
int flen = strlen(fnam);
f_name[(i+1)&F_NAME_MODULUS]=malloc_2(flen+1);
strcpy(f_name[(i+1)&F_NAME_MODULUS], fnam);
}
if(i>1)
{
free_2(f_name[(i-2)&F_NAME_MODULUS]);
f_name[(i-2)&F_NAME_MODULUS] = NULL;
}
if(GLOBALS->mvlfacs_vzt_c_3[i].flags&VZT_RD_SYM_F_ALIAS)
{
int alias = GLOBALS->mvlfacs_vzt_c_3[i].node_alias;
f=GLOBALS->mvlfacs_vzt_c_3+alias;
while(f->flags&VZT_RD_SYM_F_ALIAS)
{
f=GLOBALS->mvlfacs_vzt_c_3+f->node_alias;
}
numalias++;
}
else
{
f=GLOBALS->mvlfacs_vzt_c_3+i;
}
if((f->len>1)&& (!(f->flags&(VZT_RD_SYM_F_INTEGER|VZT_RD_SYM_F_DOUBLE|VZT_RD_SYM_F_STRING))) )
{
int len=sprintf(buf, "%s[%d:%d]", f_name[(i)&F_NAME_MODULUS],node_block[i].msi, node_block[i].lsi);
str=malloc_2(len+1);
if(!GLOBALS->alt_hier_delimeter)
{
strcpy(str, buf);
}
else
{
strcpy_vcdalt(str, buf, GLOBALS->alt_hier_delimeter);
}
s=&sym_block[i];
symadd_name_exists_sym_exists(s,str,0);
prevsymroot = prevsym = NULL;
}
else
{
int gatecmp = (f->len==1) && (!(f->flags&(VZT_RD_SYM_F_INTEGER|VZT_RD_SYM_F_DOUBLE|VZT_RD_SYM_F_STRING))) && (node_block[i].msi!=-1) && (node_block[i].lsi!=-1);
int revcmp = gatecmp && (i) && (!strcmp(f_name[(i)&F_NAME_MODULUS], f_name[(i-1)&F_NAME_MODULUS]));
if(gatecmp)
{
int len = sprintf(buf, "%s[%d]", f_name[(i)&F_NAME_MODULUS],node_block[i].msi);
str=malloc_2(len+1);
if(!GLOBALS->alt_hier_delimeter)
{
strcpy(str, buf);
}
else
{
strcpy_vcdalt(str, buf, GLOBALS->alt_hier_delimeter);
}
s=&sym_block[i];
symadd_name_exists_sym_exists(s,str,0);
if((prevsym)&&(revcmp)&&(!strchr(f_name[(i)&F_NAME_MODULUS], '\\'))) /* allow chaining for search functions.. */
{
prevsym->vec_root = prevsymroot;
prevsym->vec_chain = s;
s->vec_root = prevsymroot;
prevsym = s;
}
else
{
prevsymroot = prevsym = s;
}
}
else
{
str=malloc_2(strlen(f_name[(i)&F_NAME_MODULUS])+1);
if(!GLOBALS->alt_hier_delimeter)
{
strcpy(str, f_name[(i)&F_NAME_MODULUS]);
}
else
{
strcpy_vcdalt(str, f_name[(i)&F_NAME_MODULUS], GLOBALS->alt_hier_delimeter);
}
s=&sym_block[i];
symadd_name_exists_sym_exists(s,str,0);
prevsymroot = prevsym = NULL;
if(f->flags&VZT_RD_SYM_F_INTEGER)
{
node_block[i].msi=31;
node_block[i].lsi=0;
GLOBALS->mvlfacs_vzt_c_3[i].len=32;
}
}
}
n=&node_block[i];
n->nname=s->name;
n->mv.mvlfac = GLOBALS->mvlfacs_vzt_c_3+i;
GLOBALS->mvlfacs_vzt_c_3[i].working_node = n;
if((f->len>1)||(f->flags&(VZT_RD_SYM_F_DOUBLE|VZT_RD_SYM_F_STRING)))
{
n->extvals = 1;
}
n->head.time=-1; /* mark 1st node as negative time */
n->head.v.h_val=AN_X;
s->n=n;
}
for(i=0;i<=F_NAME_MODULUS;i++)
{
if(f_name[(i)&F_NAME_MODULUS])
{
free_2(f_name[(i)&F_NAME_MODULUS]);
f_name[(i)&F_NAME_MODULUS] = NULL;
}
}
free_2(f_name); f_name = NULL;
/* SPLASH */ splash_sync(2, 5);
GLOBALS->facs=(struct symbol **)malloc_2(GLOBALS->numfacs*sizeof(struct symbol *));
if(GLOBALS->fast_tree_sort)
{
for(i=0;i<GLOBALS->numfacs;i++)
{
int len;
GLOBALS->facs[i]=&sym_block[i];
if((len=strlen(GLOBALS->facs[i]->name))>GLOBALS->longestname) GLOBALS->longestname=len;
}
if(numalias)
{
unsigned int idx_lft = 0;
unsigned int idx_lftmax = GLOBALS->numfacs - numalias;
unsigned int idx_rgh = GLOBALS->numfacs - numalias;
struct symbol **facs_merge=(struct symbol **)malloc_2(GLOBALS->numfacs*sizeof(struct symbol *));
fprintf(stderr, VZT_RDLOAD"Merging in %d aliases.\n", numalias);
for(i=0;i<GLOBALS->numfacs;i++) /* fix possible tail appended aliases by remerging in partial one pass merge sort */
{
if(strcmp(GLOBALS->facs[idx_lft]->name, GLOBALS->facs[idx_rgh]->name) <= 0)
{
facs_merge[i] = GLOBALS->facs[idx_lft++];
if(idx_lft == idx_lftmax)
{
for(i++;i<GLOBALS->numfacs;i++)
{
facs_merge[i] = GLOBALS->facs[idx_rgh++];
}
}
}
else
{
facs_merge[i] = GLOBALS->facs[idx_rgh++];
if(idx_rgh == GLOBALS->numfacs)
{
for(i++;i<GLOBALS->numfacs;i++)
{
facs_merge[i] = GLOBALS->facs[idx_lft++];
}
}
}
}
free_2(GLOBALS->facs); GLOBALS->facs = facs_merge;
}
/* SPLASH */ splash_sync(3, 5);
fprintf(stderr, VZT_RDLOAD"Building facility hierarchy tree.\n");
init_tree();
for(i=0;i<GLOBALS->numfacs;i++)
{
int esc = 0;
char *subst = GLOBALS->facs[i]->name;
char ch;
while((ch=(*subst)))
{
if(ch==GLOBALS->hier_delimeter) { if(esc) *subst = VCDNAM_ESCAPE; }
else if(ch=='\\') { esc = 1; GLOBALS->escaped_names_found_vcd_c_1 = 1; }
subst++;
}
build_tree_from_name(GLOBALS->facs[i]->name, i);
}
/* SPLASH */ splash_sync(4, 5);
if(GLOBALS->escaped_names_found_vcd_c_1)
{
for(i=0;i<GLOBALS->numfacs;i++)
{
char *subst, ch;
subst=GLOBALS->facs[i]->name;
while((ch=(*subst)))
{
if(ch==VCDNAM_ESCAPE) { *subst=GLOBALS->hier_delimeter; } /* restore back to normal */
subst++;
}
}
}
treegraft(&GLOBALS->treeroot);
fprintf(stderr, VZT_RDLOAD"Sorting facility hierarchy tree.\n");
treesort(GLOBALS->treeroot, NULL);
/* SPLASH */ splash_sync(5, 5);
order_facs_from_treesort(GLOBALS->treeroot, &GLOBALS->facs);
if(GLOBALS->escaped_names_found_vcd_c_1)
{
treenamefix(GLOBALS->treeroot);
}
GLOBALS->facs_are_sorted=1;
}
else
{
for(i=0;i<GLOBALS->numfacs;i++)
{
char *subst, ch;
int len;
int esc = 0;
GLOBALS->facs[i]=&sym_block[i];
if((len=strlen(subst=GLOBALS->facs[i]->name))>GLOBALS->longestname) GLOBALS->longestname=len;
while((ch=(*subst)))
{
#ifdef WAVE_HIERFIX
if(ch==GLOBALS->hier_delimeter) { *subst=(!esc) ? VCDNAM_HIERSORT : VCDNAM_ESCAPE; } /* forces sort at hier boundaries */
#else
if((ch==GLOBALS->hier_delimeter)&&(esc)) { *subst = VCDNAM_ESCAPE; } /* forces sort at hier boundaries */
#endif
else if(ch=='\\') { esc = 1; GLOBALS->escaped_names_found_vcd_c_1 = 1; }
subst++;
}
}
/* SPLASH */ splash_sync(3, 5);
fprintf(stderr, VZT_RDLOAD"Sorting facilities at hierarchy boundaries.\n");
wave_heapsort(GLOBALS->facs,GLOBALS->numfacs);
#ifdef WAVE_HIERFIX
for(i=0;i<GLOBALS->numfacs;i++)
{
char *subst, ch;
subst=GLOBALS->facs[i]->name;
while((ch=(*subst)))
{
if(ch==VCDNAM_HIERSORT) { *subst=GLOBALS->hier_delimeter; } /* restore back to normal */
subst++;
}
}
#endif
GLOBALS->facs_are_sorted=1;
/* SPLASH */ splash_sync(4, 5);
fprintf(stderr, VZT_RDLOAD"Building facility hierarchy tree.\n");
init_tree();
for(i=0;i<GLOBALS->numfacs;i++)
{
char *nf = GLOBALS->facs[i]->name;
build_tree_from_name(nf, i);
}
/* SPLASH */ splash_sync(5, 5);
if(GLOBALS->escaped_names_found_vcd_c_1)
{
for(i=0;i<GLOBALS->numfacs;i++)
{
char *subst, ch;
subst=GLOBALS->facs[i]->name;
while((ch=(*subst)))
{
if(ch==VCDNAM_ESCAPE) { *subst=GLOBALS->hier_delimeter; } /* restore back to normal */
subst++;
}
}
}
treegraft(&GLOBALS->treeroot);
treesort(GLOBALS->treeroot, NULL);
if(GLOBALS->escaped_names_found_vcd_c_1)
{
treenamefix(GLOBALS->treeroot);
}
}
GLOBALS->min_time = GLOBALS->first_cycle_vzt_c_3; GLOBALS->max_time=GLOBALS->last_cycle_vzt_c_3;
GLOBALS->is_lx2 = LXT2_IS_VZT;
if(skip_start || skip_end)
{
TimeType b_start, b_end;
if(!skip_start) b_start = GLOBALS->min_time; else b_start = unformat_time(skip_start, GLOBALS->time_dimension);
if(!skip_end) b_end = GLOBALS->max_time; else b_end = unformat_time(skip_end, GLOBALS->time_dimension);
if(b_start<GLOBALS->min_time) b_start = GLOBALS->min_time;
else if(b_start>GLOBALS->max_time) b_start = GLOBALS->max_time;
if(b_end<GLOBALS->min_time) b_end = GLOBALS->min_time;
else if(b_end>GLOBALS->max_time) b_end = GLOBALS->max_time;
if(b_start > b_end)
{
TimeType tmp_time = b_start;
b_start = b_end;
b_end = tmp_time;
}
if(!vzt_rd_limit_time_range(GLOBALS->vzt_vzt_c_1, b_start, b_end))
{
fprintf(stderr, VZT_RDLOAD"--begin/--end options yield zero blocks, ignoring.\n");
vzt_rd_unlimit_time_range(GLOBALS->vzt_vzt_c_1);
}
else
{
GLOBALS->min_time = b_start;
GLOBALS->max_time = b_end;
}
}
/* SPLASH */ splash_finalize();
return(GLOBALS->max_time);
}
/*
* mainline
*/
static TimeType extload_main_2(char *fname, char *skip_start, char *skip_end)
{
int max_idcode;
#ifndef WAVE_FSDB_READER_IS_PRESENT
char sbuff[65537];
unsigned int msk = 0;
#endif
int i;
if(!(GLOBALS->extload=fopen(fname, "rb")))
{
GLOBALS->extload_already_errored = 1;
return(LLDescriptor(0)); /* look at GLOBALS->vzt_vzt_c_1 in caller for success status... */
}
fclose(GLOBALS->extload);
/* SPLASH */ splash_create();
#ifdef WAVE_FSDB_READER_IS_PRESENT
GLOBALS->extload_ffr_ctx = fsdbReaderOpenFile(GLOBALS->loaded_file_name);
GLOBALS->is_lx2 = LXT2_IS_FSDB;
if(GLOBALS->extload_ffr_ctx)
{
int rv;
int mult;
char scale;
uint64_t tim;
struct fsdbReaderGetStatistics_t *gs;
int success_count = 0;
int attempt_count = 0;
attempt_count++;
rv = fsdbReaderExtractScaleUnit(GLOBALS->extload_ffr_ctx, &mult, &scale);
if(rv)
{
GLOBALS->time_scale = mult;
GLOBALS->time_dimension = tolower(scale);
success_count++;
}
attempt_count++;
rv = fsdbReaderGetMinFsdbTag64(GLOBALS->extload_ffr_ctx, &tim);
if(rv)
{
GLOBALS->min_time = tim;
success_count++;
}
attempt_count++;
rv = fsdbReaderGetMaxFsdbTag64(GLOBALS->extload_ffr_ctx, &tim);
if(rv)
{
GLOBALS->max_time = tim;
if(GLOBALS->max_time == LLDescriptor(0))
{
GLOBALS->max_time = LLDescriptor(1);
}
success_count++;
}
attempt_count++;
gs = fsdbReaderGetStatistics(GLOBALS->extload_ffr_ctx);
if(gs)
{
GLOBALS->numfacs = gs->varCount;
free(gs);
success_count++;
}
attempt_count++;
max_idcode = fsdbReaderGetMaxVarIdcode(GLOBALS->extload_ffr_ctx);
if(max_idcode)
{
success_count++;
}
else
{
max_idcode = GLOBALS->numfacs; /* for 1.x format files */
success_count++;
}
if(attempt_count != success_count)
{
fprintf(stderr, EXTLOAD"Could not initialize '%s' properly.\n", fname);
GLOBALS->extload_already_errored = 1;
return(LLDescriptor(0));
}
}
else
{
fprintf(stderr, EXTLOAD"Could not initialize '%s' properly.\n", fname);
GLOBALS->extload_already_errored = 1;
return(LLDescriptor(0));
}
#else
last_modification_check();
sprintf(sbuff, "%s -info %s 2>&1", EXTLOAD_PATH, fname);
GLOBALS->extload = popen(sbuff, "r");
for(;;)
{
char * rc = fgets(sbuff, 65536, GLOBALS->extload);
if(!rc) break;
switch(rc[0])
{
case 's':
if(!strncmp("scale unit", rc, 10))
{
char *pnt = strchr(rc+10, ':');
if(pnt)
{
pnt++;
GLOBALS->time_scale = atoi(pnt);
GLOBALS->time_dimension = 'n';
while(*pnt)
{
if(isalpha(*pnt))
{
GLOBALS->time_dimension = tolower(*pnt);
break;
}
pnt++;
}
msk |= 1;
}
}
break;
case 'm':
if(!strncmp("minimum xtag", rc, 12))
{
char *pnt = strchr(rc+12, '(');
if(pnt)
{
unsigned int lo = 0, hi = 0;
pnt++;
sscanf(pnt, "%u %u", &hi, &lo);
GLOBALS->min_time = (TimeType)((((UTimeType)hi)<<32) + ((UTimeType)lo));
msk |= 2;
}
}
else if(!strncmp("maximum xtag", rc, 12))
{
char *pnt = strchr(rc+12, '(');
if(pnt)
{
unsigned int lo = 0, hi = 0;
pnt++;
sscanf(pnt, "%u %u", &hi, &lo);
GLOBALS->max_time = (TimeType)((((UTimeType)hi)<<32) + ((UTimeType)lo));
if(GLOBALS->max_time == LLDescriptor(0))
{
GLOBALS->max_time = LLDescriptor(1);
}
msk |= 4;
}
}
else if(!strncmp("max var idcode", rc, 14))
{
char *pnt = strchr(rc+14, ':');
if(pnt)
{
pnt++;
sscanf(pnt, "%d", &max_idcode);
msk |= 8;
}
}
break;
case 'v':
if(!strncmp("var creation cnt", rc, 16))
{
char *pnt = strchr(rc+16, ':');
if(pnt)
{
pnt++;
sscanf(pnt, "%d", &GLOBALS->numfacs);
msk |= 16;
}
}
case 'f':
if(!strncmp("file status", rc, 11))
{
char *pnt = strchr(rc+11, ':');
if(pnt)
{
pnt++;
if(strstr(pnt, "finished"))
{
msk |= 32;
}
}
}
break;
default:
break;
}
}
pclose(GLOBALS->extload);
if(msk != (1+2+4+8+16+32))
{
fprintf(stderr, EXTLOAD"Could not initialize '%s' properly.\n", fname);
if((msk & (1+2+4+8+16+32)) == (1+2+4+8+16))
{
fprintf(stderr, EXTLOAD"File is not finished dumping.\n");
}
GLOBALS->extload_already_errored = 1;
return(LLDescriptor(0));
}
#endif
GLOBALS->min_time *= GLOBALS->time_scale;
GLOBALS->max_time *= GLOBALS->time_scale;
GLOBALS->mvlfacs_vzt_c_3=(struct fac *)calloc_2(GLOBALS->numfacs,sizeof(struct fac));
GLOBALS->vzt_table_vzt_c_1=(struct lx2_entry *)calloc_2(GLOBALS->numfacs, sizeof(struct lx2_entry));
GLOBALS->extload_namecache=(char **)calloc_2(GLOBALS->numfacs, sizeof(char *));
GLOBALS->extload_sym_block = (struct symbol *)calloc_2(GLOBALS->numfacs, sizeof(struct symbol));
GLOBALS->extload_node_block=(struct Node *)calloc_2(GLOBALS->numfacs,sizeof(struct Node));
GLOBALS->extload_idcodes=(unsigned int *)calloc_2(GLOBALS->numfacs, sizeof(unsigned int));
GLOBALS->extload_inv_idcodes=(int *)calloc_2(max_idcode+1, sizeof(int));
/* SPLASH */ splash_sync(1, 5);
#ifdef WAVE_FSDB_READER_IS_PRESENT
if(!GLOBALS->hier_was_explicitly_set) /* set default hierarchy split char */
{
GLOBALS->hier_delimeter='.';
}
GLOBALS->extload_xc = fstReaderOpenForUtilitiesOnly();
GLOBALS->extload_i=-1;
fsdbReaderReadScopeVarTree(GLOBALS->extload_ffr_ctx, extload_hiertree_callback);
process_extload_variable(NULL); /* flush out final cached variable */
decorated_module_cleanup(); /* ...also now in gtk2_treesearch.c */
iter_through_comp_name_table();
for(i=0; ((i<2)&&(i<GLOBALS->numfacs)); i++)
{
if(GLOBALS->extload_namecache[i])
{
free_2(GLOBALS->extload_namecache[i]);
GLOBALS->extload_namecache[i] = NULL;
}
}
free_2(GLOBALS->extload_namecache);
GLOBALS->extload_namecache = NULL;
fstReaderClose(GLOBALS->extload_xc); /* corresponds to fstReaderOpenForUtilitiesOnly() */
#else
if(!last_modification_check()) {
GLOBALS->extload_already_errored = 1;
return(LLDescriptor(0));
}
sprintf(sbuff, "%s -hier_tree %s 2>&1", EXTLOAD_PATH, fname);
GLOBALS->extload = popen(sbuff, "r");
/* do your stuff here..all useful info has been initialized by now */
if(!GLOBALS->hier_was_explicitly_set) /* set default hierarchy split char */
{
GLOBALS->hier_delimeter='.';
}
GLOBALS->extload_xc = fstReaderOpenForUtilitiesOnly();
for(GLOBALS->extload_i=-1; (GLOBALS->numfacs) && (GLOBALS->extload_i<GLOBALS->numfacs);)
{
process_extload_variable();
}
while(get_varname(&GLOBALS->extload_vt_prev, NULL, -1)); /* read through end to process all upscopes */
decorated_module_cleanup(); /* ...also now in gtk2_treesearch.c */
iter_through_comp_name_table();
for(i=0; ((i<2)&&(i<GLOBALS->numfacs)); i++)
{
if(GLOBALS->extload_namecache[i])
{
free_2(GLOBALS->extload_namecache[i]);
GLOBALS->extload_namecache[i] = NULL;
}
}
free_2(GLOBALS->extload_namecache);
GLOBALS->extload_namecache = NULL;
pclose(GLOBALS->extload);
fstReaderClose(GLOBALS->extload_xc); /* corresponds to fstReaderOpenForUtilitiesOnly() */
#endif
/* SPLASH */ splash_sync(2, 5);
GLOBALS->facs=(struct symbol **)malloc_2(GLOBALS->numfacs*sizeof(struct symbol *));
if(GLOBALS->fast_tree_sort)
{
for(i=0; i<GLOBALS->numfacs; i++)
{
int len;
GLOBALS->facs[i]=&GLOBALS->extload_sym_block[i];
if((len=strlen(GLOBALS->facs[i]->name))>GLOBALS->longestname) GLOBALS->longestname=len;
}
/* SPLASH */ splash_sync(3, 5);
fprintf(stderr, EXTLOAD"Building facility hierarchy tree.\n");
init_tree();
for(i=0; i<GLOBALS->numfacs; i++)
{
build_tree_from_name(GLOBALS->facs[i]->name, i);
}
/* SPLASH */ splash_sync(4, 5);
treegraft(&GLOBALS->treeroot);
fprintf(stderr, EXTLOAD"Sorting facility hierarchy tree.\n");
treesort(GLOBALS->treeroot, NULL);
/* SPLASH */ splash_sync(5, 5);
order_facs_from_treesort(GLOBALS->treeroot, &GLOBALS->facs);
GLOBALS->facs_are_sorted=1;
}
else
{
for(i=0; i<GLOBALS->numfacs; i++)
{
char *subst;
#ifdef WAVE_HIERFIX
char ch;
#endif
int len;
GLOBALS->facs[i]=&GLOBALS->extload_sym_block[i];
subst=GLOBALS->facs[i]->name;
if((len=strlen(subst))>GLOBALS->longestname) GLOBALS->longestname=len;
#ifdef WAVE_HIERFIX
while((ch=(*subst)))
{
if(ch==GLOBALS->hier_delimeter) {
*subst=VCDNAM_HIERSORT; /* forces sort at hier boundaries */
}
subst++;
}
#endif
}
/* SPLASH */ splash_sync(3, 5);
fprintf(stderr, EXTLOAD"Sorting facilities at hierarchy boundaries.\n");
wave_heapsort(GLOBALS->facs,GLOBALS->numfacs);
#ifdef WAVE_HIERFIX
for(i=0; i<GLOBALS->numfacs; i++)
{
char *subst, ch;
subst=GLOBALS->facs[i]->name;
while((ch=(*subst)))
{
if(ch==VCDNAM_HIERSORT) {
*subst=GLOBALS->hier_delimeter; /* restore back to normal */
}
subst++;
}
}
#endif
GLOBALS->facs_are_sorted=1;
/* SPLASH */ splash_sync(4, 5);
fprintf(stderr, EXTLOAD"Building facility hierarchy tree.\n");
init_tree();
for(i=0; i<GLOBALS->numfacs; i++)
{
char *nf = GLOBALS->facs[i]->name;
build_tree_from_name(nf, i);
}
/* SPLASH */ splash_sync(5, 5);
treegraft(&GLOBALS->treeroot);
treesort(GLOBALS->treeroot, NULL);
}
if(skip_start || skip_end)
{
TimeType b_start, b_end;
if(!skip_start) b_start = GLOBALS->min_time;
else b_start = unformat_time(skip_start, GLOBALS->time_dimension);
if(!skip_end) b_end = GLOBALS->max_time;
else b_end = unformat_time(skip_end, GLOBALS->time_dimension);
if(b_start<GLOBALS->min_time) b_start = GLOBALS->min_time;
else if(b_start>GLOBALS->max_time) b_start = GLOBALS->max_time;
if(b_end<GLOBALS->min_time) b_end = GLOBALS->min_time;
else if(b_end>GLOBALS->max_time) b_end = GLOBALS->max_time;
if(b_start > b_end)
{
TimeType tmp_time = b_start;
b_start = b_end;
b_end = tmp_time;
}
GLOBALS->min_time = b_start;
GLOBALS->max_time = b_end;
}
/* SPLASH */ splash_finalize();
return(GLOBALS->max_time);
}