static void
query (void)
{
                ...
  static GimpParamDef args[] =
  {
    { GIMP_PDB_INT32,    "run_mode", "Interactive, non-interactive" },
    { GIMP_PDB_IMAGE,    "image",    "Input image" },
    { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }
  };
  static GimpParamDef return_vals[] =
  {
    { GIMP_PDB_INT32, "num_colors", "Number of colors in the image" }
  };
  gimp_install_procedure ("plug_in_ccanalyze",
                          "Colorcube analysis",
                          "Analyze colorcube and print some information about "
                          "the current image (also displays a color-histogram)",
                          "robert@experimental.net",
                          "robert@experimental.net",
                          "June 20th, 1997",

                          N_("Colorcube A_nalysis..."),
                          "RGB*, GRAY*, INDEXED*",
                          GIMP_PLUGIN,
                          G_N_ELEMENTS (args), G_N_ELEMENTS (return_vals),
                          args, return_vals);
  gimp_plugin_menu_register ("plug_in_ccanalyze", "<Image>/Filters/Colors");
  gimp_plugin_menu_register ("plug_in_ccanalyze", "<Image>/Layer/Colors/Info");
}

static GnmValue *
gnumeric_index (FunctionEvalInfo *ei, GnmExprList *l)
{
                ...
	GnmExpr const *source;
	int elem[3] = { 0, 0, 0 };
	unsigned i = 0;
	gboolean valid;
	GnmValue *v, *res;
	if (l == NULL)

		return value_new_error_VALUE (ei->pos);
	source = l->data;
	l = l->next;
	for (i = 0; l != NULL && i < G_N_ELEMENTS (elem) ; i++, l = l->next) {
		v = value_coerce_to_number (
			gnm_expr_eval (l->data, ei->pos, GNM_EXPR_EVAL_SCALAR_NON_EMPTY),
			&valid, ei->pos);
                ...
		if (!valid)
			return v;
		elem[i] = value_get_as_int (v) - 1;
		value_release (v);
	}
	if (source->any.oper == GNM_EXPR_OP_SET) {
		source = gnm_expr_list_nth (source->set.set, elem[2]);
		if (elem[2] < 0 || source == NULL)
			return value_new_error_REF (ei->pos);
	} else if (elem[2] != 0)
		return value_new_error_REF (ei->pos);
	v = gnm_expr_eval (source, ei->pos, GNM_EXPR_EVAL_PERMIT_NON_SCALAR);
	if (elem[1] < 0 ||
	    elem[1] >= value_area_get_width (v, ei->pos) ||
	    elem[0] < 0 ||
	    elem[0] >= value_area_get_height (v, ei->pos)) {
		value_release (v);
		return value_new_error_REF (ei->pos);
	}
	res = value_dup (value_area_fetch_x_y (v, elem[1], elem[0], ei->pos));

	value_release (v);
	return res;
}

