Пример #1
0
int		jlst_in_jlst(j_list *great_list, j_list *to_search, int (*compare_func)(void*, void*))
{
    j_list  *tmpa;
    j_list  *tmpb;
    j_list  *tmpc;
    int     i[2];
    
    tmpa = great_list;
    i[1] = jlst_length(great_list) - jlst_length(to_search);
    i[0] = 0;
    while (tmpa && i[0] <= i[1])
    {
        tmpb = to_search;
        if (!compare_func(tmpa->data, tmpb->data))
        {
            tmpc = tmpa;
            while (tmpc && tmpb && !compare_func(tmpc->data, tmpb->data))
            {
                tmpc = tmpc->next;
                tmpb = tmpb->next;
            }
            if (tmpb == NULL)
                return (i[0]);
        }
        i[0]++;
        tmpa = tmpa->next;
    }
	return (-1);
}
Пример #2
0
/* ************************************************************************* *
 * クイックソート
 * ************************************************************************* */
void
quick_sort (struct profile	*p,
	    int			start,
	    int			end,
	    int			(*compare_func) (struct profile	*p1,
						 struct profile	*p2)) {
  struct profile	tmp, key;
  int			left, right;
    
  /* キーを決める */
  key = p[(start + end) / 2];
  
  /* 交換するデータを交換する */
  left = start;
  right = end;

  while (1) {
    while (compare_func(&key, &p[left])  > 0)  left++;
    while (compare_func(&key, &p[right]) < 0) right--;
    if (left >= right) break;
    tmp = p[left];
    p[left]  = p[right];
    p[right] = tmp;
  }
  /* 左部分をさらにソート */
  if (start < left - 1) quick_sort(p, start, left - 1, compare_func);

  /* 右部分をさらにソート */
  if (end > right + 1)  quick_sort(p, right + 1, end, compare_func);
}
Пример #3
0
SList *SList_merge(SList *left, SList *right,
                   SList_CompareFunc compare_func, gpointer user_data){
    register SList *merged = SList_create(left->set);
    register SList swap;
    g_assert(left->set == right->set);
    while(!(SList_isempty(left) || SList_isempty(right))){
        if(compare_func(left->head->next->data,
                        right->head->next->data, user_data)){
            SList_queue(merged, SList_pop(left));
        } else {
            SList_queue(merged, SList_pop(right));
            }
        }
    SList_join(merged, left);
    SList_join(merged, right);
    SList_destroy(left);
    /* Swap left and merged */
    swap.head = left->head;
    swap.tail = left->tail;
    left->head = merged->head;
    left->tail = merged->tail;
    merged->head = swap.head;
    merged->tail = swap.tail;
    return merged;
    }
