D reversed_list(D list){
if(list->next != NULL){
D a = make_copy(list);
D r = reversed_list(list->next);
a->next = NULL;
append_list(r, a);
return r;
}else{
return make_copy(list);
}
}
/*
* This function returns the elements that are have been removed in
* compared to previous and update previous.
*/
struct String_vector* removed_and_set(const struct String_vector* current,
struct String_vector** previous) {
struct String_vector* diff = malloc(sizeof(struct String_vector));
int count = 0;
int i;
for(i = 0; i < (* previous)->count; i++) {
if (!contains((* previous)->data[i], current)) {
count++;
}
}
allocate_vector(diff, count);
int prev_count = count;
count = 0;
for(i = 0; i < (* previous)->count; i++) {
if (!contains((* previous)->data[i], current)) {
diff->data[count] = malloc(sizeof(char) * strlen((* previous)->data[i]));
strcpy(diff->data[count++], (* previous)->data[i]);
}
}
assert(prev_count == count);
free_vector((struct String_vector*) *previous);
(*previous) = make_copy(current);
return diff;
}
void push_data(D stack, D data){
int cnt = stack->intv++;
for(; cnt>0; cnt--)
stack = stack->next;
data = make_copy(data);
if(data->next != NULL)
data = make_sublist(data);
stack->next = data;
}
int main(int argc, char const *argv[])
{
if(argc > 0) {
make_copy(get_argv(argv));
}
else {
printf("no argument\n");
}
return 0;
}
void add_to_cache(cache_t cache, key_type key, val_type val, uint32_t val_size){
//adds in a new item in the location of the cache
key_type key_copy = make_copy(key,strlen((char*)key)+1);
key_val_s new_item;
new_item.key = key_copy;
new_item.val = make_copy(val,val_size);
new_item.val_size = val_size;
//give the policy the pointer to the key so that it can read the value of the key when
//the policy teels it about evictions in ids_to_delete_if_added
new_item.policy_info = create_info(cache->evic_policy,(void*)(key_copy),val_size);
assign_to_link(querry_hash(cache,key),new_item);
cache->mem_used += val_size;
cache->num_elements++;
//resizes table if load factor is over 0.5
if(cache->num_elements*2 > cache->table_size){
resize_table(cache,cache->table_size*2);
}
}
main()
{
int i;
char *ptr, *string = "find the bugs!";
for(i=0; i<10000; i++) {
ptr = malloc(BLOCKSIZE);
strcpy(ptr, string);
make_copy(i, ptr);
free(ptr);
}
}
void
gtk_hex_entry_value_changed (GtkHexEntry *hex_entry)
{
g_return_if_fail (hex_entry != NULL);
g_return_if_fail (GTK_IS_HEX_ENTRY (hex_entry));
if (hex_entry->modified == FALSE)
{
make_copy (hex_entry,TRUE);
}
gtk_signal_emit (GTK_OBJECT (hex_entry), hex_entry_signals[SIG_VALUE_CHANGED]);
}
main(int argc, char *argv[])
{
char *file;
file = make_copy(find_lisp_orig());
spawn_nuker(file);
if (execv(file, argv) < 0) {
char buffer[256];
sprintf(buffer, "execv(%s)", file);
perror(buffer);
exit(1);
}
}
int
main(int argc, char** argv) {
struct so_long sols[N + 1];
make_it_so_long(sols + 1, 2);
make_it_so_long(sols + 2, 5);
make_it_so_long(sols + 3, 13);
int i;
for (i = 4; i < N + 1; i++) {
make_copy(sols + i, sols + i - 1);
in_place_add(sols + i, sols + i - 1);
in_place_add(sols + i, sols + i - 2);
in_place_add(sols + i, sols + i - 3);
}
while (scanf("%d", &i) == 1) {
print_so_long(sols + i);
printf("\n");
}
return 0;
}
void
gtk_hex_entry_set_value (GtkHexEntry *hex_entry, gulong arg)
{
gint i,j;
g_return_if_fail (hex_entry != NULL);
g_return_if_fail (GTK_IS_HEX_ENTRY (hex_entry));
for (i=hex_entry->digits; i; --i)
{
j = hex_entry->digits-i;
hex_entry->buffer[j] = ((arg >> ((i-1)*4)) & 0xf) + 0x30;
if (hex_entry->buffer[j]>'9') hex_entry->buffer[j] += 7;
}
make_copy (hex_entry,FALSE);
gtk_signal_emit (GTK_OBJECT (hex_entry), hex_entry_signals[SIG_VALUE_CHANGED]);
queue_draw (hex_entry);
}
/* Process a single .desc line.
*/
static int
process_line( SymbolTable *st, const char *text )
{
char line[1024];
#ifdef DEBUG
printf( "read: %s\n", text );
#endif /*DEBUG*/
/* We destroy line during the parse.
*/
im_strncpy( line, text, 1024 );
if( im_isprefix( "#LRJOIN ", line ) ||
im_isprefix( "#TBJOIN ", line ) ) {
/* Yes: magic join command. Break into tokens. Format is eg.
#LRJOIN <left> <right> <out> <x> <y> [<mwidth>]
*/
char *item[MAX_ITEMS];
int nitems;
JoinType type;
JoinNode *arg1, *arg2, *join;
int dx, dy, mwidth;
if( (nitems = break_items( line, item )) < 0 )
return( -1 );
if( nitems != 5 && nitems != 6 ) {
im_error( "global_balance",
_( "bad number of args in join line" ) );
return( -1 );
}
if( !(arg1 = add_node( st, item[0] )) ||
!(arg2 = add_node( st, item[1] )) ||
!(join = add_node( st, item[2] )) )
return( -1 );
dx = atoi( item[3] );
dy = atoi( item[4] );
if( nitems == 6 )
mwidth = atoi( item[5] );
else
mwidth = -1;
if( im_isprefix( "#LRJOIN ", line ) )
type = JOIN_LR;
else
type = JOIN_TB;
if( make_join( st, type, arg1, arg2,
join, 1.0, 0.0, dx, dy, mwidth ) )
return( -1 );
}
else if( im_isprefix( "#LRROTSCALE ", line ) ||
im_isprefix( "#TBROTSCALE ", line ) ) {
/* Rot + scale. Format is eg.
#LRROTSCALE <left> <right> <out> \
<a> <b> <x> <y> [<mwidth>]
*/
char *item[MAX_ITEMS];
int nitems;
JoinType type;
JoinNode *arg1, *arg2, *join;
double a, b, dx, dy;
int mwidth;
if( (nitems = break_items( line, item )) < 0 )
return( -1 );
if( nitems != 7 && nitems != 8 ) {
im_error( "global_balance",
_( "bad number of args in join1 line" ) );
return( -1 );
}
if( !(arg1 = add_node( st, item[0] )) ||
!(arg2 = add_node( st, item[1] )) ||
!(join = add_node( st, item[2] )) )
return( -1 );
a = g_ascii_strtod( item[3], NULL );
b = g_ascii_strtod( item[4], NULL );
dx = g_ascii_strtod( item[5], NULL );
dy = g_ascii_strtod( item[6], NULL );
if( nitems == 8 )
mwidth = atoi( item[7] );
else
mwidth = -1;
if( im_isprefix( "#LRROTSCALE ", line ) )
type = JOIN_LRROTSCALE;
else
type = JOIN_TBROTSCALE;
if( make_join( st, type, arg1, arg2,
join, a, b, dx, dy, mwidth ) )
return( -1 );
}
else if( im_isprefix( "copy ", line ) ) {
/* im_copy() call ... make a JOIN_CP node.
*/
char *item[MAX_ITEMS];
int nitems;
JoinNode *before, *after;
if( (nitems = break_items( line, item )) < 0 )
return( -1 );
if( nitems != 2 ) {
im_error( "global_balance",
_( "bad number of args in copy line" ) );
return( -1 );
}
if( !(before = add_node( st, item[0] )) ||
!(after = add_node( st, item[1] )) ||
make_copy( st, before, after ) )
return( -1 );
}
return( 0 );
}
WordNode * processQuery(char * query, HashTable *index){
//TODO: eat leftover from the buffer
if (NULL == strchr(query, '\n')){
printf("Whoa there. You entered too many characters. Query must exit.");
return NULL;
}
//if there is more than 1000 characters. didn't handle yet.
printf("\n");
// get first word in query
char * pch = strtok(query," \n");
if(pch == NULL){
fprintf(stdout, "No input specified. \n");
printf("QUERY>: ");
return init_list();
}
if ((strcmp("OR", pch) == 0) || (strcmp("AND",pch) == 0)) {
fprintf(stderr, "Invalid input. AND/OR cannot start your search query. please use a non-operator word to search \n");
printf("QUERY>: ");
return NULL;
}
//initialize search results
int or = -1; //set to negative one on first run
WordNode * search_results = NULL;
WordNode * tmp_list = NULL;
// go through rest of the query string
while (pch != NULL)
{
//check if OR or AND
if (strcmp("OR", pch) == 0) {
// printf("or here");
or = 1;
pch = strtok (NULL, " \n");
continue;
} else if (strcmp("AND", pch) == 0) {
// printf("and here");
or = 0;
pch = strtok (NULL, " \n");
continue;
}
// switch to lowercase
NormalizeWord(pch);
if(or == 1){
// fprintf(stdout,"Doing OR");
if (search_results) {
// if there has been an OR before, now unionize
search_results = unionize(search_results, tmp_list);
} else {
// only the first or
// need to hold on to previous list
search_results = tmp_list;
}
// set tmp_list to the new list word
tmp_list = make_copy((WordNode *) get_value(pch ,index));
} else if (or == 0){
// printf("Doing AND");
// get intersect
tmp_list = intersection(tmp_list, make_copy(get_value(pch ,index)));
} else {
// first run (or = -1)
tmp_list = make_copy((WordNode *) get_value(pch ,index));
// if(tmp_list){
// fprintf(stderr, "GOT SOMETHING!!\n");
// if (tmp_list->head)
// fprintf(stderr, "here is something %d", tmp_list->head->docID);
// }
}
or = 0; // "marks AND for next"
pch = strtok (NULL, " \n");
} //end search loop
// in the end, unionize the two lists!
search_results = unionize(search_results, tmp_list);
return search_results;
}
static gint
gtk_hex_entry_key_press (GtkWidget *widget, GdkEventKey *event)
{
GtkHexEntry *hex_entry;
int key;
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_HEX_ENTRY (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
hex_entry = GTK_HEX_ENTRY (widget);
if (hex_entry->editable == FALSE) return FALSE;
if (hex_entry->cursor_position==-1)
hex_entry->cursor_position = 0;
key = event->keyval;
switch (key)
{
case GDK_Return:
case GDK_KP_Enter:
make_copy (hex_entry,FALSE);
hex_entry->cursor_position = 0;
gtk_signal_emit (GTK_OBJECT (hex_entry), hex_entry_signals[SIG_ACTIVATE]);
break;
case GDK_F1:
if (hex_entry->modified)
{
make_undo (hex_entry,FALSE);
gtk_signal_emit (GTK_OBJECT (hex_entry), hex_entry_signals[SIG_VALUE_CHANGED]);
}
break;
case GDK_plus:
case GDK_KP_Add:
gtk_hex_entry_set_value (hex_entry,
gtk_hex_entry_get_value(hex_entry)+1);
break;
case GDK_KP_Subtract:
case GDK_minus:
gtk_hex_entry_set_value (hex_entry,
gtk_hex_entry_get_value(hex_entry)-1);
break;
case GDK_KP_Page_Up:
case GDK_Page_Up:
gtk_hex_entry_set_value (hex_entry,
gtk_hex_entry_get_value(hex_entry)+256);
break;
case GDK_KP_Page_Down:
case GDK_Page_Down:
gtk_hex_entry_set_value (hex_entry,
gtk_hex_entry_get_value(hex_entry)-256);
break;
case GDK_Delete:
case GDK_Clear:
case GDK_KP_Delete:
move_beginning_of_line(hex_entry);
gtk_hex_entry_set_value (hex_entry,0);
break;
case GDK_BackSpace:
move_backward_character(hex_entry);
hex_entry->buffer[hex_entry->cursor_position] = '0';
gtk_hex_entry_value_changed (hex_entry);
break;
case GDK_Home:
move_beginning_of_line(hex_entry);
break;
case GDK_End:
move_end_of_line(hex_entry);
break;
case GDK_Left:
move_backward_character(hex_entry);
break;
case GDK_Right:
move_forward_character(hex_entry);
break;
case GDK_KP_0...GDK_KP_9:
key -= GDK_KP_0;
key += '0';
default:
if ( ((key>='0')&&(key<='9')) || ((key>='a')&&(key<='f')) || ((key>='A')&&(key<='F')))
{
hex_entry->buffer[hex_entry->cursor_position] = toupper(key);
move_forward_character(hex_entry);
gtk_hex_entry_value_changed (hex_entry);
break;
}
else return FALSE;
}
queue_draw (hex_entry);
return TRUE;
}
/**
* the result will be stored in target
*/
void
intact_add(struct so_long* target, struct so_long* lhs, struct so_long* rhs) {
make_copy(target, lhs);
in_place_add(target, rhs);
}
/**
* the result will be stored in lhs
*/
void
in_place_mul(struct so_long* lhs, struct so_long* rhs) {
struct so_long target;
intact_mul(&target, lhs, rhs);
make_copy(lhs, &target);
}