void query (void)
{
  static GimpParamDef load_args[] =
                ...
  {
    { GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
    { GIMP_PDB_STRING, "filename", "The name of the file to load" },
    { GIMP_PDB_STRING, "raw_filename", "The name of the file to load" },
  };
  static GimpParamDef load_return_vals[] =
  {
    { GIMP_PDB_IMAGE, "image", "Output image" },
  };
  gimp_install_procedure ("file_faxg3_load",
                          "loads g3 fax files",
			  "This plug-in loads Fax G3 Image files.",
                          "Jochen Friedrich",
                          "Jochen Friedrich, Gert Doering, Spencer Kimball & Peter Mattis",
                          VERSION,

			  N_("G3 fax image"),
			  NULL,
                          GIMP_PLUGIN,
                          G_N_ELEMENTS (load_args),
                          G_N_ELEMENTS (load_return_vals),
                          load_args, load_return_vals);
  gimp_register_file_handler_mime ("file_faxg3_load", "image/g3-fax");
  gimp_register_magic_load_handler ("file_faxg3_load",
                ...
				    "g3",

				    "",
				    "0,short,0x0001,0,short,0x0014");
}

static GstStructureAbbreviation *
gst_structure_get_abbrs (gint * n_abbrs)
{
                ...
  static GstStructureAbbreviation *abbrs = NULL;
  static gint num = 0;
  if (abbrs == NULL) {
    /* dynamically generate the array */
    GstStructureAbbreviation dyn_abbrs[] = {
      {"int", G_TYPE_INT}
      ,
      {"i", G_TYPE_INT}
      ,
      {"float", G_TYPE_FLOAT}
      ,
      {"f", G_TYPE_FLOAT}
      ,
      {"double", G_TYPE_DOUBLE}
      ,
      {"d", G_TYPE_DOUBLE}
      ,
      {"buffer", GST_TYPE_BUFFER}
      ,
      {"fourcc", GST_TYPE_FOURCC}
      ,
      {"4", GST_TYPE_FOURCC}
      ,
      {"fraction", GST_TYPE_FRACTION}
      ,
      {"boolean", G_TYPE_BOOLEAN}
      ,
      {"bool", G_TYPE_BOOLEAN}
      ,
      {"b", G_TYPE_BOOLEAN}
      ,
      {"string", G_TYPE_STRING}
      ,
      {"str", G_TYPE_STRING}

      ,
      {"s", G_TYPE_STRING}
    };
    num = G_N_ELEMENTS (dyn_abbrs);
    /* permanently allocate and copy the array now */
    abbrs = g_new0 (GstStructureAbbreviation, num);
    memcpy (abbrs, dyn_abbrs, sizeof (GstStructureAbbreviation) * num);
                ...
  }

  *n_abbrs = num;
  return abbrs;
}

static void
query (void)
{
                ...
  static GimpParamDef args[] =
  {
    { GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
    { GIMP_PDB_IMAGE, "image", "Input image" },
    { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
    { GIMP_PDB_FLOAT, "tile_size", "Average diameter of each tile (in pixels)" },
    { GIMP_PDB_FLOAT, "tile_saturation", "Expand tiles by this amount" },
    { GIMP_PDB_INT32, "bg_color", "Background color: { BLACK (0), BG (1) }" }
  };
  gimp_install_procedure ("plug_in_cubism",
                          "Convert the input drawable into a collection of rotated squares",
                          "Help not yet written for this plug-in",
                          "Spencer Kimball & Tracy Scott",
                          "Spencer Kimball & Tracy Scott",
                          "1996",

                          N_("_Cubism..."),
                          "RGB*, GRAY*",
                          GIMP_PLUGIN,
                          G_N_ELEMENTS (args), 0,
                          args, NULL);
  gimp_plugin_menu_register ("plug_in_cubism", "<Image>/Filters/Artistic");
}

void
rb_debug_init (gboolean debug)
{
                ...
	guint i;
	/* This is a workaround for the fact that there is not way to 
	 * make this useful debugging feature happen for ALL domains.
	 *
	 * What we did here is list all the ones we could think of that
	 * were interesting to us. It's OK to add more to the list.
	 */
	static const char * const standard_log_domains[] = {
		"",
		"Bonobo",
		"BonoboUI",
		"Echo",
		"Eel",
		"GConf",
		"GConf-Backends",
		"GConf-Tests",
		"GConfEd",
		"GLib",
		"GLib-GObject",
		"GModule",
		"GThread",
		"GStreamer",
		"Gdk",
		"Gdk-Pixbuf",
		"GdkPixbuf",
		"Glib",
		"Gnome",
		"GnomeCanvas",
		"GnomePrint",
		"GnomeUI",
		"GnomeVFS",
		"GnomeVFS-CORBA",
		"GnomeVFS-pthread",
		"GnomeVFSMonikers",
		"Gtk",
		"Rhythmbox",
		"RhythmDB",
		"MonkeyMedia",
		"ORBit",
		"ZVT",
		"libIDL",
		"libgconf-scm",
		"libglade",
		"libgnomevfs",
		"librsvg",

	};
	debugging = debug;
	if (debugging)
		for (i = 0; i < G_N_ELEMENTS (standard_log_domains); i++)
			g_log_set_handler (standard_log_domains[i], G_LOG_LEVEL_MASK, log_handler, NULL);
	rb_debug ("Debugging enabled");
}

static void
query (void)
{
                ...
  static GimpParamDef args[] =
  {
    { GIMP_PDB_INT32,    "run_mode", "Interactive, non-interactive" },
    { GIMP_PDB_IMAGE,    "image",    "Input image (used for indexed images)" },
    { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }
  };
  gimp_install_procedure ("plug_in_vinvert",
			  "Invert the 'value' component of an indexed/RGB "
                          "image in HSV colorspace",
			  "This function takes an indexed/RGB image and "
			  "inverts its 'value' in HSV space.  The upshot of "
			  "this is that the color and saturation at any given "
			  "point remains the same, but its brightness is "
			  "effectively inverted.  Quite strange.  Sometimes "
			  "produces unpleasant color artifacts on images from "
			  "lossy sources (ie. JPEG).",
			  "Adam D. Moss (adam@foxbox.org)",
			  "Adam D. Moss (adam@foxbox.org)",
			  "27th March 1997",

			  N_("_Value Invert"),
			  "RGB*, INDEXED*",
			  GIMP_PLUGIN,
			  G_N_ELEMENTS (args), 0,
			  args, NULL);
  gimp_plugin_menu_register ("plug_in_vinvert", "<Image>/Filters/Colors");
}

GtkActionGroup *
loqui_app_actions_create_group(LoquiApp *app)
{
                ...
	GtkActionGroup *action_group;
        action_group = gtk_action_group_new("LoquiApp");

	gtk_action_group_set_translate_func(action_group, gtkutils_menu_translate, NULL, NULL);
	gtk_action_group_add_actions(action_group,
				     loqui_action_entries,
				     G_N_ELEMENTS(loqui_action_entries),
				     app);
	gtk_action_group_add_toggle_actions(action_group,
					    loqui_toggle_action_entries,
					    G_N_ELEMENTS(loqui_toggle_action_entries),
					    app);
	gtk_action_group_add_radio_actions(action_group,
					   loqui_nick_list_sort_radio_action_entries,
                ...
					   G_N_ELEMENTS(loqui_nick_list_sort_radio_action_entries),
					   prefs_general.nick_list_sort_type,
					   G_CALLBACK(loqui_app_actions_nick_list_sort_radio_cb),
					   app);
	ACTION_GROUP_ACTION_SET_SENSITIVE(action_group, "PasteWithLinefeedsCut", FALSE);
	ACTION_GROUP_ACTION_SET_SENSITIVE(action_group, "Find", FALSE);

	ACTION_GROUP_ACTION_SET_SENSITIVE(action_group, "FindAgain", FALSE);
	return action_group;
}

static char const *
msole_prop_id_to_gsf (GsfMSOleMetaDataSection *section, guint32 id)
{
                ...
  char const *res = NULL;
  GsfMSOleMetaDataPropMap const *map = NULL;
  unsigned i = 0;
  if (section->dict != NULL) {
    if (id & 0x1000000) {
      id &= ~0x1000000;
      d (printf ("LINKED "););
    }
    res = g_hash_table_lookup (section->dict, GINT_TO_POINTER (id));
    if (res != NULL) {
      d (printf (res););
      return res;
    }

  }
  if (section->type == GSF_MSOLE_META_DATA_COMPONENT) {
    map = component_props;
    i = G_N_ELEMENTS (component_props);
  } else if (section->type == GSF_MSOLE_META_DATA_DOCUMENT) {
    map = document_props;
    i = G_N_ELEMENTS (document_props);
  }
  while (i-- > 0)
    if (map[i].id == id) {
                ...
      d (printf (map[i].name););
      return map[i].name;
    }
  map = common_props;
  i = G_N_ELEMENTS (common_props);
  while (i-- > 0)
    if (map[i].id == id) {
      d (printf (map[i].name););
      return map[i].name;
    }

  d (printf ("_UNKNOWN_(0x%x %d)", id, id););
  return NULL;
}

void
vino_init_stock_items (void)
{
                ...
  static gboolean  initialized = FALSE;
  GtkIconFactory  *factory;
  GtkStockItem    *items;
  int              i;
  if (initialized)

    return;
  factory = gtk_icon_factory_new ();
  gtk_icon_factory_add_default (factory);
  items = g_new (GtkStockItem, G_N_ELEMENTS (vino_stock_items));
  for (i = 0; i < G_N_ELEMENTS (vino_stock_items); i++)
    {
      GtkIconSet *icon_set;
      items [i].stock_id           = g_strdup (vino_stock_items [i].stock_id);
                ...
      items [i].label              = g_strdup (vino_stock_items [i].label);
      items [i].modifier           = 0;
      items [i].keyval             = 0;
      items [i].translation_domain = g_strdup (GETTEXT_PACKAGE);
      /* FIXME: does this take into account the theme? */
      icon_set = gtk_icon_factory_lookup_default (vino_stock_items [i].stock_icon_id);
      gtk_icon_factory_add (factory, vino_stock_items [i].stock_id, icon_set);
    }
  gtk_stock_add_static (items, G_N_ELEMENTS (vino_stock_items));

  g_object_unref (factory);
  initialized = TRUE;
}