Пример #4
0
static GSList* 
g_slist_sort_merge  (GSList      *l1, 
		     GSList      *l2,
		     GCompareFunc compare_func)
{
  GSList list, *l;

  l=&list;

  while (l1 && l2)
    {
      if (compare_func(l1->data,l2->data) < 0)
        {
	  l=l->next=l1;
	  l1=l1->next;
        } 
      else 
	{
	  l=l->next=l2;
	  l2=l2->next;
        }
    }
  l->next= l1 ? l1 : l2;
  
  return list.next;
}
Пример #5
0
MSList *ms_list_insert_sorted(MSList *list, void *data, int (*compare_func)(const void *, const void*)){
	MSList *it,*previt=NULL;
	MSList *nelem;
	MSList *ret=list;
	if (list==NULL) return ms_list_append(list,data);
	else{
		nelem=ms_list_new(data);
		for(it=list;it!=NULL;it=it->next){
			previt=it;
			if (compare_func(data,it->data)<=0){
				nelem->prev=it->prev;
				nelem->next=it;
				if (it->prev!=NULL)
					it->prev->next=nelem;
				else{
					ret=nelem;
				}
				it->prev=nelem;
				return ret;
			}
		}
		previt->next=nelem;
		nelem->prev=previt;
	}
	return ret;
}
Пример #6
0
/*===========================================================================
 
FUNCTION Q_LINEAR_SEARCH

DESCRIPTION
  Given a comparison function, this function traverses the elements in a
  queue, calls the compare function on each item, and returns a pointer to
  the current element's link if the user passed compare function returns
  non-zero on that element.

  The user compare function should return 0 if the current element is not
  the element in which the compare function is interested.

  The user compare function SHOULD NOT dequeue a node.

DEPENDENCIES
  The specified queue should have been initialized previously via a call to
  q_init.

RETURN VALUE
  A pointer to the found element's queue link.

SIDE EFFECTS
  A pointer to a linked element's link is returned without de-queuing the
  item.

===========================================================================*/
void *q_linear_search
(
  q_type              *q_ptr,          /* Queue to be traversed            */
  q_compare_func_type  compare_func,   /* Compare function to be called    */
  void                *compare_val     /* Cookie to pass to compare_func   */
)
{
  q_link_type *link_ptr = NULL;        /* Link to be returned              */
  /*- - - - - - - - - - - -  - - - - - - - - - - - - - - - - - - - - - - - */
  /*-------------------------------------------------------------------------
    Verify parameters.
  -------------------------------------------------------------------------*/
  ASSERT( NULL != q_ptr );
  ASSERT( NULL != compare_func );

  /*-------------------------------------------------------------------------
    Check that the queue is initialized.  Works if
    FEATURE_QUEUE_NO_STRICT_CHECK is turned off.
  -------------------------------------------------------------------------*/
  QUEUE_CHECK_INIT( q_ptr );

  link_ptr = q_check( q_ptr );

  while( NULL != link_ptr )
  {
    if( 0 != compare_func( link_ptr, compare_val ) )
    {
      break;
    }
    link_ptr = q_next( q_ptr, link_ptr );
  } /* while */

  return link_ptr;
} /* q_linear_search() */
Пример #7
0
bctbx_list_t* bctbx_list_insert_sorted(bctbx_list_t* list, void *data, bctbx_compare_func compare_func) {
    bctbx_list_t* it,*previt=NULL;
    bctbx_list_t* nelem;
    bctbx_list_t* ret=list;
    if (list==NULL) return bctbx_list_append(list,data);
    else {
        nelem=bctbx_list_new(data);
        for(it=list; it!=NULL; it=it->next) {
            previt=it;
            if (compare_func(data,it->data)<=0) {
                nelem->prev=it->prev;
                nelem->next=it;
                if (it->prev!=NULL)
                    it->prev->next=nelem;
                else {
                    ret=nelem;
                }
                it->prev=nelem;
                return ret;
            }
        }
        previt->next=nelem;
        nelem->prev=previt;
    }
    return ret;
}
Пример #8
0
static gint
filelist_compare_indirect(gconstpointer ap, gconstpointer bp, gpointer data)
{
	GCompareFunc compare_func = data;
	gconstpointer a = *(const gconstpointer*)ap;
	gconstpointer b = *(const gconstpointer*)bp;

	return compare_func(a, b);
}
Пример #9
0
/**
 * @brief Extract Node from single linked list
 *
 * @param list
 * @param compare_func
 * @param data
 *
 * @return pointer to Node or NULL(failled operation)
 */
