static int megahal_reply(brain_t brain, list_t *input, list_t **output) {
dict_t *keywords;
list_t *current;
struct timespec start;
double surprise;
double max_surprise;
int ret;
*output = NULL;
ret = megahal_keywords(brain, input, &keywords);
if (ret) return ret;
ret = megahal_generate(brain, NULL, output);
if (ret) {
dict_free(&keywords);
return ret;
}
if (!list_equal(input, *output))
list_free(output);
ret = clock_gettime(CLOCK_MONOTONIC, &start);
if (ret) {
ret = -ECLOCK;
goto fail;
}
max_surprise = -1.0;
do {
ret = megahal_generate(brain, keywords, ¤t);
if (ret) goto fail;
ret = megahal_evaluate(brain, keywords, current, &surprise);
if (ret) goto fail;
if (surprise > max_surprise && !list_equal(input, current)) {
max_surprise = surprise;
list_free(output);
*output = current;
} else {
list_free(¤t);
}
} while(!megahal_timeout(start));
dict_free(&keywords);
return OK;
fail:
list_free(output);
dict_free(&keywords);
return ret;
}
/* check if anything has changed for this bookmark */
static bool should_update_bookmark(url_t *url)
{
if(url->noupdate)
return false;
/* don't update bookmark if username has changed */
if(url->username && strcmp(url->username, ftp->url->username) != 0)
return false;
if(url->directory && strcmp(url->directory, ftp->curdir) != 0)
return true;
if(!url->directory && strcmp(ftp->curdir, ftp->homedir) != 0)
return true;
if(xstrcmp(url->hostname, ftp->url->hostname) != 0)
return true;
if(url->port != ftp->url->port)
return true;
if(!list_equal(url->mech, ftp->url->mech, (listsortfunc)strcasecmp) != 0)
return true;
if(xstrcmp(url->protlevel, ftp->url->protlevel) != 0)
return true;
if(url->pasvmode != ftp->url->pasvmode && ftp->url->pasvmode != -1)
return true;
if(xstrcmp(url->protocol, ftp->url->protocol) != 0)
return true;
if(xstrcmp(url->sftp_server, ftp->url->sftp_server) != 0)
return true;
return false;
}
void
extensions__dlg_preferences_apply (GtkWidget *dialog,
GthBrowser *browser,
GtkBuilder *dialog_builder)
{
BrowserData *data;
GList *active_extensions;
GthExtensionManager *manager;
GList *extension_names;
GList *scan;
data = g_object_get_data (G_OBJECT (dialog), BROWSER_DATA_KEY);
g_return_if_fail (data != NULL);
active_extensions = NULL;
manager = gth_main_get_default_extension_manager ();
extension_names = gth_extension_manager_get_extensions (manager);
for (scan = extension_names; scan; scan = scan->next) {
char *extension_name = scan->data;
GthExtensionDescription *description;
description = gth_extension_manager_get_description (manager, extension_name);
if ((description == NULL) || description->mandatory || description->hidden)
continue;
if (gth_extension_description_is_active (description))
active_extensions = g_list_prepend (active_extensions, g_strdup (extension_name));
}
active_extensions = g_list_reverse (active_extensions);
_g_settings_set_string_list (data->settings, PREF_GENERAL_ACTIVE_EXTENSIONS, active_extensions);
if (! list_equal (active_extensions, data->active_extensions)) {
GtkWidget *dialog;
int response;
dialog = _gtk_message_dialog_new (GTK_WINDOW (data->dialog),
GTK_DIALOG_MODAL,
_GTK_ICON_NAME_DIALOG_WARNING,
_("Restart required"),
_("You need to restart gthumb for these changes to take effect"),
_("_Continue"), GTK_RESPONSE_CANCEL,
_("_Restart"), GTK_RESPONSE_OK,
NULL);
response = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
if (response == GTK_RESPONSE_OK)
gth_quit (TRUE);
}
g_list_foreach (active_extensions, (GFunc) g_free, NULL);
g_list_free (active_extensions);
g_list_free (extension_names);
}
/**
* Tests if the two queues are equal.
*/
bool_t queue_equal(const queue_t* cpque_first, const queue_t* cpque_second)
{
assert(cpque_first != NULL);
assert(cpque_second != NULL);
#ifdef CSTL_QUEUE_LIST_SEQUENCE
return list_equal(&cpque_first->_t_sequence, &cpque_second->_t_sequence);
#else
return deque_equal(&cpque_first->_t_sequence, &cpque_second->_t_sequence);
#endif
}
static inline bool
aggregate_changed(int agg_type, void *v1, void *v2)
{
switch(agg_type) {
case AGG_FIRST:
return false;
case AGG_MIN_INT:
case AGG_MAX_INT:
case AGG_SUM_INT:
return MELD_INT(v1) != MELD_INT(v2);
case AGG_MIN_FLOAT:
case AGG_MAX_FLOAT:
case AGG_SUM_FLOAT:
return MELD_FLOAT(v1) != MELD_FLOAT(v2);
case AGG_SET_UNION_INT:
case AGG_SET_UNION_FLOAT: {
Set *setOld = MELD_SET(v1);
Set *setNew = MELD_SET(v2);
if(!set_equal(setOld, setNew))
return true;
/* delete new set union */
set_delete(setNew);
return false;
}
break;
case AGG_SUM_LIST_INT:
case AGG_SUM_LIST_FLOAT: {
List *listOld = MELD_LIST(v1);
List *listNew = MELD_LIST(v2);
if(!list_equal(listOld, listNew))
return true;
/* delete new list */
list_delete(listNew);
return false;
}
break;
default:
assert(0);
return true;
}
assert(0);
while(1);
}
/**
* Tests if the two stacks are equal.
*/
bool_t stack_equal(const cstl_stack_t* cpsk_first, const cstl_stack_t* cpsk_second)
{
assert(cpsk_first != NULL);
assert(cpsk_second != NULL);
#if defined (CSTL_STACK_VECTOR_SEQUENCE)
return vector_equal(&cpsk_first->_t_sequence, &cpsk_second->_t_sequence);
#elif defined (CSTL_STACK_LIST_SEQUENCE)
return list_equal(&cpsk_first->_t_sequence, &cpsk_second->_t_sequence);
#else
return deque_equal(&cpsk_first->_t_sequence, &cpsk_second->_t_sequence);
#endif
}
/* Builds the canonical collection of sets into C[] and nC. Prints
the sets to stdout if debugging is enabled. */
static void
build_canonical_sets (void)
{
int i;
nC = 1;
list_init (&C[0]);
list_add (&C[0], 0, 0);
calc_closure (&C[0], &C[0]);
for (i = 0; i < nC; i++)
{
int X;
for (X = 0; X < n_symbols; X++)
{
struct list list;
calc_goto (&list, &C[i], symbols[X].sym);
if (list_count (&list))
{
int j;
for (j = 0; j < nC; j++)
if (list_equal (&list, &C[j]))
break;
if (j >= nC)
{
assert (nC < MAX_LOL_COUNT);
C[nC++] = list;
}
else
list_free (&list);
}
else
list_free (&list);
}
}
if (debug)
{
printf ("Canonical collection of sets:\n");
for (i = 0; i < nC; i++)
{
printf ("\tI(%d) = ", i);
list_print (&C[i]);
putchar ('\n');
}
}
}
void testrandomlists(int n, int size)
{
for(int i=0; i<n; i++)
{
int list[size];
int check[size];
fill_random(list, size);
list_copy(list, check, size);
insertionSort(list, size);
insertionSortSafe(check, size);
if(!list_equal(list, check, size))
printf("FAIL!\n");
}
}
static struct ps_map_entry * ps_map_insert(struct ps_map * map, LIST * key)
{
unsigned hash_val = list_hash( key );
unsigned bucket = hash_val % map->table_size;
struct ps_map_entry * pos;
for ( pos = map->table[bucket]; pos ; pos = pos->next )
{
if ( list_equal( pos->key, key ) )
return pos;
}
if ( map->num_elems >= map->table_size )
{
ps_map_rehash( map );
bucket = hash_val % map->table_size;
}
pos = BJAM_MALLOC( sizeof( struct ps_map_entry ) );
pos->next = map->table[bucket];
pos->key = key;
pos->value = 0;
map->table[bucket] = pos;
++map->num_elems;
return pos;
}
LIST *
hcache( TARGET *t, LIST *hdrscan )
{
HCACHEDATA cachedata, *c = &cachedata;
HCACHEFILE *file;
LIST *l = 0;
int use_cache = 1;
const char *target;
# ifdef DOWNSHIFT_PATHS
char path[ MAXJPATH ];
char *p;
# endif
target = t->boundname;
# ifdef DOWNSHIFT_PATHS
p = path;
do *p++ = (char)tolower( *target );
while( *target++ );
target = path;
# endif
++queries;
c->boundname = target;
file = hcachefile_get( t );
// if ( file )
{
if( hashcheck( hcachehash, (HASHDATA **) &c ) )
{
#ifdef OPT_BUILTIN_MD5CACHE_EXT
if( c->time == t->time && md5matchescommandline( t ) )
#else
if( c->time == t->time )
#endif
{
if( !list_equal(hdrscan, c->hdrscan) )
use_cache = 0;
}
else
use_cache = 0;
if( use_cache ) {
if( DEBUG_HEADER )
printf( "using header cache for %s\n", t->boundname );
c->age = 0; /* The entry has been used, its young again */
++hits;
l = list_copy( 0, c->includes );
{
LIST *hdrfilter = var_get( "HDRFILTER" );
if ( list_first(hdrfilter) )
{
LOL lol;
lol_init( &lol );
lol_add( &lol, list_append( L0, t->name, 1 ) );
lol_add( &lol, l );
lol_add( &lol, list_append( L0, t->boundname, 0 ) );
l = evaluate_rule( list_value(list_first(hdrfilter)), &lol, NULL );
lol_free( &lol );
}
}
return l;
}
else {
if( DEBUG_HEADER )
printf( "header cache out of date for %s\n", t->boundname );
list_free( c->includes );
list_free( c->hdrscan );
c->includes = 0;
c->hdrscan = 0;
}
} else {
if( hashenter( hcachehash, (HASHDATA **)&c ) ) {
c->boundname = newstr( c->boundname );
c->file = file;
c->next = c->file->hcachelist;
c->file->hcachelist = c;
#ifdef OPT_BUILTIN_MD5CACHE_EXT
c->mtime = 0;
memset( &c->rulemd5sum, 0, MD5_SUMSIZE );
memset( &c->currentrulemd5sum, 0, MD5_SUMSIZE );
memset( &c->contentmd5sum, 0, MD5_SUMSIZE );
memset( &c->currentcontentmd5sum, 0, MD5_SUMSIZE );
#endif
}
}
}
c->file->dirty = 1;
/* 'c' points at the cache entry. Its out of date. */
l = headers1( c->boundname, hdrscan );
l = list_appendList( list_copy( 0, var_get( "HDREXTRA" ) ), l );
c->includes = list_copy( 0, l );
{
LIST *hdrfilter = var_get( "HDRFILTER" );
if (list_first(hdrfilter))
{
LOL lol;
lol_init( &lol );
lol_add( &lol, list_append( L0, t->name, 1 ) );
lol_add( &lol, l );
lol_add( &lol, list_append( L0, t->boundname, 0 ) );
l = evaluate_rule( list_value(list_first(hdrfilter)), &lol, NULL );
lol_free( &lol );
}
}
c->time = t->time;
c->age = 0;
c->hdrscan = list_copy( 0, hdrscan );
return l;
}
int test_lists() {
int len = 0;
// create a list of integers (li1) from 1 to SIZE
DLL *li1 = list_sequence(1, SIZE);
// copy the list to li2
DLL *li2 = list_copy(li1);
// remove each individual item from left side of li2 and
// append to right side of li3 (preserving order)
DLL *li3 = list_new();
// compare li2 and li1 for equality
if (!list_equal(li2, li1)) {
print("li2!=li1\n");
while(1);
}
while (!list_empty(li2)) {
list_push_tail(li3, list_pop_head(li2));
}
// li2 must now be empty
if (!list_empty(li2)) {
print("li2 ne\n");
while(1);
}
// remove each individual item from right side of li3 and
// append to right side of li2 (reversing list)
while (!list_empty(li3)) {
list_push_tail(li2, list_pop_tail(li3));
}
// li3 must now be empty
if (!list_empty(li3)) {
print( "li3 ne\n");
while(1);
}
// reverse li1 in place
list_reverse(li1);
// check that li1's first item is now SIZE
if (list_first(li1)->val != SIZE) {
print( "li1 stw\n");
while(1);
}
// check that li1's last item is now 1
if (list_last(li1)->val != 1) {
print( "lstw\n");
while(1);
}
// check that li2's first item is now SIZE
if (list_first(li2)->val != SIZE) {
print( "li2 stw\n");
while(1);
}
// check that li2's last item is now 1
if (list_last(li2)->val != 1) {
print( "lstw\n");
while(1);
}
// check that li1's length is still SIZE
if (list_length(li1) != SIZE) {
print( "li1 szw\n");
while(1);
}
// compare li1 and li2 for equality
if (!list_equal(li1, li2)) {
print( "li1!=li2\n");
while(1);
}
len = list_length(li1);
// free(li1);
// free(li2);
// free(li3);
// return the length of the list
printnum(len);
print("\n");
return 0;
}
/* Builds and outputs to stdout the action table for the parser,
including enumerated types for actions and lexemes. */
static void
build_action_table (void)
{
unsigned char **actions;
int i;
actions = xmalloc (sizeof *actions * nC);
for (i = 0; i < nC; i++)
{
actions[i] = xmalloc (sizeof **actions * (n_symbols + 1));
memset (actions[i], 0, sizeof **actions * (n_symbols + 1));
}
for (i = 0; i < nC; i++)
{
int j;
for (j = 0; j < list_count (&C[i]); j++)
{
const struct item *item = list_item (&C[i], j);
const struct production *prod = &G[item->prod];
const struct symbol *A = find_symbol (prod->left);
if (item_n_after_dot (item) > 0)
{
struct symbol *a;
a = find_symbol (item_symbol_after_dot (item));
if (!a->nonterminal)
{
struct list list;
int k;
calc_goto (&list, &C[i], a->sym);
for (k = 0; k < nC; k++)
if (list_equal (&list, &C[k]))
set_action (actions, i, a - symbols, 2 + k);
list_free (&list);
}
}
else if (A->sym != G[0].left)
{
const struct set *follow_A = &A->follow;
int k;
for (k = 0; k < follow_A->n; k++)
{
int c;
int index;
c = follow_A->which[k];
if (c == '$')
index = n_symbols;
else
index = find_symbol (c) - symbols;
set_action (actions, i, index, 2 + nC + (prod - G));
}
}
if (list_contains (&C[i], 0, 1))
set_action (actions, i, n_symbols, 1);
}
}
fputs ("/* Actions used in action_table[][] entries. */\n"
"enum\n"
" {\n"
" err,\t/* Error. */\n"
" acc,\t/* Accept. */\n"
"\n"
" /* Shift actions. */\n", stdout);
print_enum_list ('s', 0, nC - 1);
fputs ("\n"
" /* Reduce actions. */\n", stdout);
print_enum_list ('r', 1, n_grammar);
printf ("\n"
" n_states = %d,\n"
" n_terminals = %d,\n"
" n_nonterminals = %d,\n"
" n_reductions = %d\n"
" };\n"
"\n"
"/* Symbolic token names used in parse_table[][] second index. */\n"
"enum\n"
" {\n",
nC, n_terminals + 1, n_nonterminals, n_grammar);
for (i = 0; i < n_symbols; i++)
{
struct symbol *sym = &symbols[i];
int j;
if (sym->nonterminal)
continue;
for (j = 0; j < n_tokens; j++)
if (tokens[j].token == sym->sym)
break;
assert (j < n_tokens);
printf (" %s,%*c/* %c */\n",
tokens[j].name, 25 - (int) strlen (tokens[j].name), ' ',
sym->sym);
}
fputs (" lex_stop /* $ */\n"
" };\n"
"\n"
"/* Action table. This is action[][] from Fig. 4.30, \"LR parsing\n"
" program\", in Aho, Sethi, and Ullman. */\n"
"static const unsigned char action_table[n_states][n_terminals] =\n"
" {\n"
" /* ", stdout);
for (i = 0; i < n_symbols; i++)
if (!symbols[i].nonterminal)
printf (" %c ", symbols[i].sym);
fputs (" $ */\n", stdout);
for (i = 0; i < nC; i++)
{
int j;
printf (" /*%3d */ {", i);
for (j = 0; j <= n_symbols; j++)
if (j == n_symbols || !symbols[j].nonterminal)
{
char buf[16];
if (j != 0)
putchar (',');
action_name (buf, actions[i][j]);
printf ("%3s", buf);
}
fputs ("},\n", stdout);
}
fputs (" };\n\n", stdout);
for (i = 0; i < nC; i++)
free (actions[i]);
free (actions);
}
/* Builds and prints to stdout the goto table for this parser. */
static void
build_goto_table (void)
{
unsigned char **gotos;
int i;
gotos = xmalloc (sizeof *gotos * nC);
for (i = 0; i < nC; i++)
{
gotos[i] = xmalloc (sizeof **gotos * n_nonterminals);
memset (gotos[i], 0, sizeof **gotos * n_nonterminals);
}
for (i = 0; i < nC; i++)
{
int j;
for (j = 0; j < n_symbols; j++)
{
struct symbol *A;
struct list list;
A = &symbols[j];
if (A->nonterminal)
{
int k;
calc_goto (&list, &C[i], A->sym);
for (k = 0; k < nC; k++)
if (list_equal (&list, &C[k]))
{
gotos[i][A->nt_index] = k;
break;
}
list_free (&list);
}
}
}
fputs ("/* Go to table. This is goto[][] from Fig. 4.30, \"LR parsing\n"
" program\", in Aho, Sethi, and Ullman. */\n"
"static const unsigned char goto_table[n_states][n_nonterminals] =\n"
" {\n"
" /* ", stdout);
for (i = 0; i < n_symbols; i++)
if (symbols[i].nonterminal)
printf (" %c ", symbols[i].sym);
fputs ("*/\n", stdout);
for (i = 0; i < nC; i++)
{
int j;
printf (" /*%3d */ {", i);
for (j = 0; j < n_symbols; j++)
{
struct symbol *sym = &symbols[j];
if (sym->nonterminal)
{
if (sym->nt_index != 0)
putchar (',');
printf ("%2d", gotos[i][sym->nt_index]);
}
}
fputs ("},\n", stdout);
}
fputs (" };\n\n", stdout);
for (i = 0; i < nC; i++)
free (gotos[i]);
free (gotos);
}
int compare_entry_state (Entry_State *entry1, Entry_State *entry2, int run)
{
int j;
int error = 0;
/* first - quick check for present / not present */
for (j = 0; j < sim.value_count; j++)
{
if (entry1->values[j].present != entry2->values[j].present)
{
fprintf (sim.fout,
"value %s is %s present in the first run but %s present in the %d run\n",
g_values[j], entry1->values[j].present ? "" : "not",
entry2->values[j].present ? "" : "not", run);
error = 1;
}
}
if (error)
return 3;
/* compare value state */
error = 0;
if (entry1->attr_delete_csn != entry2->attr_delete_csn)
{
fprintf (sim.fout, "attribute delete csn is %d for run 1 "
"but is %d for run %d\n", entry1->attr_delete_csn,
entry2->attr_delete_csn, run);
error = 1;
}
for (j = 0; j < sim.value_count; j++)
{
if (entry1->values[j].presense_csn != entry2->values[j].presense_csn)
{
fprintf (sim.fout, "presence csn for value %s is %d in run 1 "
"but is %d in run %d\n", g_values[j], entry1->values[j].presense_csn,
entry2->values[j].presense_csn, run);
error = 1;
}
if (entry1->values[j].distinguished_csn != entry2->values[j].distinguished_csn)
{
fprintf (sim.fout, "distinguished csn for value %s is %d in run 1 "
"but is %d in run %d\n", g_values[j], entry1->values[j].distinguished_csn,
entry2->values[j].distinguished_csn, run);
error = 1;
}
if (entry1->values[j].delete_csn != entry2->values[j].delete_csn)
{
fprintf (sim.fout, "delete csn for value %s is %d in run 1 "
"but is %d in run %d\n", g_values[j], entry1->values[j].delete_csn,
entry2->values[j].delete_csn, run);
error = 1;
}
if (!list_equal (entry1->values[j].non_distinguished_csns,
entry2->values[j].non_distinguished_csns))
{
fprintf (sim.fout, "pending list mismatch for valye %s in runs 1 and %d\n",
g_values[j], run);
dump_list (entry1->values[j].non_distinguished_csns);
dump_list (entry2->values[j].non_distinguished_csns);
}
}
if (error != 0)
{
return 1;
}
else
return 0;
}
char list_not_equal(array x, array y) {
return !list_equal(x,y);
}
