static void delete_lines_from_scrobble_log (GSList **lines_to_remove_ptr, gchar *queuepath) {
    GSList *lines_to_remove = *lines_to_remove_ptr;
    gchar *contents = NULL;
    gchar **lines = NULL;
    gchar **finallines = g_malloc_n(1, sizeof(gchar *));
    int n_finallines;

    if (lines_to_remove == NULL) {
        return;
    }
    lines_to_remove = g_slist_reverse(lines_to_remove);


    pthread_mutex_lock(&log_access_mutex);

    gboolean success = g_file_get_contents(queuepath, &contents, NULL, NULL);
    if (!success) {
        AUDDBG("Could not read scrobbler.log contents.\n");
    } else {
        lines = g_strsplit(contents, "\n", 0);

        n_finallines = 0;
        for (int i = 0 ; lines[i] != NULL && strlen(lines[i]) > 0; i++) {
            if (lines_to_remove != NULL && *((int *) (lines_to_remove->data)) == i) {
                //this line is to remove
                lines_to_remove = g_slist_next(lines_to_remove);
            } else {
                //keep this line
                n_finallines++;
                finallines = g_realloc_n(finallines, n_finallines, sizeof(gchar *));
                finallines[n_finallines-1] = g_strdup(lines[i]);
            }
        }

        finallines = g_realloc_n(finallines, n_finallines+2, sizeof(gchar *));
        finallines[n_finallines] = g_strdup("");
        finallines[n_finallines+1] = NULL;
        g_free(contents);
        contents = g_strjoinv("\n", finallines);
        success = g_file_set_contents(queuepath, contents, -1, NULL);
        if (!success) {
            AUDDBG("Could not write to scrobbler.log!\n");
        }

    }

    pthread_mutex_unlock(&log_access_mutex);


    g_strfreev(finallines);
    g_strfreev(lines);
    g_free(contents);
}
Ejemplo n.º 2
0
static void
nimf_settings_page_key_update_gsettings_strv (NimfSettingsPageKey *page_key,
                                              GtkTreeModel        *model)
{
  gchar       **vals;
  GtkTreeIter   iter;
  gint          i;

  vals = g_malloc0_n (1, sizeof (gchar *));

  if (gtk_tree_model_get_iter_first (model, &iter))
  {
    i = 0;
    do {
      gtk_tree_model_get (model, &iter, 0, &vals[i], -1);
      vals = g_realloc_n (vals, sizeof (gchar *), i + 2);
      vals[i + 1] = NULL;
      i++;
    } while (gtk_tree_model_iter_next (model, &iter));
  }

  g_settings_set_strv (page_key->gsettings,
                       page_key->key, (const gchar **) vals);

  g_strfreev (vals);
}
Ejemplo n.º 3
0
static inline libvlc_instance_t *
create_vlc_instance(void)
{
	gchar	**vlc_argv;
	gint	vlc_argc = 0;

	libvlc_instance_t *ret;

	vlc_argv = g_malloc_n(2, sizeof(vlc_argv[0]));
	vlc_argv[vlc_argc++] = g_strdup(g_get_prgname());

#if LIBVLC_VERSION_INT < LIBVLC_VERSION(2,0,0,0)
	if (g_getenv("VLC_PLUGIN_PATH") != NULL) {
		vlc_argv = g_realloc_n(vlc_argv,
				       vlc_argc + 2 + 1, sizeof(vlc_argv[0]));
		vlc_argv[vlc_argc++] = g_strdup("--plugin-path");
		vlc_argv[vlc_argc++] = g_strdup(g_getenv("VLC_PLUGIN_PATH"));
	}
#endif

	vlc_argv[vlc_argc] = NULL;

	ret = libvlc_new((int)vlc_argc, (const char *const *)vlc_argv);

	g_strfreev(vlc_argv);
	return ret;
}
Ejemplo n.º 4
0
void *g_try_realloc_n(void *ptr, size_t nmemb, size_t size)
{
    int nomem;

    if (nomem) {
        return NULL;
    }
    return g_realloc_n(ptr, nmemb, size);
}
Ejemplo n.º 5
0
/**
 * irc_strv_append:
 * @array: (transfer full) (nullable): Array to append
 * @str: String to append
 *
 * If @array is %NULL new array is allocated.
 * If @str is %NULL nothing is appended.
 *
 * Returns: (transfer full): Newly re-allocated array. Free with g_strfreev()
 */