Node* single_linked_list_get_Node(SingleLinkedList* list, COMPARE compare_func, void* data) {
   Node* node = list->head;
   while (node != NULL) {
      if (compare_func(node->data, data) == 0) {
         return node;
      }
      node = node->next;
   }
   return NULL;
}
Пример #10
0
bctbx_list_t * bctbx_list_remove_custom(bctbx_list_t *first, bctbx_compare_func compare_func, const void *user_data) {
    bctbx_list_t *cur;
    bctbx_list_t *elem = first;
    while (elem != NULL) {
        cur = elem;
        elem = elem->next;
        if (compare_func(cur->data, user_data) == 0) {
            first = bctbx_list_remove(first, cur->data);
        }
    }
    return first;
}
Пример #11
0
MSList * ms_list_remove_custom(MSList *first, MSCompareFunc compare_func, const void *user_data) {
	MSList *cur;
	MSList *elem = first;
	while (elem != NULL) {
		cur = elem;
		elem = elem->next;
		if (compare_func(cur->data, user_data) == 0) {
			first = ms_list_remove(first, cur->data);
		}
	}
	return first;
}
Пример #12
0
int		jlst_appears(j_list *first_node, void *data, int (*compare_func)(void*, void*))
{
	j_list	*tmp;

	tmp = first_node;
	while (tmp)
	{
		if (!compare_func(data, tmp->data))
			return (1);
		tmp = tmp->next;
	}
	return (0);
}
Пример #13
0
wmem_list_frame_t *
wmem_list_find_custom(wmem_list_t *list, const void *data, GCompareFunc compare_func)
{
    wmem_list_frame_t *cur;

    for (cur = list->head; cur != NULL; cur = cur->next) {
        if (compare_func(cur->data, data) == 0) {
            return cur;
        }
    }

    return NULL;
}
Пример #14
0
int compare_pnp_id(struct pnp_id *pos, const char *id)
{
	if (!pos || !id || (strlen(id) != 7))
		return 0;
	if (memcmp(id, "ANYDEVS", 7) == 0)
		return 1;
	while (pos) {
		if (memcmp(pos->id, id, 3) == 0)
			if (compare_func(pos->id, id) == 1)
				return 1;
		pos = pos->next;
	}
	return 0;
}
ngx_rbtree_node_t *
ngx_http_rwd_rbtree_lookup_value(ngx_rbtree_t *rbtree,
                                 ngx_rbtree_node_t *target,
                                 ngx_http_rwd_rbtree_compare_pt compare_func)
{
    ngx_rbtree_node_t *tmpnode = rbtree->root;

    while (tmpnode != rbtree->sentinel) {
        if (compare_func(target, tmpnode) == 0) {
            return tmpnode;
        }
    }

    return NULL;
}
Пример #16
0
void    jlst_del_data(j_list **first_node, void *data, int (*compare_func)(void*, void*))
{
    int     i;
    j_list  *tmp;
    
    i = 1;
    tmp = *first_node;
    while (tmp)
    {
        if (!compare_func(tmp->data, data))
            jlst_del_node(first_node, i);
        tmp = tmp->next;
        i++;
    }
}
Пример #17
0
metapixel_match_t
search_metapixel_nearest_to (int num_libraries, library_t **libraries,
			     coeffs_union_t *coeffs, metric_t *metric, int x, int y,
			     metapixel_t **forbidden, int num_forbidden,
			     unsigned int forbid_reconstruction_radius, unsigned int allowed_flips,
			     int (*validity_func) (void*, metapixel_t*, unsigned int, int, int),
			     void *validity_func_data)
{
    float best_score = FLT_MAX;
    metapixel_t *best_fit = 0;
    unsigned int best_index = (unsigned int)-1;
    unsigned int best_orientation = 0;
    compare_func_set_t *compare_func_set = metric_compare_func_set_for_metric(metric);
    metapixel_match_t match;
    /* allowed < 0 means we don't know.  0 means not allowed, >0 means allowed.  */
    int allowed;

    void check_orientation (metapixel_t *pixel, unsigned int pixel_index,
			    compare_func_t compare_func, unsigned int orientation)
	{
	    float score;

	    if (allowed == 0)
		return;

	    score = compare_func(coeffs, pixel, best_score, metric->color_space, metric->weights);

	    if (score < best_score)
	    {
		if (allowed < 0)
		    allowed = (!metapixel_in_array(pixel, forbidden, num_forbidden)
			       && (validity_func == 0
				   || validity_func(validity_func_data, pixel, pixel_index, x, y)))
			? 1 : 0;

		assert(allowed >= 0);

		if (allowed)
		{
		    best_score = score;
		    best_fit = pixel;
		    best_index = pixel_index;
		    best_orientation = orientation;
		}
	    }
	}
Пример #18
0
void
e_canvas_item_remove_selection (GnomeCanvasItem *item, gpointer id)
{
	int flags;
	ECanvas *canvas;
	ECanvasSelectionInfo *info;
	GList *list;

	g_return_if_fail(item != NULL);
	g_return_if_fail(GNOME_IS_CANVAS_ITEM(item));
	g_return_if_fail(item->canvas != NULL);
	g_return_if_fail(E_IS_CANVAS(item->canvas));

	flags = E_CANVAS_ITEM_SELECTION_DELETE_DATA;
	canvas = E_CANVAS(item->canvas);

	for (list = canvas->selection; list; list = g_list_next(list)) {
		info = list->data;

		if (info->item == item) {
			ECanvasItemSelectionCompareFunc compare_func;
			compare_func = (ECanvasItemSelectionCompareFunc)g_object_get_data(G_OBJECT(info->item),
											  "ECanvasItem::selection_compare_callback");

			if (compare_func(info->item, info->id, id, 0) == 0) {
				ECanvasItemSelectionFunc func;
				func = (ECanvasItemSelectionFunc) g_object_get_data(G_OBJECT(info->item),
										    "ECanvasItem::selection_callback");
				if (func)
					func(info->item, flags, info->id);
				canvas->selection = g_list_remove_link(canvas->selection, list);

				if (canvas->cursor == info)
					canvas->cursor = NULL;

				g_message ("ECANVAS: removing info: item %p, info %p",
					   info->item, info->id);
				g_object_unref (info->item);
				g_free(info);
				g_list_free_1(list);
				break;
			}
		}
	}
}
Пример #19
0
dlist* find_list_element_by_compare( dlist *destlist, list_element element, list_ele_compare compare_func )
{
	dlist *listitem;
	ASSERT( NULL != destlist );

	listitem = destlist;
	listitem = listitem->next;

	for( ; NULL != listitem; listitem = listitem->next )
	{
		if( 0 == compare_func( listitem->info, element ) )
		{
			return listitem->info;
		}
	}

	return NULL;
}
Пример #20
0
static fluid_list_t*
fluid_list_sort_merge(fluid_list_t *l1, fluid_list_t *l2, fluid_compare_func_t compare_func)
{
  fluid_list_t list, *l;

  l = &list;

  while (l1 && l2) {
    if (compare_func(l1->data,l2->data) < 0) {
      l = l->next = l1;
      l1 = l1->next;
    } else {
      l = l->next = l2;
      l2 = l2->next;
    }
  }
  l->next= l1 ? l1 : l2;

  return list.next;
}
Пример #21
0
/*===========================================================================
FUNCTION Q_LINEAR_SEARCH

DESCRIPTION
  Given a comparison function, this function traverses the elements in
  a queue, calls the compare function, and returns a pointer to the
  current element being compared if the user passed compare function
  returns non zero.

  The user compare function should return 0 if the current element is
  not the element in which the compare function is interested.

DEPENDENCIES
  The specified queue should have been initialized previously via a call
  to q_init.

  The user's queue elements must have q_link_type as the first element
  of the queued structure.

RETURN VALUE
  A pointer to the found element

SIDE EFFECTS
  None.
===========================================================================*/
void* q_linear_search(
   q_type             *q_ptr,
   q_compare_func_type compare_func,
   void               *compare_val
)
{
   q_generic_item_type *item_ptr = NULL;

   item_ptr = (q_generic_item_type*)q_check( q_ptr );

   while( item_ptr != NULL )
   {
      if( compare_func( item_ptr, compare_val ) != 0 )
      {
         return item_ptr;
      }
      item_ptr = (q_generic_item_type*)q_next( q_ptr, &item_ptr->link );
   } /* END while traversing the queue */

   return NULL;
} /* END q_linear_search */
Пример #22
0
int
ndi_fmc_entry_error(dev_info_t *dip, int flag, ddi_fm_error_t *derr,
    const void *bus_err_state)
{
	int status, fatal = 0, nonfatal = 0;
	ndi_fmc_t *fcp = NULL;
	ndi_fmcentry_t *fep;
	struct i_ddi_fmhdl *fmhdl;

	ASSERT(flag == DMA_HANDLE || flag == ACC_HANDLE);

	fmhdl = DEVI(dip)->devi_fmhdl;
	ASSERT(fmhdl);
	status = DDI_FM_UNKNOWN;

	if (flag == DMA_HANDLE && DDI_FM_DMA_ERR_CAP(fmhdl->fh_cap)) {
		fcp = fmhdl->fh_dma_cache;
		ASSERT(fcp);
	} else if (flag == ACC_HANDLE && DDI_FM_ACC_ERR_CAP(fmhdl->fh_cap)) {
		fcp = fmhdl->fh_acc_cache;
		ASSERT(fcp);
	}

	if (fcp != NULL) {

		/*
		 * Check active resource entries
		 */
		mutex_enter(&fcp->fc_lock);
		for (fep = fcp->fc_head; fep != NULL; fep = fep->fce_next) {
			ddi_fmcompare_t compare_func;

			/*
			 * Compare captured error state with handle
			 * resources.  During the comparison and
			 * subsequent error handling, we block
			 * attempts to free the cache entry.
			 */
			compare_func = (flag == ACC_HANDLE) ?
			    i_ddi_fm_acc_err_cf_get((ddi_acc_handle_t)
			    fep->fce_resource) :
			    i_ddi_fm_dma_err_cf_get((ddi_dma_handle_t)
			    fep->fce_resource);

			if (compare_func == NULL) /* unbound or not FLAGERR */
				continue;

			status = compare_func(dip, fep->fce_resource,
			    bus_err_state, fep->fce_bus_specific);
			if (status == DDI_FM_UNKNOWN || status == DDI_FM_OK)
				continue;

			if (status == DDI_FM_FATAL)
				++fatal;
			else if (status == DDI_FM_NONFATAL)
				++nonfatal;

			/* Set the error for this resource handle */
			if (flag == ACC_HANDLE) {
				ddi_acc_handle_t ap = fep->fce_resource;

				i_ddi_fm_acc_err_set(ap, derr->fme_ena, status,
				    DDI_FM_ERR_UNEXPECTED);
				ddi_fm_acc_err_get(ap, derr, DDI_FME_VERSION);
				derr->fme_acc_handle = ap;
			} else {
				ddi_dma_handle_t dp = fep->fce_resource;

				i_ddi_fm_dma_err_set(dp, derr->fme_ena, status,
				    DDI_FM_ERR_UNEXPECTED);
				ddi_fm_dma_err_get(dp, derr, DDI_FME_VERSION);
				derr->fme_dma_handle = dp;
			}
		}
		mutex_exit(&fcp->fc_lock);
	}
	return (fatal ? DDI_FM_FATAL : nonfatal ? DDI_FM_NONFATAL :
	    DDI_FM_UNKNOWN);
}
Пример #23
0
MSList *ms_list_find_custom(MSList *list, int (*compare_func)(const void *, const void*), const void *user_data){
	for(;list!=NULL;list=list->next){
		if (compare_func(list->data,user_data)==0) return list;
	}
	return NULL;
}
Пример #24
0
void
e_canvas_item_add_selection (GnomeCanvasItem *item, gpointer id)
{
	int flags;
	ECanvas *canvas;
	ECanvasSelectionInfo *info;
	ECanvasItemSelectionFunc func;
	GList *list;

	g_return_if_fail(item != NULL);
	g_return_if_fail(GNOME_IS_CANVAS_ITEM(item));
	g_return_if_fail(item->canvas != NULL);
	g_return_if_fail(E_IS_CANVAS(item->canvas));

	flags = E_CANVAS_ITEM_SELECTION_SELECT;
	canvas = E_CANVAS(item->canvas);

	if (canvas->cursor) {
		func = (ECanvasItemSelectionFunc)g_object_get_data(G_OBJECT(canvas->cursor->item),
								   "ECanvasItem::selection_callback");
		if (func)
			func(canvas->cursor->item, flags, canvas->cursor->id);
	}

	gnome_canvas_item_grab_focus(item);

	flags = E_CANVAS_ITEM_SELECTION_SELECT | E_CANVAS_ITEM_SELECTION_CURSOR;

	for (list = canvas->selection; list; list = g_list_next(list)) {
		ECanvasSelectionInfo *search;
		search = list->data;

		if (search->item == item) {
			ECanvasItemSelectionCompareFunc compare_func;
			compare_func = (ECanvasItemSelectionCompareFunc)g_object_get_data(G_OBJECT(search->item),
											  "ECanvasItem::selection_compare_callback");

			if (compare_func(search->item, search->id, id, 0) == 0) {
				canvas->cursor = search;
				func = (ECanvasItemSelectionFunc)g_object_get_data(G_OBJECT(item),
										   "ECanvasItem::selection_callback");
				if (func)
					func(item, flags, search->id);
				return;
			}
		}
	}

	info = g_new(ECanvasSelectionInfo, 1);
	info->item = item;
	g_object_ref (info->item);
	info->id = id;
	g_message ("ECANVAS: new info (2): item %p, id %p", item, id);

	func = (ECanvasItemSelectionFunc)g_object_get_data(G_OBJECT(item),
							   "ECanvasItem::selection_callback");
	if (func)
		func(item, flags, id);

	canvas->selection = g_list_prepend(canvas->selection, info);
	canvas->cursor = info;
}
Пример #25
0
static SListEntry *slist_sort_internal(SListEntry **list,
                                       SListCompareFunc compare_func) {
    SListEntry *pivot;
    SListEntry *rover;
    SListEntry *less_list, *more_list;
    SListEntry *less_list_end, *more_list_end;

    /* If there are less than two entries in this list, it is
     * already sorted */

    if (*list == NULL || (*list)->next == NULL) {
        return *list;
    }

    /* The first entry is the pivot */

    pivot = *list;

    /* Iterate over the list, starting from the second entry.  Sort
     * all entries into the less and more lists based on comparisons
     * with the pivot */

    less_list = NULL;
    more_list = NULL;
    rover = (*list)->next;

    while (rover != NULL) {
        SListEntry *next = rover->next;

        if (compare_func(rover->data, pivot->data) < 0) {

            /* Place this in the less list */

            rover->next = less_list;
            less_list = rover;

        } else {

            /* Place this in the more list */

            rover->next = more_list;
            more_list = rover;

        }

        rover = next;
    }

    /* Sort the sublists recursively */

    less_list_end = slist_sort_internal(&less_list, compare_func);
    more_list_end = slist_sort_internal(&more_list, compare_func);

    /* Create the new list starting from the less list */

    *list = less_list;

    /* Append the pivot to the end of the less list.  If the less list
     * was empty, start from the pivot */

    if (less_list == NULL) {
        *list = pivot;
    } else {
        less_list_end->next = pivot;
    }

    /* Append the more list after the pivot */

    pivot->next = more_list;

    /* Work out what the last entry in the list is.  If the more list was
     * empty, the pivot was the last entry.  Otherwise, the end of the
     * more list is the end of the total list. */

    if (more_list == NULL) {
        return pivot;
    } else {
        return more_list_end;
    }
}
Пример #26
0
belle_sip_list_t* belle_sip_list_find_custom(const belle_sip_list_t* list, belle_sip_compare_func compare_func, const void *user_data){
	for(;list!=NULL;list=list->next){
		if (compare_func(list->data,user_data)==0) return (belle_sip_list_t *)list;
	}
	return NULL;
}
Пример #27
0
	texture::settings& texture::settings::compare(texture::compare_func func, texture::compare_mode mode)
	{
		return compare_func(func).compare_mode(mode);
	}
Пример #28
0
static INLINE void
send_delta_events(part_evtlist_t *evlist, memsize_t cur_size, memsize_t prev_size,
					bool (*compare_func)(memsize_t delta, memsize_t last_sz, memsize_t cur_sz))
{
	elistdata_t  eld_p;
	mempart_evt_t  *reg_event = get_first_event(evlist, &eld_p);

	while (reg_event != NULL)
	{
		struct evt_info_s *evt = &reg_event->evt_reg;

		if (reg_event->onlist == &evlist->active)
		{
			memsize_t *delta_p = GET_DELTA_P(evt);
			CRASHCHECK(delta_p == NULL);

			initial_delta_conditions_check(reg_event, prev_size, (void *)compare_func);

			/* if this event has been deactivated, don't send it */
			if (evt->flags & evtflags_DEACTIVATE) {
				deactivate_event(evlist, (part_evt_t *)reg_event);
			}
			/* check for event send conditions */
			else if ((reg_event->evt_dest.rcvid > 0) &&
					 ((compare_func == NULL) ||
					  (compare_func(*delta_p, reg_event->evt_data.size, cur_size) == bool_t_TRUE)))
			{
				int r;
				struct sigevent se = evt->sig;		// make a local copy
				/*
				 * if the caller has set evtflags_SIGEV_FLAG_SIGINFO, we
				 * can return some useful information
				*/
				if (evt->flags & evtflags_SIGEV_FLAG_SIGINFO)
				{
					/*
					 * if the 'cur_size' is too large to fit in the sival_int field
					 * then send back UINT_MAX. This otherwise illegal size value
					 * (because UINT_MAX & (__PAGESIZE - 1) != 0) will be an indication
					 * to the event receiver that o information was provided and
					 * that they need to request the current size if they need it
					*/
					if (cur_size > UINT_MAX) {
						se.sigev_value.sival_int = UINT_MAX;
					} else {
						se.sigev_value.sival_int = (_Uint32t)cur_size;
					}
				}
				r = apm_deliver_event(&reg_event->evt_dest, &se);

				if (r == EOK) reg_event->undeliverable_count = 0;
				else if (r == ESRCH) ++reg_event->undeliverable_count;

				if ((reg_event->undeliverable_count > ORPHAN_RETRY_COUNT) ||
					(!(evt->flags & evtflags_REARM)))
				{
					/* remove the event from the list */
					deactivate_event(evlist, (part_evt_t *)reg_event);
				}
				else {
					reg_event->evt_data.size = cur_size;
				}
			}
		}
		reg_event = get_next_event(evlist, reg_event, &eld_p);
	}
}
static gchar *
recursive_compare (struct stat *localtime_stat,
                   const gchar *localtime_content,
                   gsize localtime_content_len,
                   const gchar *file,
                   CompareFiles compare_func,
                   GHashTable *ical_zones,
                   gint deep_level,
                   gchar **fallback)
{
	struct stat file_stat;

	if (g_stat (file, &file_stat) != 0)
		return NULL;

	if (S_ISREG (file_stat.st_mode)) {
		if (compare_func (localtime_stat,
				  &file_stat,
				  localtime_content,
				  localtime_content_len,
				  file)) {
			gchar *tz = system_timezone_strip_path_if_valid (file);

			if (deep_level <= 1 || (ical_zones && g_hash_table_lookup (ical_zones, tz))) {
				update_fallback (fallback, tz, ical_zones);
				return NULL;
			}

			if (ical_zones && !g_hash_table_lookup (ical_zones, tz)) {
				g_free (tz);
				return NULL;
			}

			return tz;
		} else
			return NULL;
	} else if (S_ISDIR (file_stat.st_mode)) {
		GDir       *dir = NULL;
		gchar       *ret = NULL;
		const gchar *subfile = NULL;
		gchar       *subpath = NULL;

		dir = g_dir_open (file, 0, NULL);
		if (dir == NULL)
			return NULL;

		while ((subfile = g_dir_read_name (dir)) != NULL) {
			subpath = g_build_filename (file, subfile, NULL);

			ret = recursive_compare (
				localtime_stat,
				localtime_content,
				localtime_content_len,
				subpath,
				compare_func,
				ical_zones,
				deep_level + 1,
				fallback);

			g_free (subpath);

			if (ret != NULL)
				break;
		}

		g_dir_close (dir);

		return ret;
	}

	return NULL;
}