Allow G_OPTION_ARG_CALLBACK for G_OPTION_REMAINING. (#437297, Dave Benson)
[platform/upstream/glib.git] / glib / goption.c
1 /* goption.c - Option parser
2  *
3  *  Copyright (C) 1999, 2003 Red Hat Software
4  *  Copyright (C) 2004       Anders Carlsson <andersca@gnome.org>
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Library General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Library General Public License for more details.
15  *
16  * You should have received a copy of the GNU Library General Public
17  * License along with this library; if not, write to the
18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19  * Boston, MA 02111-1307, USA.
20  */
21
22 #include "config.h"
23
24 #include "goption.h"
25 #include "glib.h"
26 #include "glibintl.h"
27 #include "gprintf.h"
28
29 #include "galias.h"
30
31 #include <string.h>
32 #include <stdlib.h>
33 #include <stdio.h>
34 #include <errno.h>
35
36 #define TRANSLATE(group, str) (((group)->translate_func ? (* (group)->translate_func) ((str), (group)->translate_data) : (str)))
37
38 #define NO_ARG(entry) ((entry)->arg == G_OPTION_ARG_NONE ||       \
39                        ((entry)->arg == G_OPTION_ARG_CALLBACK &&  \
40                         ((entry)->flags & G_OPTION_FLAG_NO_ARG)))
41
42 #define OPTIONAL_ARG(entry) ((entry)->arg == G_OPTION_ARG_CALLBACK &&  \
43                        (entry)->flags & G_OPTION_FLAG_OPTIONAL_ARG)
44
45 typedef struct 
46 {
47   GOptionArg arg_type;
48   gpointer arg_data;  
49   union 
50   {
51     gboolean bool;
52     gint integer;
53     gchar *str;
54     gchar **array;
55     gdouble dbl;
56     gint64 int64;
57   } prev;
58   union 
59   {
60     gchar *str;
61     struct 
62     {
63       gint len;
64       gchar **data;
65     } array;
66   } allocated;
67 } Change;
68
69 typedef struct
70 {
71   gchar **ptr;
72   gchar *value;
73 } PendingNull;
74
75 struct _GOptionContext
76 {
77   GList           *groups;
78
79   gchar           *parameter_string;
80   gchar           *summary;
81   gchar           *description;
82
83   GTranslateFunc   translate_func;
84   GDestroyNotify   translate_notify;
85   gpointer         translate_data;
86
87   guint            help_enabled   : 1;
88   guint            ignore_unknown : 1;
89   
90   GOptionGroup    *main_group;
91
92   /* We keep a list of change so we can revert them */
93   GList           *changes;
94   
95   /* We also keep track of all argv elements 
96    * that should be NULLed or modified.
97    */
98   GList           *pending_nulls;
99 };
100
101 struct _GOptionGroup
102 {
103   gchar           *name;
104   gchar           *description;
105   gchar           *help_description;
106
107   GDestroyNotify   destroy_notify;
108   gpointer         user_data;
109
110   GTranslateFunc   translate_func;
111   GDestroyNotify   translate_notify;
112   gpointer         translate_data;
113
114   GOptionEntry    *entries;
115   gint             n_entries;
116
117   GOptionParseFunc pre_parse_func;
118   GOptionParseFunc post_parse_func;
119   GOptionErrorFunc error_func;
120 };
121
122 static void free_changes_list (GOptionContext *context,
123                                gboolean        revert);
124 static void free_pending_nulls (GOptionContext *context,
125                                 gboolean        perform_nulls);
126
127
128 static int
129 _g_unichar_get_width (gunichar c)
130 {
131   if (G_UNLIKELY (g_unichar_iszerowidth (c)))
132     return 0;
133
134   /* we ignore the fact that we should call g_unichar_iswide_cjk() under
135    * some locales (legacy East Asian ones) */
136   if (g_unichar_iswide (c))
137     return 2;
138
139   return 1;
140 }
141
142 static glong
143 _g_utf8_strwidth (const gchar *p,
144                   gssize       max)
145 {
146   glong len = 0;
147   const gchar *start = p;
148   g_return_val_if_fail (p != NULL || max == 0, 0);
149
150   if (max < 0)
151     {
152       while (*p)
153         {
154           len += _g_unichar_get_width (g_utf8_get_char (p));
155           p = g_utf8_next_char (p);
156         }
157     }
158   else
159     {
160       if (max == 0 || !*p)
161         return 0;
162
163       /* this case may not be quite correct */
164       
165       len += _g_unichar_get_width (g_utf8_get_char (p));
166       p = g_utf8_next_char (p);          
167
168       while (p - start < max && *p)
169         {
170           len += _g_unichar_get_width (g_utf8_get_char (p));
171           p = g_utf8_next_char (p);          
172         }
173     }
174
175   return len;
176 }
177
178
179 GQuark
180 g_option_error_quark (void)
181 {
182   return g_quark_from_static_string ("g-option-context-error-quark");
183 }
184
185 /**
186  * g_option_context_new:
187  * @parameter_string: a string which is displayed in
188  *    the first line of <option>--help</option> output, after the
189  *    usage summary 
190  *    <literal><replaceable>programname</replaceable> [OPTION...]</literal>
191  *
192  * Creates a new option context. 
193  *
194  * The @parameter_string can serve multiple purposes. It can be used
195  * to add descriptions for "rest" arguments, which are not parsed by
196  * the #GOptionContext, typically something like "FILES" or
197  * "FILE1 FILE2...". If you are using #G_OPTION_REMAINING for
198  * collecting "rest" arguments, GLib handles this automatically by
199  * using the @arg_description of the corresponding #GOptionEntry in
200  * the usage summary.
201  *
202  * Another usage is to give a short summary of the program
203  * functionality, like " - frob the strings", which will be displayed
204  * in the same line as the usage. For a longer description of the
205  * program functionality that should be displayed as a paragraph
206  * below the usage line, use g_option_context_set_summary().
207  *
208  * Note that the @parameter_string is translated (see 
209  * g_option_context_set_translate_func()).
210  *
211  * Returns: a newly created #GOptionContext, which must be
212  *    freed with g_option_context_free() after use.
213  *
214  * Since: 2.6
215  */
216 GOptionContext *
217 g_option_context_new (const gchar *parameter_string)
218
219 {
220   GOptionContext *context;
221
222   context = g_new0 (GOptionContext, 1);
223
224   context->parameter_string = g_strdup (parameter_string);
225   context->help_enabled = TRUE;
226   context->ignore_unknown = FALSE;
227
228   return context;
229 }
230
231 /**
232  * g_option_context_free:
233  * @context: a #GOptionContext 
234  *
235  * Frees context and all the groups which have been 
236  * added to it.
237  *
238  * Since: 2.6
239  */
240 void g_option_context_free (GOptionContext *context) 
241 {
242   g_return_if_fail (context != NULL);
243
244   g_list_foreach (context->groups, (GFunc)g_option_group_free, NULL);
245   g_list_free (context->groups);
246
247   if (context->main_group) 
248     g_option_group_free (context->main_group);
249
250   free_changes_list (context, FALSE);
251   free_pending_nulls (context, FALSE);
252   
253   g_free (context->parameter_string);
254   g_free (context->summary);
255   g_free (context->description);
256   
257   if (context->translate_notify)
258     (* context->translate_notify) (context->translate_data);
259
260   g_free (context);
261 }
262
263
264 /**
265  * g_option_context_set_help_enabled:
266  * @context: a #GOptionContext
267  * @help_enabled: %TRUE to enable <option>--help</option>, %FALSE to disable it
268  *
269  * Enables or disables automatic generation of <option>--help</option> 
270  * output. By default, g_option_context_parse() recognizes
271  * <option>--help</option>, <option>-?</option>, <option>--help-all</option>
272  * and <option>--help-</option><replaceable>groupname</replaceable> and creates
273  * suitable output to stdout. 
274  *
275  * Since: 2.6
276  */
277 void g_option_context_set_help_enabled (GOptionContext *context,
278                                         gboolean        help_enabled)
279
280 {
281   g_return_if_fail (context != NULL);
282
283   context->help_enabled = help_enabled;
284 }
285
286 /**
287  * g_option_context_get_help_enabled:
288  * @context: a #GOptionContext
289  * 
290  * Returns whether automatic <option>--help</option> generation
291  * is turned on for @context. See g_option_context_set_help_enabled().
292  * 
293  * Returns: %TRUE if automatic help generation is turned on.
294  *
295  * Since: 2.6
296  */
297 gboolean 
298 g_option_context_get_help_enabled (GOptionContext *context) 
299 {
300   g_return_val_if_fail (context != NULL, FALSE);
301   
302   return context->help_enabled;
303 }
304
305 /**
306  * g_option_context_set_ignore_unknown_options:
307  * @context: a #GOptionContext
308  * @ignore_unknown: %TRUE to ignore unknown options, %FALSE to produce
309  *    an error when unknown options are met
310  * 
311  * Sets whether to ignore unknown options or not. If an argument is 
312  * ignored, it is left in the @argv array after parsing. By default, 
313  * g_option_context_parse() treats unknown options as error.
314  * 
315  * This setting does not affect non-option arguments (i.e. arguments 
316  * which don't start with a dash). But note that GOption cannot reliably
317  * determine whether a non-option belongs to a preceding unknown option.
318  *
319  * Since: 2.6
320  **/
321 void
322 g_option_context_set_ignore_unknown_options (GOptionContext *context,
323                                              gboolean        ignore_unknown)
324 {
325   g_return_if_fail (context != NULL);
326
327   context->ignore_unknown = ignore_unknown;
328 }
329
330 /**
331  * g_option_context_get_ignore_unknown_options:
332  * @context: a #GOptionContext
333  * 
334  * Returns whether unknown options are ignored or not. See
335  * g_option_context_set_ignore_unknown_options().
336  * 
337  * Returns: %TRUE if unknown options are ignored.
338  * 
339  * Since: 2.6
340  **/
341 gboolean
342 g_option_context_get_ignore_unknown_options (GOptionContext *context)
343 {
344   g_return_val_if_fail (context != NULL, FALSE);
345
346   return context->ignore_unknown;
347 }
348
349 /**
350  * g_option_context_add_group:
351  * @context: a #GOptionContext
352  * @group: the group to add
353  * 
354  * Adds a #GOptionGroup to the @context, so that parsing with @context
355  * will recognize the options in the group. Note that the group will
356  * be freed together with the context when g_option_context_free() is
357  * called, so you must not free the group yourself after adding it
358  * to a context.
359  *
360  * Since: 2.6
361  **/
362 void
363 g_option_context_add_group (GOptionContext *context,
364                             GOptionGroup   *group)
365 {
366   GList *list;
367
368   g_return_if_fail (context != NULL);
369   g_return_if_fail (group != NULL);
370   g_return_if_fail (group->name != NULL);
371   g_return_if_fail (group->description != NULL);
372   g_return_if_fail (group->help_description != NULL);
373
374   for (list = context->groups; list; list = list->next)
375     {
376       GOptionGroup *g = (GOptionGroup *)list->data;
377
378       if ((group->name == NULL && g->name == NULL) ||
379           (group->name && g->name && strcmp (group->name, g->name) == 0))
380         g_warning ("A group named \"%s\" is already part of this GOptionContext", 
381                    group->name);
382     }
383
384   context->groups = g_list_append (context->groups, group);
385 }
386
387 /**
388  * g_option_context_set_main_group:
389  * @context: a #GOptionContext
390  * @group: the group to set as main group
391  * 
392  * Sets a #GOptionGroup as main group of the @context. 
393  * This has the same effect as calling g_option_context_add_group(), 
394  * the only difference is that the options in the main group are 
395  * treated differently when generating <option>--help</option> output.
396  *
397  * Since: 2.6
398  **/
399 void
400 g_option_context_set_main_group (GOptionContext *context,
401                                  GOptionGroup   *group)
402 {
403   g_return_if_fail (context != NULL);
404   g_return_if_fail (group != NULL);
405
406   if (context->main_group)
407     {
408       g_warning ("This GOptionContext already has a main group");
409
410       return;
411     }
412   
413   context->main_group = group;
414 }
415
416 /**
417  * g_option_context_get_main_group:
418  * @context: a #GOptionContext
419  * 
420  * Returns a pointer to the main group of @context.
421  * 
422  * Return value: the main group of @context, or %NULL if @context doesn't
423  *  have a main group. Note that group belongs to @context and should
424  *  not be modified or freed.
425  *
426  * Since: 2.6
427  **/
428 GOptionGroup *
429 g_option_context_get_main_group (GOptionContext *context)
430 {
431   g_return_val_if_fail (context != NULL, NULL);
432
433   return context->main_group;
434 }
435
436 /**
437  * g_option_context_add_main_entries:
438  * @context: a #GOptionContext
439  * @entries: a %NULL-terminated array of #GOptionEntry<!-- -->s
440  * @translation_domain: a translation domain to use for translating
441  *    the <option>--help</option> output for the options in @entries
442  *    with gettext(), or %NULL
443  * 
444  * A convenience function which creates a main group if it doesn't 
445  * exist, adds the @entries to it and sets the translation domain.
446  * 
447  * Since: 2.6
448  **/
449 void
450 g_option_context_add_main_entries (GOptionContext      *context,
451                                    const GOptionEntry  *entries,
452                                    const gchar         *translation_domain)
453 {
454   g_return_if_fail (entries != NULL);
455
456   if (!context->main_group)
457     context->main_group = g_option_group_new (NULL, NULL, NULL, NULL, NULL);
458   
459   g_option_group_add_entries (context->main_group, entries);
460   g_option_group_set_translation_domain (context->main_group, translation_domain);
461 }
462
463 static gint
464 calculate_max_length (GOptionGroup *group)
465 {
466   GOptionEntry *entry;
467   gint i, len, max_length;
468
469   max_length = 0;
470
471   for (i = 0; i < group->n_entries; i++)
472     {
473       entry = &group->entries[i];
474
475       if (entry->flags & G_OPTION_FLAG_HIDDEN)
476         continue;
477
478       len = _g_utf8_strwidth (entry->long_name, -1);
479       
480       if (entry->short_name)
481         len += 4;
482       
483       if (!NO_ARG (entry) && entry->arg_description)
484         len += 1 + _g_utf8_strwidth (TRANSLATE (group, entry->arg_description), -1);
485       
486       max_length = MAX (max_length, len);
487     }
488
489   return max_length;
490 }
491
492 static void
493 print_entry (GOptionGroup       *group,
494              gint                max_length,
495              const GOptionEntry *entry,
496              GString            *string)
497 {
498   GString *str;
499   
500   if (entry->flags & G_OPTION_FLAG_HIDDEN)
501     return;
502
503   if (entry->long_name[0] == 0)
504     return;
505
506   str = g_string_new (NULL);
507   
508   if (entry->short_name)
509     g_string_append_printf (str, "  -%c, --%s", entry->short_name, entry->long_name);
510   else
511     g_string_append_printf (str, "  --%s", entry->long_name);
512   
513   if (entry->arg_description)
514     g_string_append_printf (str, "=%s", TRANSLATE (group, entry->arg_description));
515   
516   g_string_append_printf (string, "%s%*s %s\n", str->str,
517                           (int) (max_length + 4 - _g_utf8_strwidth (str->str, -1)), "",
518                           entry->description ? TRANSLATE (group, entry->description) : "");
519   g_string_free (str, TRUE);  
520 }
521
522 /**
523  * g_option_context_get_help: 
524  * @context: a #GOptionContext
525  * @main_help: if %TRUE, only include the main group 
526  * @group: the #GOptionGroup to create help for, or %NULL
527  *
528  * Returns a formatted, translated help text for the given context.
529  * To obtain the text produced by <option>--help</option>, call
530  * <literal>g_option_context_get_help (context, TRUE, NULL)</literal>.
531  * To obtain the text produced by <option>--help-all</option>, call
532  * <literal>g_option_context_get_help (context, FALSE, NULL)</literal>.
533  * To obtain the help text for an option group, call
534  * <literal>g_option_context_get_help (context, FALSE, group)</literal>.
535  *
536  * Returns: A newly allocated string containing the help text
537  *
538  * Since: 2.14
539  */
540 gchar *
541 g_option_context_get_help (GOptionContext *context,
542                            gboolean        main_help,
543                            GOptionGroup   *group)
544 {
545   GList *list;
546   gint max_length, len;
547   gint i;
548   GOptionEntry *entry;
549   GHashTable *shadow_map;
550   gboolean seen[256];
551   const gchar *rest_description;
552   GString *string;
553
554   string = g_string_sized_new (1024);
555
556   rest_description = NULL;
557   if (context->main_group)
558     {
559
560       for (i = 0; i < context->main_group->n_entries; i++)
561         {
562           entry = &context->main_group->entries[i];
563           if (entry->long_name[0] == 0)
564             {
565               rest_description = TRANSLATE (context->main_group, entry->arg_description);
566               break;
567             }
568         }
569     }
570
571   g_string_append_printf (string, "%s\n  %s %s", 
572                           _("Usage:"), g_get_prgname(), _("[OPTION...]"));
573
574   if (rest_description)
575     {
576       g_string_printf (string, " ");
577       g_string_printf (string, rest_description);
578     }
579
580   if (context->parameter_string)
581     {
582       g_string_printf (string, " ");
583       g_string_printf (string, TRANSLATE (context, context->parameter_string));
584     }
585
586   g_string_append (string, "\n\n");
587
588   if (context->summary)
589     {
590       g_string_append (string, TRANSLATE (context, context->summary));
591       g_string_append (string, "\n\n");
592     }
593
594   memset (seen, 0, sizeof (gboolean) * 256);
595   shadow_map = g_hash_table_new (g_str_hash, g_str_equal);
596
597   if (context->main_group)
598     {
599       for (i = 0; i < context->main_group->n_entries; i++)
600         {
601           entry = &context->main_group->entries[i];
602           g_hash_table_insert (shadow_map, 
603                                (gpointer)entry->long_name, 
604                                entry);
605           
606           if (seen[(guchar)entry->short_name])
607             entry->short_name = 0;
608           else
609             seen[(guchar)entry->short_name] = TRUE;
610         }
611     }
612
613   list = context->groups;
614   while (list != NULL)
615     {
616       GOptionGroup *group = list->data;
617       for (i = 0; i < group->n_entries; i++)
618         {
619           entry = &group->entries[i];
620           if (g_hash_table_lookup (shadow_map, entry->long_name) && 
621               !(entry->flags & G_OPTION_FLAG_NOALIAS))
622             entry->long_name = g_strdup_printf ("%s-%s", group->name, entry->long_name);
623           else  
624             g_hash_table_insert (shadow_map, (gpointer)entry->long_name, entry);
625
626           if (seen[(guchar)entry->short_name] && 
627               !(entry->flags & G_OPTION_FLAG_NOALIAS))
628             entry->short_name = 0;
629           else
630             seen[(guchar)entry->short_name] = TRUE;
631         }
632       list = list->next;
633     }
634
635   g_hash_table_destroy (shadow_map);
636
637   list = context->groups;
638
639   max_length = _g_utf8_strwidth ("-?, --help", -1);
640
641   if (list)
642     {
643       len = _g_utf8_strwidth ("--help-all", -1);
644       max_length = MAX (max_length, len);
645     }
646
647   if (context->main_group)
648     {
649       len = calculate_max_length (context->main_group);
650       max_length = MAX (max_length, len);
651     }
652
653   while (list != NULL)
654     {
655       GOptionGroup *group = list->data;
656       
657       /* First, we check the --help-<groupname> options */
658       len = _g_utf8_strwidth ("--help-", -1) + _g_utf8_strwidth (group->name, -1);
659       max_length = MAX (max_length, len);
660
661       /* Then we go through the entries */
662       len = calculate_max_length (group);
663       max_length = MAX (max_length, len);
664       
665       list = list->next;
666     }
667
668   /* Add a bit of padding */
669   max_length += 4;
670
671   if (!group)
672     {
673       list = context->groups;
674       
675       g_string_append_printf (string, "%s\n  -%c, --%-*s %s\n", 
676                               _("Help Options:"), '?', max_length - 4, "help", 
677                               _("Show help options"));
678       
679       /* We only want --help-all when there are groups */
680       if (list)
681         g_string_append_printf (string, "  --%-*s %s\n", 
682                                 max_length, "help-all", 
683                                 _("Show all help options"));
684       
685       while (list)
686         {
687           GOptionGroup *group = list->data;
688           
689           g_string_append_printf (string, "  --help-%-*s %s\n", 
690                                   max_length - 5, group->name, 
691                                   TRANSLATE (group, group->help_description));
692           
693           list = list->next;
694         }
695
696       g_string_append (string, "\n");
697     }
698
699   if (group)
700     {
701       /* Print a certain group */
702       
703       g_string_append (string, TRANSLATE (group, group->description));
704       g_string_append (string, "\n");
705       for (i = 0; i < group->n_entries; i++)
706         print_entry (group, max_length, &group->entries[i], string);
707       g_string_append (string, "\n");
708     }
709   else if (!main_help)
710     {
711       /* Print all groups */
712
713       list = context->groups;
714
715       while (list)
716         {
717           GOptionGroup *group = list->data;
718
719           g_string_append (string, group->description);
720           g_string_append (string, "\n");
721           for (i = 0; i < group->n_entries; i++)
722             if (!(group->entries[i].flags & G_OPTION_FLAG_IN_MAIN))
723               print_entry (group, max_length, &group->entries[i], string);
724           
725           g_string_append (string, "\n");
726           list = list->next;
727         }
728     }
729   
730   /* Print application options if --help or --help-all has been specified */
731   if (main_help || !group)
732     {
733       list = context->groups;
734
735       g_string_append (string,  _("Application Options:"));
736       g_string_append (string, "\n");
737       if (context->main_group)
738         for (i = 0; i < context->main_group->n_entries; i++) 
739           print_entry (context->main_group, max_length, 
740                        &context->main_group->entries[i], string);
741
742       while (list != NULL)
743         {
744           GOptionGroup *group = list->data;
745
746           /* Print main entries from other groups */
747           for (i = 0; i < group->n_entries; i++)
748             if (group->entries[i].flags & G_OPTION_FLAG_IN_MAIN)
749               print_entry (group, max_length, &group->entries[i], string);
750           
751           list = list->next;
752         }
753
754       g_string_append (string, "\n");
755     }
756  
757   if (context->description)
758     {
759       g_string_append (string, TRANSLATE (context, context->description));
760       g_string_append (string, "\n");
761     }
762
763   return g_string_free (string, FALSE);
764 }
765
766 static void
767 print_help (GOptionContext *context,
768             gboolean        main_help,
769             GOptionGroup   *group)
770 {
771   gchar *help;
772
773   help = g_option_context_get_help (context, main_help, group);
774   g_printf (help);
775   g_free (help);
776
777   exit (0);  
778 }
779
780 static gboolean
781 parse_int (const gchar *arg_name,
782            const gchar *arg,
783            gint        *result,
784            GError     **error)
785 {
786   gchar *end;
787   glong tmp;
788
789   errno = 0;
790   tmp = strtol (arg, &end, 0);
791   
792   if (*arg == '\0' || *end != '\0')
793     {
794       g_set_error (error,
795                    G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
796                    _("Cannot parse integer value '%s' for %s"),
797                    arg, arg_name);
798       return FALSE;
799     }
800
801   *result = tmp;
802   if (*result != tmp || errno == ERANGE)
803     {
804       g_set_error (error,
805                    G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
806                    _("Integer value '%s' for %s out of range"),
807                    arg, arg_name);
808       return FALSE;
809     }
810
811   return TRUE;
812 }
813
814
815 static gboolean
816 parse_double (const gchar *arg_name,
817            const gchar *arg,
818            gdouble        *result,
819            GError     **error)
820 {
821   gchar *end;
822   gdouble tmp;
823
824   errno = 0;
825   tmp = g_strtod (arg, &end);
826   
827   if (*arg == '\0' || *end != '\0')
828     {
829       g_set_error (error,
830                    G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
831                    _("Cannot parse double value '%s' for %s"),
832                    arg, arg_name);
833       return FALSE;
834     }
835   if (errno == ERANGE)
836     {
837       g_set_error (error,
838                    G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
839                    _("Double value '%s' for %s out of range"),
840                    arg, arg_name);
841       return FALSE;
842     }
843
844   *result = tmp;
845   
846   return TRUE;
847 }
848
849
850 static gboolean
851 parse_int64 (const gchar *arg_name,
852              const gchar *arg,
853              gint64      *result,
854              GError     **error)
855 {
856   gchar *end;
857   gint64 tmp;
858
859   errno = 0;
860   tmp = g_ascii_strtoll (arg, &end, 0);
861
862   if (*arg == '\0' || *end != '\0')
863     {
864       g_set_error (error,
865                    G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
866                    _("Cannot parse integer value '%s' for %s"),
867                    arg, arg_name);
868       return FALSE;
869     }
870   if (errno == ERANGE)
871     {
872       g_set_error (error,
873                    G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
874                    _("Integer value '%s' for %s out of range"),
875                    arg, arg_name);
876       return FALSE;
877     }
878
879   *result = tmp;
880   
881   return TRUE;
882 }
883
884
885 static Change *
886 get_change (GOptionContext *context,
887             GOptionArg      arg_type,
888             gpointer        arg_data)
889 {
890   GList *list;
891   Change *change = NULL;
892   
893   for (list = context->changes; list != NULL; list = list->next)
894     {
895       change = list->data;
896
897       if (change->arg_data == arg_data)
898         goto found;
899     }
900
901   change = g_new0 (Change, 1);
902   change->arg_type = arg_type;
903   change->arg_data = arg_data;
904   
905   context->changes = g_list_prepend (context->changes, change);
906   
907  found:
908
909   return change;
910 }
911
912 static void
913 add_pending_null (GOptionContext *context,
914                   gchar         **ptr,
915                   gchar          *value)
916 {
917   PendingNull *n;
918
919   n = g_new0 (PendingNull, 1);
920   n->ptr = ptr;
921   n->value = value;
922
923   context->pending_nulls = g_list_prepend (context->pending_nulls, n);
924 }
925                   
926 static gboolean
927 parse_arg (GOptionContext *context,
928            GOptionGroup   *group,
929            GOptionEntry   *entry,
930            const gchar    *value,
931            const gchar    *option_name,
932            GError        **error)
933      
934 {
935   Change *change;
936
937   g_assert (value || OPTIONAL_ARG (entry) || NO_ARG (entry));
938
939   switch (entry->arg)
940     {
941     case G_OPTION_ARG_NONE:
942       {
943         change = get_change (context, G_OPTION_ARG_NONE,
944                              entry->arg_data);
945
946         *(gboolean *)entry->arg_data = !(entry->flags & G_OPTION_FLAG_REVERSE);
947         break;
948       }      
949     case G_OPTION_ARG_STRING:
950       {
951         gchar *data;
952         
953         data = g_locale_to_utf8 (value, -1, NULL, NULL, error);
954
955         if (!data)
956           return FALSE;
957
958         change = get_change (context, G_OPTION_ARG_STRING,
959                              entry->arg_data);
960         g_free (change->allocated.str);
961         
962         change->prev.str = *(gchar **)entry->arg_data;
963         change->allocated.str = data;
964         
965         *(gchar **)entry->arg_data = data;
966         break;
967       }
968     case G_OPTION_ARG_STRING_ARRAY:
969       {
970         gchar *data;
971
972         data = g_locale_to_utf8 (value, -1, NULL, NULL, error);
973
974         if (!data)
975           return FALSE;
976
977         change = get_change (context, G_OPTION_ARG_STRING_ARRAY,
978                              entry->arg_data);
979
980         if (change->allocated.array.len == 0)
981           {
982             change->prev.array = *(gchar ***)entry->arg_data;
983             change->allocated.array.data = g_new (gchar *, 2);
984           }
985         else
986           change->allocated.array.data =
987             g_renew (gchar *, change->allocated.array.data,
988                      change->allocated.array.len + 2);
989
990         change->allocated.array.data[change->allocated.array.len] = data;
991         change->allocated.array.data[change->allocated.array.len + 1] = NULL;
992
993         change->allocated.array.len ++;
994
995         *(gchar ***)entry->arg_data = change->allocated.array.data;
996
997         break;
998       }
999       
1000     case G_OPTION_ARG_FILENAME:
1001       {
1002         gchar *data;
1003
1004 #ifdef G_OS_WIN32
1005         data = g_locale_to_utf8 (value, -1, NULL, NULL, error);
1006         
1007         if (!data)
1008           return FALSE;
1009 #else
1010         data = g_strdup (value);
1011 #endif
1012         change = get_change (context, G_OPTION_ARG_FILENAME,
1013                              entry->arg_data);
1014         g_free (change->allocated.str);
1015         
1016         change->prev.str = *(gchar **)entry->arg_data;
1017         change->allocated.str = data;
1018
1019         *(gchar **)entry->arg_data = data;
1020         break;
1021       }
1022
1023     case G_OPTION_ARG_FILENAME_ARRAY:
1024       {
1025         gchar *data;
1026         
1027 #ifdef G_OS_WIN32
1028         data = g_locale_to_utf8 (value, -1, NULL, NULL, error);
1029         
1030         if (!data)
1031           return FALSE;
1032 #else
1033         data = g_strdup (value);
1034 #endif
1035         change = get_change (context, G_OPTION_ARG_STRING_ARRAY,
1036                              entry->arg_data);
1037
1038         if (change->allocated.array.len == 0)
1039           {
1040             change->prev.array = *(gchar ***)entry->arg_data;
1041             change->allocated.array.data = g_new (gchar *, 2);
1042           }
1043         else
1044           change->allocated.array.data =
1045             g_renew (gchar *, change->allocated.array.data,
1046                      change->allocated.array.len + 2);
1047
1048         change->allocated.array.data[change->allocated.array.len] = data;
1049         change->allocated.array.data[change->allocated.array.len + 1] = NULL;
1050
1051         change->allocated.array.len ++;
1052
1053         *(gchar ***)entry->arg_data = change->allocated.array.data;
1054
1055         break;
1056       }
1057       
1058     case G_OPTION_ARG_INT:
1059       {
1060         gint data;
1061
1062         if (!parse_int (option_name, value,
1063                         &data,
1064                         error))
1065           return FALSE;
1066
1067         change = get_change (context, G_OPTION_ARG_INT,
1068                              entry->arg_data);
1069         change->prev.integer = *(gint *)entry->arg_data;
1070         *(gint *)entry->arg_data = data;
1071         break;
1072       }
1073     case G_OPTION_ARG_CALLBACK:
1074       {
1075         gchar *data;
1076         gboolean retval;
1077
1078         if (!value && entry->flags & G_OPTION_FLAG_OPTIONAL_ARG)
1079           data = NULL;
1080         else if (entry->flags & G_OPTION_FLAG_NO_ARG)
1081           data = NULL;
1082         else if (entry->flags & G_OPTION_FLAG_FILENAME)
1083           {
1084 #ifdef G_OS_WIN32
1085             data = g_locale_to_utf8 (value, -1, NULL, NULL, error);
1086 #else
1087             data = g_strdup (value);
1088 #endif
1089           }
1090         else
1091           data = g_locale_to_utf8 (value, -1, NULL, NULL, error);
1092
1093         if (!(entry->flags & (G_OPTION_FLAG_NO_ARG|G_OPTION_FLAG_OPTIONAL_ARG)) && 
1094             !data)
1095           return FALSE;
1096
1097         retval = (* (GOptionArgFunc) entry->arg_data) (option_name, data, group->user_data, error);
1098         
1099         g_free (data);
1100         
1101         return retval;
1102         
1103         break;
1104       }
1105     case G_OPTION_ARG_DOUBLE:
1106       {
1107         gdouble data;
1108
1109         if (!parse_double (option_name, value,
1110                         &data,
1111                         error))
1112           {
1113             return FALSE;
1114           }
1115
1116         change = get_change (context, G_OPTION_ARG_DOUBLE,
1117                              entry->arg_data);
1118         change->prev.dbl = *(gdouble *)entry->arg_data;
1119         *(gdouble *)entry->arg_data = data;
1120         break;
1121       }
1122     case G_OPTION_ARG_INT64:
1123       {
1124         gint64 data;
1125
1126         if (!parse_int64 (option_name, value,
1127                          &data,
1128                          error))
1129           {
1130             return FALSE;
1131           }
1132
1133         change = get_change (context, G_OPTION_ARG_INT64,
1134                              entry->arg_data);
1135         change->prev.int64 = *(gint64 *)entry->arg_data;
1136         *(gint64 *)entry->arg_data = data;
1137         break;
1138       }
1139     default:
1140       g_assert_not_reached ();
1141     }
1142
1143   return TRUE;
1144 }
1145
1146 static gboolean
1147 parse_short_option (GOptionContext *context,
1148                     GOptionGroup   *group,
1149                     gint            index,
1150                     gint           *new_index,
1151                     gchar           arg,
1152                     gint           *argc,
1153                     gchar        ***argv,
1154                     GError        **error,
1155                     gboolean       *parsed)
1156 {
1157   gint j;
1158     
1159   for (j = 0; j < group->n_entries; j++)
1160     {
1161       if (arg == group->entries[j].short_name)
1162         {
1163           gchar *option_name;
1164           gchar *value = NULL;
1165           
1166           option_name = g_strdup_printf ("-%c", group->entries[j].short_name);
1167
1168           if (NO_ARG (&group->entries[j]))
1169             value = NULL;
1170           else
1171             {
1172               if (*new_index > index)
1173                 {
1174                   g_set_error (error, 
1175                                G_OPTION_ERROR, G_OPTION_ERROR_FAILED,
1176                                _("Error parsing option %s"), option_name);
1177                   g_free (option_name);
1178                   return FALSE;
1179                 }
1180
1181               if (index < *argc - 1)
1182                 {
1183                   if (!OPTIONAL_ARG (&group->entries[j]))       
1184                     {    
1185                       value = (*argv)[index + 1];
1186                       add_pending_null (context, &((*argv)[index + 1]), NULL);
1187                       *new_index = index+1;
1188                     }
1189                   else
1190                     {
1191                       if ((*argv)[index + 1][0] == '-') 
1192                         value = NULL;
1193                       else
1194                         {
1195                           value = (*argv)[index + 1];
1196                           add_pending_null (context, &((*argv)[index + 1]), NULL);
1197                           *new_index = index + 1;
1198                         }
1199                     }
1200                 }
1201               else if (index >= *argc - 1 && OPTIONAL_ARG (&group->entries[j]))
1202                 value = NULL;
1203               else
1204                 {
1205                   g_set_error (error, 
1206                                G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
1207                                _("Missing argument for %s"), option_name);
1208                   g_free (option_name);
1209                   return FALSE;
1210                 }
1211             }
1212
1213           if (!parse_arg (context, group, &group->entries[j], 
1214                           value, option_name, error))
1215             {
1216               g_free (option_name);
1217               return FALSE;
1218             }
1219           
1220           g_free (option_name);
1221           *parsed = TRUE;
1222         }
1223     }
1224
1225   return TRUE;
1226 }
1227
1228 static gboolean
1229 parse_long_option (GOptionContext *context,
1230                    GOptionGroup   *group,
1231                    gint           *index,
1232                    gchar          *arg,
1233                    gboolean        aliased,
1234                    gint           *argc,
1235                    gchar        ***argv,
1236                    GError        **error,
1237                    gboolean       *parsed)
1238 {
1239   gint j;
1240
1241   for (j = 0; j < group->n_entries; j++)
1242     {
1243       if (*index >= *argc)
1244         return TRUE;
1245
1246       if (aliased && (group->entries[j].flags & G_OPTION_FLAG_NOALIAS))
1247         continue;
1248
1249       if (NO_ARG (&group->entries[j]) &&
1250           strcmp (arg, group->entries[j].long_name) == 0)
1251         {
1252           gchar *option_name;
1253
1254           option_name = g_strconcat ("--", group->entries[j].long_name, NULL);
1255           parse_arg (context, group, &group->entries[j],
1256                      NULL, option_name, error);
1257           g_free(option_name);
1258           
1259           add_pending_null (context, &((*argv)[*index]), NULL);
1260           *parsed = TRUE;
1261         }
1262       else
1263         {
1264           gint len = strlen (group->entries[j].long_name);
1265           
1266           if (strncmp (arg, group->entries[j].long_name, len) == 0 &&
1267               (arg[len] == '=' || arg[len] == 0))
1268             {
1269               gchar *value = NULL;
1270               gchar *option_name;
1271
1272               add_pending_null (context, &((*argv)[*index]), NULL);
1273               option_name = g_strconcat ("--", group->entries[j].long_name, NULL);
1274
1275               if (arg[len] == '=')
1276                 value = arg + len + 1;
1277               else if (*index < *argc - 1) 
1278                 {
1279                   if (!(group->entries[j].flags & G_OPTION_FLAG_OPTIONAL_ARG))  
1280                     {    
1281                       value = (*argv)[*index + 1];
1282                       add_pending_null (context, &((*argv)[*index + 1]), NULL);
1283                       (*index)++;
1284                     }
1285                   else
1286                     {
1287                       if ((*argv)[*index + 1][0] == '-') 
1288                         {
1289                           gboolean retval;
1290                           retval = parse_arg (context, group, &group->entries[j],
1291                                               NULL, option_name, error);
1292                           *parsed = TRUE;
1293                           g_free (option_name);
1294                           return retval;
1295                         }
1296                       else
1297                         {
1298                           value = (*argv)[*index + 1];
1299                           add_pending_null (context, &((*argv)[*index + 1]), NULL);
1300                           (*index)++;
1301                         }
1302                     }
1303                 }
1304               else if (*index >= *argc - 1 &&
1305                        group->entries[j].flags & G_OPTION_FLAG_OPTIONAL_ARG)
1306                 {
1307                     gboolean retval;
1308                     retval = parse_arg (context, group, &group->entries[j],
1309                                         NULL, option_name, error);
1310                     *parsed = TRUE;
1311                     g_free (option_name);
1312                     return retval;
1313                 }
1314               else
1315                 {
1316                   g_set_error (error, 
1317                                G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
1318                                _("Missing argument for %s"), option_name);
1319                   g_free (option_name);
1320                   return FALSE;
1321                 }
1322
1323               if (!parse_arg (context, group, &group->entries[j], 
1324                               value, option_name, error))
1325                 {
1326                   g_free (option_name);
1327                   return FALSE;
1328                 }
1329
1330               g_free (option_name);
1331               *parsed = TRUE;
1332             } 
1333         }
1334     }
1335   
1336   return TRUE;
1337 }
1338
1339 static gboolean
1340 parse_remaining_arg (GOptionContext *context,
1341                      GOptionGroup   *group,
1342                      gint           *index,
1343                      gint           *argc,
1344                      gchar        ***argv,
1345                      GError        **error,
1346                      gboolean       *parsed)
1347 {
1348   gint j;
1349
1350   for (j = 0; j < group->n_entries; j++)
1351     {
1352       if (*index >= *argc)
1353         return TRUE;
1354
1355       if (group->entries[j].long_name[0])
1356         continue;
1357
1358       g_return_val_if_fail (group->entries[j].arg == G_OPTION_ARG_CALLBACK ||
1359                             group->entries[j].arg == G_OPTION_ARG_STRING_ARRAY ||
1360                             group->entries[j].arg == G_OPTION_ARG_FILENAME_ARRAY, FALSE);
1361       
1362       add_pending_null (context, &((*argv)[*index]), NULL);
1363       
1364       if (!parse_arg (context, group, &group->entries[j], (*argv)[*index], "", error))
1365         return FALSE;
1366       
1367       *parsed = TRUE;
1368       return TRUE;
1369     }
1370
1371   return TRUE;
1372 }
1373
1374 static void
1375 free_changes_list (GOptionContext *context,
1376                    gboolean        revert)
1377 {
1378   GList *list;
1379
1380   for (list = context->changes; list != NULL; list = list->next)
1381     {
1382       Change *change = list->data;
1383
1384       if (revert)
1385         {
1386           switch (change->arg_type)
1387             {
1388             case G_OPTION_ARG_NONE:
1389               *(gboolean *)change->arg_data = change->prev.bool;
1390               break;
1391             case G_OPTION_ARG_INT:
1392               *(gint *)change->arg_data = change->prev.integer;
1393               break;
1394             case G_OPTION_ARG_STRING:
1395             case G_OPTION_ARG_FILENAME:
1396               g_free (change->allocated.str);
1397               *(gchar **)change->arg_data = change->prev.str;
1398               break;
1399             case G_OPTION_ARG_STRING_ARRAY:
1400             case G_OPTION_ARG_FILENAME_ARRAY:
1401               g_strfreev (change->allocated.array.data);
1402               *(gchar ***)change->arg_data = change->prev.array;
1403               break;
1404             case G_OPTION_ARG_DOUBLE:
1405               *(gdouble *)change->arg_data = change->prev.dbl;
1406               break;
1407             case G_OPTION_ARG_INT64:
1408               *(gint64 *)change->arg_data = change->prev.int64;
1409               break;
1410             default:
1411               g_assert_not_reached ();
1412             }
1413         }
1414       
1415       g_free (change);
1416     }
1417
1418   g_list_free (context->changes);
1419   context->changes = NULL;
1420 }
1421
1422 static void
1423 free_pending_nulls (GOptionContext *context,
1424                     gboolean        perform_nulls)
1425 {
1426   GList *list;
1427
1428   for (list = context->pending_nulls; list != NULL; list = list->next)
1429     {
1430       PendingNull *n = list->data;
1431
1432       if (perform_nulls)
1433         {
1434           if (n->value)
1435             {
1436               /* Copy back the short options */
1437               *(n->ptr)[0] = '-';             
1438               strcpy (*n->ptr + 1, n->value);
1439             }
1440           else
1441             *n->ptr = NULL;
1442         }
1443       
1444       g_free (n->value);
1445       g_free (n);
1446     }
1447
1448   g_list_free (context->pending_nulls);
1449   context->pending_nulls = NULL;
1450 }
1451
1452 /**
1453  * g_option_context_parse:
1454  * @context: a #GOptionContext
1455  * @argc: a pointer to the number of command line arguments
1456  * @argv: a pointer to the array of command line arguments
1457  * @error: a return location for errors 
1458  * 
1459  * Parses the command line arguments, recognizing options
1460  * which have been added to @context. A side-effect of 
1461  * calling this function is that g_set_prgname() will be
1462  * called.
1463  *
1464  * If the parsing is successful, any parsed arguments are
1465  * removed from the array and @argc and @argv are updated 
1466  * accordingly. A '--' option is stripped from @argv
1467  * unless there are unparsed options before and after it, 
1468  * or some of the options after it start with '-'. In case 
1469  * of an error, @argc and @argv are left unmodified. 
1470  *
1471  * If automatic <option>--help</option> support is enabled
1472  * (see g_option_context_set_help_enabled()), and the 
1473  * @argv array contains one of the recognized help options,
1474  * this function will produce help output to stdout and
1475  * call <literal>exit (0)</literal>.
1476  *
1477  * Note that function depends on the 
1478  * <link linkend="setlocale">current locale</link> for 
1479  * automatic character set conversion of string and filename
1480  * arguments.
1481  * 
1482  * Return value: %TRUE if the parsing was successful, 
1483  *               %FALSE if an error occurred
1484  *
1485  * Since: 2.6
1486  **/
1487 gboolean
1488 g_option_context_parse (GOptionContext   *context,
1489                         gint             *argc,
1490                         gchar          ***argv,
1491                         GError          **error)
1492 {
1493   gint i, j, k;
1494   GList *list;
1495
1496   /* Set program name */
1497   if (!g_get_prgname())
1498     {
1499       if (argc && argv && *argc)
1500         {
1501           gchar *prgname;
1502           
1503           prgname = g_path_get_basename ((*argv)[0]);
1504           g_set_prgname (prgname);
1505           g_free (prgname);
1506         }
1507       else
1508         g_set_prgname ("<unknown>");
1509     }
1510
1511   /* Call pre-parse hooks */
1512   list = context->groups;
1513   while (list)
1514     {
1515       GOptionGroup *group = list->data;
1516       
1517       if (group->pre_parse_func)
1518         {
1519           if (!(* group->pre_parse_func) (context, group,
1520                                           group->user_data, error))
1521             goto fail;
1522         }
1523       
1524       list = list->next;
1525     }
1526
1527   if (context->main_group && context->main_group->pre_parse_func)
1528     {
1529       if (!(* context->main_group->pre_parse_func) (context, context->main_group,
1530                                                     context->main_group->user_data, error))
1531         goto fail;
1532     }
1533
1534   if (argc && argv)
1535     {
1536       gboolean stop_parsing = FALSE;
1537       gboolean has_unknown = FALSE;
1538       gint separator_pos = 0;
1539
1540       for (i = 1; i < *argc; i++)
1541         {
1542           gchar *arg, *dash;
1543           gboolean parsed = FALSE;
1544
1545           if ((*argv)[i][0] == '-' && (*argv)[i][1] != '\0' && !stop_parsing)
1546             {
1547               if ((*argv)[i][1] == '-')
1548                 {
1549                   /* -- option */
1550
1551                   arg = (*argv)[i] + 2;
1552
1553                   /* '--' terminates list of arguments */
1554                   if (*arg == 0)
1555                     {
1556                       separator_pos = i;
1557                       stop_parsing = TRUE;
1558                       continue;
1559                     }
1560
1561                   /* Handle help options */
1562                   if (context->help_enabled)
1563                     {
1564                       if (strcmp (arg, "help") == 0)
1565                         print_help (context, TRUE, NULL);
1566                       else if (strcmp (arg, "help-all") == 0)
1567                         print_help (context, FALSE, NULL);                    
1568                       else if (strncmp (arg, "help-", 5) == 0)
1569                         {
1570                           GList *list;
1571                           
1572                           list = context->groups;
1573                           
1574                           while (list)
1575                             {
1576                               GOptionGroup *group = list->data;
1577                               
1578                               if (strcmp (arg + 5, group->name) == 0)
1579                                 print_help (context, FALSE, group);                                           
1580                               
1581                               list = list->next;
1582                             }
1583                         }
1584                     }
1585
1586                   if (context->main_group &&
1587                       !parse_long_option (context, context->main_group, &i, arg,
1588                                           FALSE, argc, argv, error, &parsed))
1589                     goto fail;
1590
1591                   if (parsed)
1592                     continue;
1593                   
1594                   /* Try the groups */
1595                   list = context->groups;
1596                   while (list)
1597                     {
1598                       GOptionGroup *group = list->data;
1599                       
1600                       if (!parse_long_option (context, group, &i, arg, 
1601                                               FALSE, argc, argv, error, &parsed))
1602                         goto fail;
1603                       
1604                       if (parsed)
1605                         break;
1606                       
1607                       list = list->next;
1608                     }
1609                   
1610                   if (parsed)
1611                     continue;
1612
1613                   /* Now look for --<group>-<option> */
1614                   dash = strchr (arg, '-');
1615                   if (dash)
1616                     {
1617                       /* Try the groups */
1618                       list = context->groups;
1619                       while (list)
1620                         {
1621                           GOptionGroup *group = list->data;
1622                           
1623                           if (strncmp (group->name, arg, dash - arg) == 0)
1624                             {
1625                               if (!parse_long_option (context, group, &i, dash + 1,
1626                                                       TRUE, argc, argv, error, &parsed))
1627                                 goto fail;
1628                               
1629                               if (parsed)
1630                                 break;
1631                             }
1632                           
1633                           list = list->next;
1634                         }
1635                     }
1636                   
1637                   if (context->ignore_unknown)
1638                     continue;
1639                 }
1640               else
1641                 { /* short option */
1642                   gint j, new_i = i, arg_length;
1643                   gboolean *nulled_out = NULL;
1644                   arg = (*argv)[i] + 1;
1645                   arg_length = strlen (arg);
1646                   nulled_out = g_newa (gboolean, arg_length);
1647                   memset (nulled_out, 0, arg_length * sizeof (gboolean));
1648                   for (j = 0; j < arg_length; j++)
1649                     {
1650                       if (context->help_enabled && arg[j] == '?')
1651                         print_help (context, TRUE, NULL);
1652                       parsed = FALSE;
1653                       if (context->main_group &&
1654                           !parse_short_option (context, context->main_group,
1655                                                i, &new_i, arg[j],
1656                                                argc, argv, error, &parsed))
1657                         goto fail;
1658                       if (!parsed)
1659                         {
1660                           /* Try the groups */
1661                           list = context->groups;
1662                           while (list)
1663                             {
1664                               GOptionGroup *group = list->data;
1665                               if (!parse_short_option (context, group, i, &new_i, arg[j],
1666                                                        argc, argv, error, &parsed))
1667                                 goto fail;
1668                               if (parsed)
1669                                 break;
1670                               list = list->next;
1671                             }
1672                         }
1673                       
1674                       if (context->ignore_unknown && parsed)
1675                         nulled_out[j] = TRUE;
1676                       else if (context->ignore_unknown)
1677                         continue;
1678                       else if (!parsed)
1679                         break;
1680                       /* !context->ignore_unknown && parsed */
1681                     }
1682                   if (context->ignore_unknown)
1683                     {
1684                       gchar *new_arg = NULL; 
1685                       gint arg_index = 0;
1686                       for (j = 0; j < arg_length; j++)
1687                         {
1688                           if (!nulled_out[j])
1689                             {
1690                               if (!new_arg)
1691                                 new_arg = g_malloc (arg_length + 1);
1692                               new_arg[arg_index++] = arg[j];
1693                             }
1694                         }
1695                       if (new_arg)
1696                         new_arg[arg_index] = '\0';
1697                       add_pending_null (context, &((*argv)[i]), new_arg);
1698                     }
1699                   else if (parsed)
1700                     {
1701                       add_pending_null (context, &((*argv)[i]), NULL);
1702                       i = new_i;
1703                     }
1704                 }
1705               
1706               if (!parsed)
1707                 has_unknown = TRUE;
1708
1709               if (!parsed && !context->ignore_unknown)
1710                 {
1711                   g_set_error (error,
1712                                G_OPTION_ERROR, G_OPTION_ERROR_UNKNOWN_OPTION,
1713                                    _("Unknown option %s"), (*argv)[i]);
1714                   goto fail;
1715                 }
1716             }
1717           else
1718             {
1719               /* Collect remaining args */
1720               if (context->main_group &&
1721                   !parse_remaining_arg (context, context->main_group, &i,
1722                                         argc, argv, error, &parsed))
1723                 goto fail;
1724               
1725               if (!parsed && (has_unknown || (*argv)[i][0] == '-'))
1726                 separator_pos = 0;
1727             }
1728         }
1729
1730       if (separator_pos > 0)
1731         add_pending_null (context, &((*argv)[separator_pos]), NULL);
1732         
1733     }
1734
1735   /* Call post-parse hooks */
1736   list = context->groups;
1737   while (list)
1738     {
1739       GOptionGroup *group = list->data;
1740       
1741       if (group->post_parse_func)
1742         {
1743           if (!(* group->post_parse_func) (context, group,
1744                                            group->user_data, error))
1745             goto fail;
1746         }
1747       
1748       list = list->next;
1749     }
1750   
1751   if (context->main_group && context->main_group->post_parse_func)
1752     {
1753       if (!(* context->main_group->post_parse_func) (context, context->main_group,
1754                                                      context->main_group->user_data, error))
1755         goto fail;
1756     }
1757   
1758   if (argc && argv)
1759     {
1760       free_pending_nulls (context, TRUE);
1761       
1762       for (i = 1; i < *argc; i++)
1763         {
1764           for (k = i; k < *argc; k++)
1765             if ((*argv)[k] != NULL)
1766               break;
1767           
1768           if (k > i)
1769             {
1770               k -= i;
1771               for (j = i + k; j < *argc; j++)
1772                 {
1773                   (*argv)[j-k] = (*argv)[j];
1774                   (*argv)[j] = NULL;
1775                 }
1776               *argc -= k;
1777             }
1778         }      
1779     }
1780
1781   return TRUE;
1782
1783  fail:
1784   
1785   /* Call error hooks */
1786   list = context->groups;
1787   while (list)
1788     {
1789       GOptionGroup *group = list->data;
1790       
1791       if (group->error_func)
1792         (* group->error_func) (context, group,
1793                                group->user_data, error);
1794       
1795       list = list->next;
1796     }
1797
1798   if (context->main_group && context->main_group->error_func)
1799     (* context->main_group->error_func) (context, context->main_group,
1800                                          context->main_group->user_data, error);
1801   
1802   free_changes_list (context, TRUE);
1803   free_pending_nulls (context, FALSE);
1804
1805   return FALSE;
1806 }
1807                                    
1808 /**
1809  * g_option_group_new:
1810  * @name: the name for the option group, this is used to provide
1811  *   help for the options in this group with <option>--help-</option>@name
1812  * @description: a description for this group to be shown in 
1813  *   <option>--help</option>. This string is translated using the translation
1814  *   domain or translation function of the group
1815  * @help_description: a description for the <option>--help-</option>@name option.
1816  *   This string is translated using the translation domain or translation function
1817  *   of the group
1818  * @user_data: user data that will be passed to the pre- and post-parse hooks,
1819  *   the error hook and to callbacks of %G_OPTION_ARG_CALLBACK options, or %NULL
1820  * @destroy: a function that will be called to free @user_data, or %NULL
1821  * 
1822  * Creates a new #GOptionGroup.
1823  * 
1824  * Return value: a newly created option group. It should be added 
1825  *   to a #GOptionContext or freed with g_option_group_free().
1826  *
1827  * Since: 2.6
1828  **/
1829 GOptionGroup *
1830 g_option_group_new (const gchar    *name,
1831                     const gchar    *description,
1832                     const gchar    *help_description,
1833                     gpointer        user_data,
1834                     GDestroyNotify  destroy)
1835
1836 {
1837   GOptionGroup *group;
1838
1839   group = g_new0 (GOptionGroup, 1);
1840   group->name = g_strdup (name);
1841   group->description = g_strdup (description);
1842   group->help_description = g_strdup (help_description);
1843   group->user_data = user_data;
1844   group->destroy_notify = destroy;
1845   
1846   return group;
1847 }
1848
1849
1850 /**
1851  * g_option_group_free:
1852  * @group: a #GOptionGroup
1853  * 
1854  * Frees a #GOptionGroup. Note that you must <emphasis>not</emphasis>
1855  * free groups which have been added to a #GOptionContext.
1856  *
1857  * Since: 2.6
1858  **/
1859 void
1860 g_option_group_free (GOptionGroup *group)
1861 {
1862   g_return_if_fail (group != NULL);
1863
1864   g_free (group->name);
1865   g_free (group->description);
1866   g_free (group->help_description);
1867
1868   g_free (group->entries);
1869   
1870   if (group->destroy_notify)
1871     (* group->destroy_notify) (group->user_data);
1872
1873   if (group->translate_notify)
1874     (* group->translate_notify) (group->translate_data);
1875   
1876   g_free (group);
1877 }
1878
1879
1880 /**
1881  * g_option_group_add_entries:
1882  * @group: a #GOptionGroup
1883  * @entries: a %NULL-terminated array of #GOptionEntry<!-- -->s
1884  * 
1885  * Adds the options specified in @entries to @group.
1886  *
1887  * Since: 2.6
1888  **/
1889 void
1890 g_option_group_add_entries (GOptionGroup       *group,
1891                             const GOptionEntry *entries)
1892 {
1893   gint i, n_entries;
1894   
1895   g_return_if_fail (entries != NULL);
1896
1897   for (n_entries = 0; entries[n_entries].long_name != NULL; n_entries++) ;
1898
1899   group->entries = g_renew (GOptionEntry, group->entries, group->n_entries + n_entries);
1900
1901   memcpy (group->entries + group->n_entries, entries, sizeof (GOptionEntry) * n_entries);
1902
1903   for (i = group->n_entries; i < group->n_entries + n_entries; i++)
1904     {
1905       gchar c = group->entries[i].short_name;
1906
1907       if (c)
1908         {
1909           if (c == '-' || !g_ascii_isprint (c))
1910             {
1911               g_warning (G_STRLOC": ignoring invalid short option '%c' (%d)", c, c);
1912               group->entries[i].short_name = 0;
1913             }
1914         }
1915     }
1916
1917   group->n_entries += n_entries;
1918 }
1919
1920 /**
1921  * g_option_group_set_parse_hooks:
1922  * @group: a #GOptionGroup
1923  * @pre_parse_func: a function to call before parsing, or %NULL
1924  * @post_parse_func: a function to call after parsing, or %NULL
1925  * 
1926  * Associates two functions with @group which will be called 
1927  * from g_option_context_parse() before the first option is parsed
1928  * and after the last option has been parsed, respectively.
1929  *
1930  * Note that the user data to be passed to @pre_parse_func and
1931  * @post_parse_func can be specified when constructing the group
1932  * with g_option_group_new().
1933  *
1934  * Since: 2.6
1935  **/
1936 void
1937 g_option_group_set_parse_hooks (GOptionGroup     *group,
1938                                 GOptionParseFunc  pre_parse_func,
1939                                 GOptionParseFunc  post_parse_func)
1940 {
1941   g_return_if_fail (group != NULL);
1942
1943   group->pre_parse_func = pre_parse_func;
1944   group->post_parse_func = post_parse_func;  
1945 }
1946
1947 /**
1948  * g_option_group_set_error_hook:
1949  * @group: a #GOptionGroup
1950  * @error_func: a function to call when an error occurs
1951  * 
1952  * Associates a function with @group which will be called 
1953  * from g_option_context_parse() when an error occurs.
1954  *
1955  * Note that the user data to be passed to @pre_parse_func and
1956  * @post_parse_func can be specified when constructing the group
1957  * with g_option_group_new().
1958  *
1959  * Since: 2.6
1960  **/
1961 void
1962 g_option_group_set_error_hook (GOptionGroup     *group,
1963                                GOptionErrorFunc  error_func)
1964 {
1965   g_return_if_fail (group != NULL);
1966
1967   group->error_func = error_func;  
1968 }
1969
1970
1971 /**
1972  * g_option_group_set_translate_func:
1973  * @group: a #GOptionGroup
1974  * @func: the #GTranslateFunc, or %NULL 
1975  * @data: user data to pass to @func, or %NULL
1976  * @destroy_notify: a function which gets called to free @data, or %NULL
1977  * 
1978  * Sets the function which is used to translate user-visible
1979  * strings, for <option>--help</option> output. Different
1980  * groups can use different #GTranslateFunc<!-- -->s. If @func
1981  * is %NULL, strings are not translated.
1982  *
1983  * If you are using gettext(), you only need to set the translation
1984  * domain, see g_option_group_set_translation_domain().
1985  *
1986  * Since: 2.6
1987  **/
1988 void
1989 g_option_group_set_translate_func (GOptionGroup   *group,
1990                                    GTranslateFunc  func,
1991                                    gpointer        data,
1992                                    GDestroyNotify  destroy_notify)
1993 {
1994   g_return_if_fail (group != NULL);
1995   
1996   if (group->translate_notify)
1997     group->translate_notify (group->translate_data);
1998       
1999   group->translate_func = func;
2000   group->translate_data = data;
2001   group->translate_notify = destroy_notify;
2002 }
2003
2004 static gchar *
2005 dgettext_swapped (const gchar *msgid, 
2006                   const gchar *domainname)
2007 {
2008   return dgettext (domainname, msgid);
2009 }
2010
2011 /**
2012  * g_option_group_set_translation_domain:
2013  * @group: a #GOptionGroup
2014  * @domain: the domain to use
2015  * 
2016  * A convenience function to use gettext() for translating
2017  * user-visible strings. 
2018  * 
2019  * Since: 2.6
2020  **/
2021 void
2022 g_option_group_set_translation_domain (GOptionGroup *group,
2023                                        const gchar  *domain)
2024 {
2025   g_return_if_fail (group != NULL);
2026
2027   g_option_group_set_translate_func (group, 
2028                                      (GTranslateFunc)dgettext_swapped,
2029                                      g_strdup (domain),
2030                                      g_free);
2031
2032
2033 /**
2034  * g_option_context_set_translate_func:
2035  * @context: a #GOptionContext
2036  * @func: the #GTranslateFunc, or %NULL 
2037  * @data: user data to pass to @func, or %NULL
2038  * @destroy_notify: a function which gets called to free @data, or %NULL
2039  * 
2040  * Sets the function which is used to translate the contexts 
2041  * user-visible strings, for <option>--help</option> output. 
2042  * If @func is %NULL, strings are not translated.
2043  *
2044  * Note that option groups have their own translation functions, 
2045  * this function only affects the @parameter_string (see g_option_context_nex()), 
2046  * the summary (see g_option_context_set_summary()) and the description 
2047  * (see g_option_context_set_description()).
2048  *
2049  * If you are using gettext(), you only need to set the translation
2050  * domain, see g_context_group_set_translation_domain().
2051  *
2052  * Since: 2.12
2053  **/
2054 void
2055 g_option_context_set_translate_func (GOptionContext *context,
2056                                      GTranslateFunc func,
2057                                      gpointer       data,
2058                                      GDestroyNotify destroy_notify)
2059 {
2060   g_return_if_fail (context != NULL);
2061   
2062   if (context->translate_notify)
2063     context->translate_notify (context->translate_data);
2064       
2065   context->translate_func = func;
2066   context->translate_data = data;
2067   context->translate_notify = destroy_notify;
2068 }
2069
2070 /**
2071  * g_option_context_set_translation_domain:
2072  * @context: a #GOptionContext
2073  * @domain: the domain to use
2074  * 
2075  * A convenience function to use gettext() for translating
2076  * user-visible strings. 
2077  * 
2078  * Since: 2.12
2079  **/
2080 void
2081 g_option_context_set_translation_domain (GOptionContext *context,
2082                                          const gchar     *domain)
2083 {
2084   g_return_if_fail (context != NULL);
2085
2086   g_option_context_set_translate_func (context, 
2087                                        (GTranslateFunc)dgettext_swapped,
2088                                        g_strdup (domain),
2089                                        g_free);
2090 }
2091
2092 /**
2093  * g_option_context_set_summary:
2094  * @context: a #GOptionContext
2095  * @summary: a string to be shown in <option>--help</option> output 
2096  *  before the list of options, or %NULL
2097  * 
2098  * Adds a string to be displayed in <option>--help</option> output
2099  * before the list of options. This is typically a summary of the
2100  * program functionality. 
2101  *
2102  * Note that the summary is translated (see 
2103  * g_option_context_set_translate_func()).
2104  *
2105  * Since: 2.12
2106  */
2107 void
2108 g_option_context_set_summary (GOptionContext *context,
2109                               const gchar    *summary)
2110 {
2111   g_return_if_fail (context != NULL);
2112
2113   g_free (context->summary);
2114   context->summary = g_strdup (summary);
2115 }
2116
2117
2118 /**
2119  * g_option_context_get_summary:
2120  * @context: a #GOptionContext
2121  * 
2122  * Returns the summary. See g_option_context_set_summary().
2123  *
2124  * Returns: the summary
2125  *
2126  * Since: 2.12
2127  */
2128 G_CONST_RETURN gchar *
2129 g_option_context_get_summary (GOptionContext *context)
2130 {
2131   g_return_val_if_fail (context != NULL, NULL);
2132
2133   return context->summary;
2134 }
2135
2136 /**
2137  * g_option_context_set_description:
2138  * @context: a #GOptionContext
2139  * @description: a string to be shown in <option>--help</option> output 
2140  *   after the list of options, or %NULL
2141  * 
2142  * Adds a string to be displayed in <option>--help</option> output
2143  * after the list of options. This text often includes a bug reporting
2144  * address.
2145  *
2146  * Note that the summary is translated (see 
2147  * g_option_context_set_translate_func()).
2148  *
2149  * Since: 2.12
2150  */
2151 void
2152 g_option_context_set_description (GOptionContext *context,
2153                                   const gchar    *description)
2154 {
2155   g_return_if_fail (context != NULL);
2156
2157   g_free (context->description);
2158   context->description = g_strdup (description);
2159 }
2160
2161
2162 /**
2163  * g_option_context_get_description:
2164  * @context: a #GOptionContext
2165  * 
2166  * Returns the description. See g_option_context_set_description().
2167  *
2168  * Returns: the description
2169  *
2170  * Since: 2.12
2171  */
2172 G_CONST_RETURN gchar *
2173 g_option_context_get_description (GOptionContext *context)
2174 {
2175   g_return_val_if_fail (context != NULL, NULL);
2176
2177   return context->description;
2178 }
2179
2180
2181 #define __G_OPTION_C__
2182 #include "galiasdef.c"