GStrv
irc_strv_append (GStrv array, const char *str)
{
	if (str == NULL)
		return array;

	const gsize len = array ? g_strv_length (array) : 0;
	GStrv new_array = g_realloc_n (array, len + 2, sizeof(char*));
	new_array[len] = g_strdup (str);
	new_array[len + 1] = NULL;
	return new_array;
}
Ejemplo n.º 6
0
/**
 * uber_buffer_set_size:
 * @buffer: A #UberBuffer.
 * @size: The number of elements that @buffer should contain.
 *
 * Resizes the circular buffer.
 *
 * Returns: None.
 * Side effects: None.
 */
void
uber_buffer_set_size (UberBuffer *buffer, /* IN */
                      gint        size)   /* IN */
{
	gint count;

	g_return_if_fail(buffer != NULL);
	g_return_if_fail(size > 0);

	if (size == buffer->len) {
		return;
	}
	if (size > buffer->len) {
		buffer->buffer = g_realloc_n(buffer->buffer, size, sizeof(gdouble));
		uber_buffer_clear_range(buffer, buffer->len, size);
		if ((count = buffer->len - buffer->pos)) {
			memmove(&buffer->buffer[size - count],
			        &buffer->buffer[buffer->pos],
			        count * sizeof(gdouble));
			if (size - count > buffer->pos) {
				uber_buffer_clear_range(buffer, 0, size - count - buffer->pos);
			}
		}
		buffer->len = size;
		return;
	}
	if (size >= buffer->pos) {
		memmove(&buffer->buffer[buffer->pos],
		        &buffer->buffer[size],
		        (buffer->len - size) * sizeof(gdouble));
		buffer->buffer = g_realloc_n(buffer->buffer, size, sizeof(gdouble));
		buffer->len = size;
		return;
	}
	memmove(buffer->buffer, &buffer->buffer[buffer->pos - size],
	        size * sizeof(gdouble));
	buffer->buffer = g_realloc_n(buffer->buffer, size, sizeof(gdouble));
	buffer->pos = 0;
	buffer->len = size;
}
Ejemplo n.º 7
0
static void torchat_parse_latency(struct im_connection *ic, char *address, char* line)
{
	bee_user_t *bu = bee_user_by_handle(ic->bee, ic, address);
	int size = 1;
	char** argv = g_realloc_n(NULL, size, sizeof(char*));

	char **pieces, **pieceptr, *piece;

	pieceptr = pieces = g_strsplit(line, " ", 0);

	while ((piece = *pieceptr++) && strlen(piece)) {
		argv = g_realloc_n(argv, ++size, sizeof(char*));
		argv[size - 2] = piece;
	}

	argv[size - 1] = 0;

	imcb_buddy_action_response(bu, "PING", argv, NULL);

	g_free(argv);
	g_strfreev(pieces);
}
Ejemplo n.º 8
0
static void
ensure_seat_slot_allocated (ClutterSeatEvdev *seat,
                            int               seat_slot)
{
  if (seat_slot >= seat->n_alloc_touch_states)
    {
      const int size_increase = 5;
      int i;

      seat->n_alloc_touch_states += size_increase;
      seat->touch_states = g_realloc_n (seat->touch_states,
                                        seat->n_alloc_touch_states,
                                        sizeof (ClutterTouchState *));
      for (i = 0; i < size_increase; i++)
        seat->touch_states[seat->n_alloc_touch_states - (i + 1)] = NULL;
    }
}
Ejemplo n.º 9
0
static int sqlfs_write(const char *path, const char *buf, size_t size,
		       off_t offset, struct fuse_file_info *fi)
{
  int err = 0;
  sqlfs_file_t *fsfile = g_hash_table_lookup(cache.open_table, &(fi->fh));

  if (fsfile && fsfile->buffer) {
    size_t len = strlen(fsfile->buffer);
    if (len < size + offset)
      fsfile->buffer = g_realloc_n(fsfile->buffer, size + offset + 1,
				   sizeof(gchar ));
    g_strlcpy(fsfile->buffer + offset, buf, size + 1);
    err = size;
    fsfile->flush = TRUE;
  }
  else
    err = -ENOENT;

  return err;
}
Ejemplo n.º 10
0
void
libwacom_update_match(WacomDevice *device, const WacomMatch *newmatch)
{
	int i;

	for (i = 0; i < device->nmatches; i++) {
		const char *matchstr = libwacom_match_get_match_string(device->matches[i]);
		if (g_strcmp0(matchstr, newmatch->match) == 0) {
			device->match = i;
			return;
		}
	}

	device->nmatches++;

	device->matches = g_realloc_n(device->matches, device->nmatches + 1, sizeof(WacomMatch*));
	device->matches[device->nmatches] = NULL;
	device->matches[device->nmatches - 1] = libwacom_copy_match(newmatch);
	device->match = device->nmatches - 1;
}
Ejemplo n.º 11
0
/**
 * dfl_time_sequence_append:
 * @sequence: a #DflTimeSequence
 * @timestamp: TODO
 *
 * TODO
 *
 * Note that the pointers returned from dfl_time_sequence_append() may change
 * if dfl_time_sequence_append() is called again, due to internal reallocations.
 * The returned pointer is only valid until the next call to
 * dfl_time_sequence_append().
 *
 * Returns: (transfer none): TODO
 * Since: 0.1.0
 */
gpointer
dfl_time_sequence_append (DflTimeSequence *sequence,
                          DflTimestamp     timestamp)
{
  DflTimeSequenceReal *self = (DflTimeSequenceReal *) sequence;
  DflTimestamp last_timestamp;
  gpointer last_element;
  DflTimeSequenceElement *element;

  g_return_val_if_fail (sequence != NULL, NULL);
  g_return_val_if_fail (self->n_elements_valid < G_MAXSIZE, NULL);

  /* Check @timestamp is monotonically increasing. */
  last_element = dfl_time_sequence_get_last_element (sequence, &last_timestamp);
  g_return_val_if_fail (last_element == NULL || timestamp >= last_timestamp,
                       NULL);

  /* Do we need to expand the array first? */
  if (self->n_elements_valid == self->n_elements_allocated)
    {
      self->n_elements_allocated =
        ((gsize) 1 << (g_bit_nth_msf (self->n_elements_allocated, -1) + 1));
      self->elements = g_realloc_n (self->elements, self->n_elements_allocated,
                                    sizeof (DflTimeSequenceElement) +
                                    self->element_size);
    }

  g_assert (self->n_elements_allocated > self->n_elements_valid);

  /* Append the new element. */
  self->n_elements_valid++;

  element = dfl_time_sequence_index (sequence, self->n_elements_valid - 1);
  element->timestamp = timestamp;

  return element->data;
}
Ejemplo n.º 12
0
void *g_realloc(void *ptr, size_t size)
{
    return g_realloc_n(ptr, 1, size);
}
Ejemplo n.º 13
0
static void
mem_overflow (void)
{
  gsize a = G_MAXSIZE / 10 + 10;
  gsize b = 10;
  gpointer p, q;
  typedef char X[10];

#define CHECK_PASS(P)	p = (P); g_assert (p == NULL);
#define CHECK_FAIL(P)	p = (P); g_assert (p != NULL);

  CHECK_PASS (g_try_malloc_n (a, a));
  CHECK_PASS (g_try_malloc_n (a, b));
  CHECK_PASS (g_try_malloc_n (b, a));
  CHECK_FAIL (g_try_malloc_n (b, b));

  CHECK_PASS (g_try_malloc0_n (a, a));
  CHECK_PASS (g_try_malloc0_n (a, b));
  CHECK_PASS (g_try_malloc0_n (b, a));
  CHECK_FAIL (g_try_malloc0_n (b, b));

  q = g_malloc (1);
  CHECK_PASS (g_try_realloc_n (q, a, a));
  CHECK_PASS (g_try_realloc_n (q, a, b));
  CHECK_PASS (g_try_realloc_n (q, b, a));
  CHECK_FAIL (g_try_realloc_n (q, b, b));
  free (p);

  CHECK_PASS (g_try_new (X, a));
  CHECK_FAIL (g_try_new (X, b));

  CHECK_PASS (g_try_new0 (X, a));
  CHECK_FAIL (g_try_new0 (X, b));

  q = g_try_malloc (1);
  CHECK_PASS (g_try_renew (X, q, a));
  CHECK_FAIL (g_try_renew (X, q, b));
  free (p);

#undef CHECK_FAIL
#undef CHECK_PASS

#define CHECK_FAIL(P)	if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR)) { p = (P); exit (0); } g_test_trap_assert_failed();
#define CHECK_PASS(P)	if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR)) { p = (P); exit (0); } g_test_trap_assert_passed();

  CHECK_FAIL (g_malloc_n (a, a));
  CHECK_FAIL (g_malloc_n (a, b));
  CHECK_FAIL (g_malloc_n (b, a));
  CHECK_PASS (g_malloc_n (b, b));

  CHECK_FAIL (g_malloc0_n (a, a));
  CHECK_FAIL (g_malloc0_n (a, b));
  CHECK_FAIL (g_malloc0_n (b, a));
  CHECK_PASS (g_malloc0_n (b, b));

  q = g_malloc (1);
  CHECK_FAIL (g_realloc_n (q, a, a));
  CHECK_FAIL (g_realloc_n (q, a, b));
  CHECK_FAIL (g_realloc_n (q, b, a));
  CHECK_PASS (g_realloc_n (q, b, b));
  free (q);

  CHECK_FAIL (g_new (X, a));
  CHECK_PASS (g_new (X, b));

  CHECK_FAIL (g_new0 (X, a));
  CHECK_PASS (g_new0 (X, b));

  q = g_malloc (1);
  CHECK_FAIL (g_renew (X, q, a));
  CHECK_PASS (g_renew (X, q, b));
  free (q);
}
Ejemplo n.º 14
0
static void
gimp_color_history_set_property (GObject      *object,
                                 guint         property_id,
                                 const GValue *value,
                                 GParamSpec   *pspec)
{
  GimpColorHistory *history = GIMP_COLOR_HISTORY (object);

  switch (property_id)
    {
    case PROP_CONTEXT:
      history->context = g_value_get_object (value);
      break;
    case PROP_HISTORY_SIZE:
        {
          GtkWidget *button;
          gint       i;

          /* Destroy previous color buttons. */
          gtk_container_foreach (GTK_CONTAINER (history),
                                 (GtkCallback) gtk_widget_destroy, NULL);
          history->history_size = g_value_get_int (value);
          gtk_table_resize (GTK_TABLE (history),
                            2, (history->history_size + 1)/ 2);
          gtk_table_set_row_spacings (GTK_TABLE (history), 2);
          gtk_table_set_col_spacings (GTK_TABLE (history), 2);
          history->color_areas = g_realloc_n (history->color_areas,
                                              history->history_size,
                                              sizeof (GtkWidget*));
          for (i = 0; i < history->history_size; i++)
            {
              GimpRGB black = { 0.0, 0.0, 0.0, 1.0 };
              gint    row, column;

              column = i % (history->history_size / 2);
              row    = i / (history->history_size / 2);

              button = gtk_button_new ();
              gtk_widget_set_size_request (button, COLOR_AREA_SIZE, COLOR_AREA_SIZE);
              gtk_table_attach_defaults (GTK_TABLE (history), button,
                                         column, column + 1, row, row + 1);
              gtk_widget_show (button);

              history->color_areas[i] = gimp_color_area_new (&black,
                                                             GIMP_COLOR_AREA_SMALL_CHECKS,
                                                             GDK_BUTTON2_MASK);
              gtk_container_add (GTK_CONTAINER (button), history->color_areas[i]);
              gtk_widget_show (history->color_areas[i]);

              g_signal_connect (button, "clicked",
                                G_CALLBACK (gimp_color_history_color_clicked),
                                history);

              g_signal_connect (history->color_areas[i], "color-changed",
                                G_CALLBACK (gimp_color_history_color_changed),
                                GINT_TO_POINTER (i));
            }
        }
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
      break;
    }
}