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 Lesser General Public
8	* License as published by the Free Software Foundation; either
9	* version 2.1 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	* Lesser General Public License for more details.
15	*
16	* You should have received a copy of the GNU Lesser General Public License
17	* along with this library; if not, see <http://www.gnu.org/licenses/>.
18	*/
19
20	/**
21	* SECTION:option
22	* @Short_description: parses commandline options
23	* @Title: Commandline option parser
24	*
25	* The GOption commandline parser is intended to be a simpler replacement
26	* for the popt library. It supports short and long commandline options,
27	* as shown in the following example:
28	*
29	* `testtreemodel -r 1 --max-size 20 --rand --display=:1.0 -vb -- file1 file2`
30	*
31	* The example demonstrates a number of features of the GOption
32	* commandline parser:
33	*
34	* - Options can be single letters, prefixed by a single dash.
35	*
36	* - Multiple short options can be grouped behind a single dash.
37	*
38	* - Long options are prefixed by two consecutive dashes.
39	*
40	* - Options can have an extra argument, which can be a number, a string or
41	* a filename. For long options, the extra argument can be appended with
42	* an equals sign after the option name, which is useful if the extra
43	* argument starts with a dash, which would otherwise cause it to be
44	* interpreted as another option.
45	*
46	* - Non-option arguments are returned to the application as rest arguments.
47	*
48	* - An argument consisting solely of two dashes turns off further parsing,
49	* any remaining arguments (even those starting with a dash) are returned
50	* to the application as rest arguments.
51	*
52	* Another important feature of GOption is that it can automatically
53	* generate nicely formatted help output. Unless it is explicitly turned
54	* off with g_option_context_set_help_enabled(), GOption will recognize
55	* the `--help`, `-?`, `--help-all` and `--help-groupname` options
56	* (where `groupname` is the name of a #GOptionGroup) and write a text
57	* similar to the one shown in the following example to stdout.
58	*
59	* |[
60	* Usage:
61	* testtreemodel [OPTION...] - test tree model performance
62	*
63	* Help Options:
64	* -h, --help Show help options
65	* --help-all Show all help options
66	* --help-gtk Show GTK+ Options
67	*
68	* Application Options:
69	* -r, --repeats=N Average over N repetitions
70	* -m, --max-size=M Test up to 2^M items
71	* --display=DISPLAY X display to use
72	* -v, --verbose Be verbose
73	* -b, --beep Beep when done
74	* --rand Randomize the data
75	* ]|
76	*
77	* GOption groups options in #GOptionGroups, which makes it easy to
78	* incorporate options from multiple sources. The intended use for this is
79	* to let applications collect option groups from the libraries it uses,
80	* add them to their #GOptionContext, and parse all options by a single call
81	* to g_option_context_parse(). See gtk_get_option_group() for an example.
82	*
83	* If an option is declared to be of type string or filename, GOption takes
84	* care of converting it to the right encoding; strings are returned in
85	* UTF-8, filenames are returned in the GLib filename encoding. Note that
86	* this only works if setlocale() has been called before
87	* g_option_context_parse().
88	*
89	* Here is a complete example of setting up GOption to parse the example
90	* commandline above and produce the example help output.
91	* |[<!-- language="C" -->
92	* static gint repeats = 2;
93	* static gint max_size = 8;
94	* static gboolean verbose = FALSE;
95	* static gboolean beep = FALSE;
96	* static gboolean randomize = FALSE;
97	*
98	* static GOptionEntry entries[] =
99	* {
100	* { "repeats", 'r', 0, G_OPTION_ARG_INT, &repeats, "Average over N repetitions", "N" },
101	* { "max-size", 'm', 0, G_OPTION_ARG_INT, &max_size, "Test up to 2^M items", "M" },
102	* { "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose, "Be verbose", NULL },
103	* { "beep", 'b', 0, G_OPTION_ARG_NONE, &beep, "Beep when done", NULL },
104	* { "rand", 0, 0, G_OPTION_ARG_NONE, &randomize, "Randomize the data", NULL },
105	* { NULL }
106	* };
107	*
108	* int
109	* main (int argc, char *argv[])
110	* {
111	* GError *error = NULL;
112	* GOptionContext *context;
113	*
114	* context = g_option_context_new ("- test tree model performance");
115	* g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
116	* g_option_context_add_group (context, gtk_get_option_group (TRUE));
117	* if (!g_option_context_parse (context, &argc, &argv, &error))
118	* {
119	* g_print ("option parsing failed: %s\n", error->message);
120	* exit (1);
121	* }
122	*
123	* ...
124	*
125	* }
126	* ]|
127	*
128	* On UNIX systems, the argv that is passed to main() has no particular
129	* encoding, even to the extent that different parts of it may have
130	* different encodings. In general, normal arguments and flags will be
131	* in the current locale and filenames should be considered to be opaque
132	* byte strings. Proper use of %G_OPTION_ARG_FILENAME vs
133	* %G_OPTION_ARG_STRING is therefore important.
134	*
135	* Note that on Windows, filenames do have an encoding, but using
136	* #GOptionContext with the argv as passed to main() will result in a
137	* program that can only accept commandline arguments with characters
138	* from the system codepage. This can cause problems when attempting to
139	* deal with filenames containing Unicode characters that fall outside
140	* of the codepage.
141	*
142	* A solution to this is to use g_win32_get_command_line() and
143	* g_option_context_parse_strv() which will properly handle full Unicode
144	* filenames. If you are using #GApplication, this is done
145	* automatically for you.
146	*
147	* The following example shows how you can use #GOptionContext directly
148	* in order to correctly deal with Unicode filenames on Windows:
149	*
150	* |[<!-- language="C" -->
151	* int
152	* main (int argc, char **argv)
153	* {
154	* GError *error = NULL;
155	* GOptionContext *context;
156	* gchar **args;
157	*
158	* #ifdef G_OS_WIN32
159	* args = g_win32_get_command_line ();
160	* #else
161	* args = g_strdupv (argv);
162	* #endif
163	*
164	* // set up context
165	*
166	* if (!g_option_context_parse_strv (context, &args, &error))
167	* {
168	* // error happened
169	* }
170	*
171	* ...
172	*
173	* g_strfreev (args);
174	*
175	* ...
176	* }
177	* ]|
178	*/
179
180	#include "config.h"
181
182	#include <string.h>
183	#include <stdlib.h>
184	#include <stdio.h>
185	#include <errno.h>
186
187	#if defined __OpenBSD__
188	#include <unistd.h>
189	#include <sys/sysctl.h>
190	#endif
191
192	#include "goption.h"
193
194	#include "gprintf.h"
195	#include "glibintl.h"
196
197	#if defined G_OS_WIN32
198	#include <windows.h>
199	#endif
200
201	#define TRANSLATE(group, str) (((group)->translate_func ? (* (group)->translate_func) ((str), (group)->translate_data) : (str)))
202
203	#define NO_ARG(entry) ((entry)->arg == G_OPTION_ARG_NONE || \
204	((entry)->arg == G_OPTION_ARG_CALLBACK && \
205	((entry)->flags & G_OPTION_FLAG_NO_ARG)))
206
207	#define OPTIONAL_ARG(entry) ((entry)->arg == G_OPTION_ARG_CALLBACK && \
208	(entry)->flags & G_OPTION_FLAG_OPTIONAL_ARG)
209
210	typedef struct
211	{
212	GOptionArg arg_type;
213	gpointer arg_data;
214	union
215	{
216	gboolean bool;
217	gint integer;
218	gchar *str;
219	gchar **array;
220	gdouble dbl;
221	gint64 int64;
222	} prev;
223	union
224	{
225	gchar *str;
226	struct
227	{
228	gint len;
229	gchar **data;
230	} array;
231	} allocated;
232	} Change;
233
234	typedef struct
235	{
236	gchar **ptr;
237	gchar *value;
238	} PendingNull;
239
240	struct _GOptionContext
241	{
242	GList *groups;
243
244	gchar *parameter_string; /* (nullable) */
245	gchar *summary;
246	gchar *description;
247
248	GTranslateFunc translate_func;
249	GDestroyNotify translate_notify;
250	gpointer translate_data;
251
252	guint help_enabled : 1;
253	guint ignore_unknown : 1;
254	guint strv_mode : 1;
255	guint strict_posix : 1;
256
257	GOptionGroup *main_group;
258
259	/* We keep a list of change so we can revert them */
260	GList *changes;
261
262	/* We also keep track of all argv elements
263	* that should be NULLed or modified.
264	*/
265	GList *pending_nulls;
266	};
267
268	struct _GOptionGroup
269	{
270	gchar *name;
271	gchar *description;
272	gchar *help_description;
273
274	gint ref_count;
275
276	GDestroyNotify destroy_notify;
277	gpointer user_data;
278
279	GTranslateFunc translate_func;
280	GDestroyNotify translate_notify;
281	gpointer translate_data;
282
283	GOptionEntry *entries;
284	gsize n_entries;
285
286	GOptionParseFunc pre_parse_func;
287	GOptionParseFunc post_parse_func;
288	GOptionErrorFunc error_func;
289	};
290
291	static void free_changes_list (GOptionContext *context,
292	gboolean revert);
293	static void free_pending_nulls (GOptionContext *context,
294	gboolean perform_nulls);
295
296
297	static int
298	_g_unichar_get_width (gunichar c)
299	{
300	if (G_UNLIKELY (g_unichar_iszerowidth (c)))
301	return 0;
302
303	/* we ignore the fact that we should call g_unichar_iswide_cjk() under
304	* some locales (legacy East Asian ones) */
305	if (g_unichar_iswide (c))
306	return 2;
307
308	return 1;
309	}
310
311	static glong
312	_g_utf8_strwidth (const gchar *p)
313	{
314	glong len = 0;
315	g_return_val_if_fail (p != NULL, 0);
316
317	while (*p)
318	{
319	len += _g_unichar_get_width (c: g_utf8_get_char (p));
320	p = g_utf8_next_char (p);
321	}
322
323	return len;
324	}
325
326	G_DEFINE_QUARK (g-option-context-error-quark, g_option_error)
327
328	/**
329	* g_option_context_new:
330	* @parameter_string: (nullable): a string which is displayed in
331	* the first line of `--help` output, after the usage summary
332	* `programname [OPTION...]`
333	*
334	* Creates a new option context.
335	*
336	* The @parameter_string can serve multiple purposes. It can be used
337	* to add descriptions for "rest" arguments, which are not parsed by
338	* the #GOptionContext, typically something like "FILES" or
339	* "FILE1 FILE2...". If you are using #G_OPTION_REMAINING for
340	* collecting "rest" arguments, GLib handles this automatically by
341	* using the @arg_description of the corresponding #GOptionEntry in
342	* the usage summary.
343	*
344	* Another usage is to give a short summary of the program
345	* functionality, like " - frob the strings", which will be displayed
346	* in the same line as the usage. For a longer description of the
347	* program functionality that should be displayed as a paragraph
348	* below the usage line, use g_option_context_set_summary().
349	*
350	* Note that the @parameter_string is translated using the
351	* function set with g_option_context_set_translate_func(), so
352	* it should normally be passed untranslated.
353	*
354	* Returns: a newly created #GOptionContext, which must be
355	* freed with g_option_context_free() after use.
356	*
357	* Since: 2.6
358	*/
359	GOptionContext *
360	g_option_context_new (const gchar *parameter_string)
361
362	{
363	GOptionContext *context;
364
365	context = g_new0 (GOptionContext, 1);
366
367	/* Clear the empty string to NULL, otherwise we end up calling gettext(""),
368	* which returns the translation header. */
369	if (parameter_string != NULL && *parameter_string == '\0')
370	parameter_string = NULL;
371
372	context->parameter_string = g_strdup (str: parameter_string);
373	context->strict_posix = FALSE;
374	context->help_enabled = TRUE;
375	context->ignore_unknown = FALSE;
376
377	return context;
378	}
379
380	/**
381	* g_option_context_free:
382	* @context: a #GOptionContext
383	*
384	* Frees context and all the groups which have been
385	* added to it.
386	*
387	* Please note that parsed arguments need to be freed separately (see
388	* #GOptionEntry).
389	*
390	* Since: 2.6
391	*/
392	void g_option_context_free (GOptionContext *context)
393	{
394	g_return_if_fail (context != NULL);
395
396	g_list_free_full (list: context->groups, free_func: (GDestroyNotify) g_option_group_unref);
397
398	if (context->main_group)
399	g_option_group_unref (group: context->main_group);
400
401	free_changes_list (context, FALSE);
402	free_pending_nulls (context, FALSE);
403
404	g_free (mem: context->parameter_string);
405	g_free (mem: context->summary);
406	g_free (mem: context->description);
407
408	if (context->translate_notify)
409	(* context->translate_notify) (context->translate_data);
410
411	g_free (mem: context);
412	}
413
414
415	/**
416	* g_option_context_set_help_enabled:
417	* @context: a #GOptionContext
418	* @help_enabled: %TRUE to enable `--help`, %FALSE to disable it
419	*
420	* Enables or disables automatic generation of `--help` output.
421	* By default, g_option_context_parse() recognizes `--help`, `-h`,
422	* `-?`, `--help-all` and `--help-groupname` and creates suitable
423	* output to stdout.
424	*
425	* Since: 2.6
426	*/
427	void g_option_context_set_help_enabled (GOptionContext *context,
428	gboolean help_enabled)
429
430	{
431	g_return_if_fail (context != NULL);
432
433	context->help_enabled = help_enabled;
434	}
435
436	/**
437	* g_option_context_get_help_enabled:
438	* @context: a #GOptionContext
439	*
440	* Returns whether automatic `--help` generation
441	* is turned on for @context. See g_option_context_set_help_enabled().
442	*
443	* Returns: %TRUE if automatic help generation is turned on.
444	*
445	* Since: 2.6
446	*/
447	gboolean
448	g_option_context_get_help_enabled (GOptionContext *context)
449	{
450	g_return_val_if_fail (context != NULL, FALSE);
451
452	return context->help_enabled;
453	}
454
455	/**
456	* g_option_context_set_ignore_unknown_options:
457	* @context: a #GOptionContext
458	* @ignore_unknown: %TRUE to ignore unknown options, %FALSE to produce
459	* an error when unknown options are met
460	*
461	* Sets whether to ignore unknown options or not. If an argument is
462	* ignored, it is left in the @argv array after parsing. By default,
463	* g_option_context_parse() treats unknown options as error.
464	*
465	* This setting does not affect non-option arguments (i.e. arguments
466	* which don't start with a dash). But note that GOption cannot reliably
467	* determine whether a non-option belongs to a preceding unknown option.
468	*
469	* Since: 2.6
470	**/
471	void
472	g_option_context_set_ignore_unknown_options (GOptionContext *context,
473	gboolean ignore_unknown)
474	{
475	g_return_if_fail (context != NULL);
476
477	context->ignore_unknown = ignore_unknown;
478	}
479
480	/**
481	* g_option_context_get_ignore_unknown_options:
482	* @context: a #GOptionContext
483	*
484	* Returns whether unknown options are ignored or not. See
485	* g_option_context_set_ignore_unknown_options().
486	*
487	* Returns: %TRUE if unknown options are ignored.
488	*
489	* Since: 2.6
490	**/
491	gboolean
492	g_option_context_get_ignore_unknown_options (GOptionContext *context)
493	{
494	g_return_val_if_fail (context != NULL, FALSE);
495
496	return context->ignore_unknown;
497	}
498
499	/**
500	* g_option_context_set_strict_posix:
501	* @context: a #GOptionContext
502	* @strict_posix: the new value
503	*
504	* Sets strict POSIX mode.
505	*
506	* By default, this mode is disabled.
507	*
508	* In strict POSIX mode, the first non-argument parameter encountered
509	* (eg: filename) terminates argument processing. Remaining arguments
510	* are treated as non-options and are not attempted to be parsed.
511	*
512	* If strict POSIX mode is disabled then parsing is done in the GNU way
513	* where option arguments can be freely mixed with non-options.
514	*
515	* As an example, consider "ls foo -l". With GNU style parsing, this
516	* will list "foo" in long mode. In strict POSIX style, this will list
517	* the files named "foo" and "-l".
518	*
519	* It may be useful to force strict POSIX mode when creating "verb
520	* style" command line tools. For example, the "gsettings" command line
521	* tool supports the global option "--schemadir" as well as many
522	* subcommands ("get", "set", etc.) which each have their own set of
523	* arguments. Using strict POSIX mode will allow parsing the global
524	* options up to the verb name while leaving the remaining options to be
525	* parsed by the relevant subcommand (which can be determined by
526	* examining the verb name, which should be present in argv[1] after
527	* parsing).
528	*
529	* Since: 2.44
530	**/
531	void
532	g_option_context_set_strict_posix (GOptionContext *context,
533	gboolean strict_posix)
534	{
535	g_return_if_fail (context != NULL);
536
537	context->strict_posix = strict_posix;
538	}
539
540	/**
541	* g_option_context_get_strict_posix:
542	* @context: a #GOptionContext
543	*
544	* Returns whether strict POSIX code is enabled.
545	*
546	* See g_option_context_set_strict_posix() for more information.
547	*
548	* Returns: %TRUE if strict POSIX is enabled, %FALSE otherwise.
549	*
550	* Since: 2.44
551	**/
552	gboolean
553	g_option_context_get_strict_posix (GOptionContext *context)
554	{
555	g_return_val_if_fail (context != NULL, FALSE);
556
557	return context->strict_posix;
558	}
559
560	/**
561	* g_option_context_add_group:
562	* @context: a #GOptionContext
563	* @group: (transfer full): the group to add
564	*
565	* Adds a #GOptionGroup to the @context, so that parsing with @context
566	* will recognize the options in the group. Note that this will take
567	* ownership of the @group and thus the @group should not be freed.
568	*
569	* Since: 2.6
570	**/
571	void
572	g_option_context_add_group (GOptionContext *context,
573	GOptionGroup *group)
574	{
575	GList *list;
576
577	g_return_if_fail (context != NULL);
578	g_return_if_fail (group != NULL);
579	g_return_if_fail (group->name != NULL);
580	g_return_if_fail (group->description != NULL);
581	g_return_if_fail (group->help_description != NULL);
582
583	for (list = context->groups; list; list = list->next)
584	{
585	GOptionGroup *g = (GOptionGroup *)list->data;
586
587	if ((group->name == NULL && g->name == NULL) ||
588	(group->name && g->name && strcmp (s1: group->name, s2: g->name) == 0))
589	g_warning ("A group named \"%s\" is already part of this GOptionContext",
590	group->name);
591	}
592
593	context->groups = g_list_append (list: context->groups, data: group);
594	}
595
596	/**
597	* g_option_context_set_main_group:
598	* @context: a #GOptionContext
599	* @group: (transfer full): the group to set as main group
600	*
601	* Sets a #GOptionGroup as main group of the @context.
602	* This has the same effect as calling g_option_context_add_group(),
603	* the only difference is that the options in the main group are
604	* treated differently when generating `--help` output.
605	*
606	* Since: 2.6
607	**/
608	void
609	g_option_context_set_main_group (GOptionContext *context,
610	GOptionGroup *group)
611	{
612	g_return_if_fail (context != NULL);
613	g_return_if_fail (group != NULL);
614
615	if (context->main_group)
616	{
617	g_warning ("This GOptionContext already has a main group");
618
619	return;
620	}
621
622	context->main_group = group;
623	}
624
625	/**
626	* g_option_context_get_main_group:
627	* @context: a #GOptionContext
628	*
629	* Returns a pointer to the main group of @context.
630	*
631	* Returns: (transfer none): the main group of @context, or %NULL if
632	* @context doesn't have a main group. Note that group belongs to
633	* @context and should not be modified or freed.
634	*
635	* Since: 2.6
636	**/
637	GOptionGroup *
638	g_option_context_get_main_group (GOptionContext *context)
639	{
640	g_return_val_if_fail (context != NULL, NULL);
641
642	return context->main_group;
643	}
644
645	/**
646	* g_option_context_add_main_entries:
647	* @context: a #GOptionContext
648	* @entries: (array zero-terminated=1): a %NULL-terminated array of #GOptionEntrys
649	* @translation_domain: (nullable): a translation domain to use for translating
650	* the `--help` output for the options in @entries
651	* with gettext(), or %NULL
652	*
653	* A convenience function which creates a main group if it doesn't
654	* exist, adds the @entries to it and sets the translation domain.
655	*
656	* Since: 2.6
657	**/
658	void
659	g_option_context_add_main_entries (GOptionContext *context,
660	const GOptionEntry *entries,
661	const gchar *translation_domain)
662	{
663	g_return_if_fail (context != NULL);
664	g_return_if_fail (entries != NULL);
665
666	if (!context->main_group)
667	context->main_group = g_option_group_new (NULL, NULL, NULL, NULL, NULL);
668
669	g_option_group_add_entries (group: context->main_group, entries);
670	g_option_group_set_translation_domain (group: context->main_group, domain: translation_domain);
671	}
672
673	static gint
674	calculate_max_length (GOptionGroup *group,
675	GHashTable *aliases)
676	{
677	GOptionEntry *entry;
678	gsize i, len, max_length;
679	const gchar *long_name;
680
681	max_length = 0;
682
683	for (i = 0; i < group->n_entries; i++)
684	{
685	entry = &group->entries[i];
686
687	if (entry->flags & G_OPTION_FLAG_HIDDEN)
688	continue;
689
690	long_name = g_hash_table_lookup (hash_table: aliases, key: &entry->long_name);
691	if (!long_name)
692	long_name = entry->long_name;
693	len = _g_utf8_strwidth (p: long_name);
694
695	if (entry->short_name)
696	len += 4;
697
698	if (!NO_ARG (entry) && entry->arg_description)
699	len += 1 + _g_utf8_strwidth (TRANSLATE (group, entry->arg_description));
700
701	max_length = MAX (max_length, len);
702	}
703
704	return max_length;
705	}
706
707	static void
708	print_entry (GOptionGroup *group,
709	gint max_length,
710	const GOptionEntry *entry,
711	GString *string,
712	GHashTable *aliases)
713	{
714	GString *str;
715	const gchar *long_name;
716
717	if (entry->flags & G_OPTION_FLAG_HIDDEN)
718	return;
719
720	if (entry->long_name[0] == 0)
721	return;
722
723	long_name = g_hash_table_lookup (hash_table: aliases, key: &entry->long_name);
724	if (!long_name)
725	long_name = entry->long_name;
726
727	str = g_string_new (NULL);
728
729	if (entry->short_name)
730	g_string_append_printf (string: str, format: " -%c, --%s", entry->short_name, long_name);
731	else
732	g_string_append_printf (string: str, format: " --%s", long_name);
733
734	if (entry->arg_description)
735	g_string_append_printf (string: str, format: "=%s", TRANSLATE (group, entry->arg_description));
736
737	g_string_append_printf (string, format: "%s%*s %s\n", str->str,
738	(int) (max_length + 4 - _g_utf8_strwidth (p: str->str)), "",
739	entry->description ? TRANSLATE (group, entry->description) : "");
740	g_string_free (string: str, TRUE);
741	}
742
743	static gboolean
744	group_has_visible_entries (GOptionContext *context,
745	GOptionGroup *group,
746	gboolean main_entries)
747	{
748	GOptionFlags reject_filter = G_OPTION_FLAG_HIDDEN;
749	GOptionEntry *entry;
750	gint i, l;
751	gboolean main_group = group == context->main_group;
752
753	if (!main_entries)
754	reject_filter |= G_OPTION_FLAG_IN_MAIN;
755
756	for (i = 0, l = (group ? group->n_entries : 0); i < l; i++)
757	{
758	entry = &group->entries[i];
759
760	if (main_entries && !main_group && !(entry->flags & G_OPTION_FLAG_IN_MAIN))
761	continue;
762	if (entry->long_name[0] == 0) /* ignore rest entry */
763	continue;
764	if (!(entry->flags & reject_filter))
765	return TRUE;
766	}
767
768	return FALSE;
769	}
770
771	static gboolean
772	group_list_has_visible_entries (GOptionContext *context,
773	GList *group_list,
774	gboolean main_entries)
775	{
776	while (group_list)
777	{
778	if (group_has_visible_entries (context, group: group_list->data, main_entries))
779	return TRUE;
780
781	group_list = group_list->next;
782	}
783
784	return FALSE;
785	}
786
787	static gboolean
788	context_has_h_entry (GOptionContext *context)
789	{
790	gsize i;
791	GList *list;
792
793	if (context->main_group)
794	{
795	for (i = 0; i < context->main_group->n_entries; i++)
796	{
797	if (context->main_group->entries[i].short_name == 'h')
798	return TRUE;
799	}
800	}
801
802	for (list = context->groups; list != NULL; list = g_list_next (list))
803	{
804	GOptionGroup *group;
805
806	group = (GOptionGroup*)list->data;
807	for (i = 0; i < group->n_entries; i++)
808	{
809	if (group->entries[i].short_name == 'h')
810	return TRUE;
811	}
812	}
813	return FALSE;
814	}
815
816	/**
817	* g_option_context_get_help:
818	* @context: a #GOptionContext
819	* @main_help: if %TRUE, only include the main group
820	* @group: (nullable): the #GOptionGroup to create help for, or %NULL
821	*
822	* Returns a formatted, translated help text for the given context.
823	* To obtain the text produced by `--help`, call
824	* `g_option_context_get_help (context, TRUE, NULL)`.
825	* To obtain the text produced by `--help-all`, call
826	* `g_option_context_get_help (context, FALSE, NULL)`.
827	* To obtain the help text for an option group, call
828	* `g_option_context_get_help (context, FALSE, group)`.
829	*
830	* Returns: A newly allocated string containing the help text
831	*
832	* Since: 2.14
833	*/
834	gchar *
835	g_option_context_get_help (GOptionContext *context,
836	gboolean main_help,
837	GOptionGroup *group)
838	{
839	GList *list;
840	gint max_length = 0, len;
841	gsize i;
842	GOptionEntry *entry;
843	GHashTable *shadow_map;
844	GHashTable *aliases;
845	gboolean seen[256];
846	const gchar *rest_description;
847	GString *string;
848	guchar token;
849
850	g_return_val_if_fail (context != NULL, NULL);
851
852	string = g_string_sized_new (dfl_size: 1024);
853
854	rest_description = NULL;
855	if (context->main_group)
856	{
857
858	for (i = 0; i < context->main_group->n_entries; i++)
859	{
860	entry = &context->main_group->entries[i];
861	if (entry->long_name[0] == 0)
862	{
863	rest_description = TRANSLATE (context->main_group, entry->arg_description);
864	break;
865	}
866	}
867	}
868
869	g_string_append_printf (string, format: "%s\n %s", _("Usage:"), g_get_prgname ());
870	if (context->help_enabled ||
871	(context->main_group && context->main_group->n_entries > 0) ||
872	context->groups != NULL)
873	g_string_append_printf (string, format: " %s", _("[OPTION…]"));
874
875	if (rest_description)
876	{
877	g_string_append (string, val: " ");
878	g_string_append (string, val: rest_description);
879	}
880
881	if (context->parameter_string)
882	{
883	g_string_append (string, val: " ");
884	g_string_append (string, TRANSLATE (context, context->parameter_string));
885	}
886
887	g_string_append (string, val: "\n\n");
888
889	if (context->summary)
890	{
891	g_string_append (string, TRANSLATE (context, context->summary));
892	g_string_append (string, val: "\n\n");
893	}
894
895	memset (s: seen, c: 0, n: sizeof (gboolean) * 256);
896	shadow_map = g_hash_table_new (hash_func: g_str_hash, key_equal_func: g_str_equal);
897	aliases = g_hash_table_new_full (NULL, NULL, NULL, value_destroy_func: g_free);
898
899	if (context->main_group)
900	{
901	for (i = 0; i < context->main_group->n_entries; i++)
902	{
903	entry = &context->main_group->entries[i];
904	g_hash_table_insert (hash_table: shadow_map,
905	key: (gpointer)entry->long_name,
906	value: entry);
907
908	if (seen[(guchar)entry->short_name])
909	entry->short_name = 0;
910	else
911	seen[(guchar)entry->short_name] = TRUE;
912	}
913	}
914
915	list = context->groups;
916	while (list != NULL)
917	{
918	GOptionGroup *g = list->data;
919	for (i = 0; i < g->n_entries; i++)
920	{
921	entry = &g->entries[i];
922	if (g_hash_table_lookup (hash_table: shadow_map, key: entry->long_name) &&
923	!(entry->flags & G_OPTION_FLAG_NOALIAS))
924	{
925	g_hash_table_insert (hash_table: aliases, key: &entry->long_name,
926	value: g_strdup_printf (format: "%s-%s", g->name, entry->long_name));
927	}
928	else
929	g_hash_table_insert (hash_table: shadow_map, key: (gpointer)entry->long_name, value: entry);
930
931	if (seen[(guchar)entry->short_name] &&
932	!(entry->flags & G_OPTION_FLAG_NOALIAS))
933	entry->short_name = 0;
934	else
935	seen[(guchar)entry->short_name] = TRUE;
936	}
937	list = list->next;
938	}
939
940	g_hash_table_destroy (hash_table: shadow_map);
941
942	list = context->groups;
943
944	if (context->help_enabled)
945	{
946	max_length = _g_utf8_strwidth (p: "-?, --help");
947
948	if (list)
949	{
950	len = _g_utf8_strwidth (p: "--help-all");
951	max_length = MAX (max_length, len);
952	}
953	}
954
955	if (context->main_group)
956	{
957	len = calculate_max_length (group: context->main_group, aliases);
958	max_length = MAX (max_length, len);
959	}
960
961	while (list != NULL)
962	{
963	GOptionGroup *g = list->data;
964
965	if (context->help_enabled)
966	{
967	/* First, we check the --help-<groupname> options */
968	len = _g_utf8_strwidth (p: "--help-") + _g_utf8_strwidth (p: g->name);
969	max_length = MAX (max_length, len);
970	}
971
972	/* Then we go through the entries */
973	len = calculate_max_length (group: g, aliases);
974	max_length = MAX (max_length, len);
975
976	list = list->next;
977	}
978
979	/* Add a bit of padding */
980	max_length += 4;
981
982	if (!group && context->help_enabled)
983	{
984	list = context->groups;
985
986	token = context_has_h_entry (context) ? '?' : 'h';
987
988	g_string_append_printf (string, format: "%s\n -%c, --%-*s %s\n",
989	_("Help Options:"), token, max_length - 4, "help",
990	_("Show help options"));
991
992	/* We only want --help-all when there are groups */
993	if (list)
994	g_string_append_printf (string, format: " --%-*s %s\n",
995	max_length, "help-all",
996	_("Show all help options"));
997
998	while (list)
999	{
1000	GOptionGroup *g = list->data;
1001
1002	if (group_has_visible_entries (context, group: g, FALSE))
1003	g_string_append_printf (string, format: " --help-%-*s %s\n",
1004	max_length - 5, g->name,
1005	TRANSLATE (g, g->help_description));
1006
1007	list = list->next;
1008	}
1009
1010	g_string_append (string, val: "\n");
1011	}
1012
1013	if (group)
1014	{
1015	/* Print a certain group */
1016
1017	if (group_has_visible_entries (context, group, FALSE))
1018	{
1019	g_string_append (string, TRANSLATE (group, group->description));
1020	g_string_append (string, val: "\n");
1021	for (i = 0; i < group->n_entries; i++)
1022	print_entry (group, max_length, entry: &group->entries[i], string, aliases);
1023	g_string_append (string, val: "\n");
1024	}
1025	}
1026	else if (!main_help)
1027	{
1028	/* Print all groups */
1029
1030	list = context->groups;
1031
1032	while (list)
1033	{
1034	GOptionGroup *g = list->data;
1035
1036	if (group_has_visible_entries (context, group: g, FALSE))
1037	{
1038	g_string_append (string, val: g->description);
1039	g_string_append (string, val: "\n");
1040	for (i = 0; i < g->n_entries; i++)
1041	if (!(g->entries[i].flags & G_OPTION_FLAG_IN_MAIN))
1042	print_entry (group: g, max_length, entry: &g->entries[i], string, aliases);
1043
1044	g_string_append (string, val: "\n");
1045	}
1046
1047	list = list->next;
1048	}
1049	}
1050
1051	/* Print application options if --help or --help-all has been specified */
1052	if ((main_help || !group) &&
1053	(group_has_visible_entries (context, group: context->main_group, TRUE) ||
1054	group_list_has_visible_entries (context, group_list: context->groups, TRUE)))
1055	{
1056	list = context->groups;
1057
1058	if (context->help_enabled || list)
1059	g_string_append (string, _("Application Options:"));
1060	else
1061	g_string_append (string, _("Options:"));
1062	g_string_append (string, val: "\n");
1063	if (context->main_group)
1064	for (i = 0; i < context->main_group->n_entries; i++)
1065	print_entry (group: context->main_group, max_length,
1066	entry: &context->main_group->entries[i], string, aliases);
1067
1068	while (list != NULL)
1069	{
1070	GOptionGroup *g = list->data;
1071
1072	/* Print main entries from other groups */
1073	for (i = 0; i < g->n_entries; i++)
1074	if (g->entries[i].flags & G_OPTION_FLAG_IN_MAIN)
1075	print_entry (group: g, max_length, entry: &g->entries[i], string, aliases);
1076
1077	list = list->next;
1078	}
1079
1080	g_string_append (string, val: "\n");
1081	}
1082
1083	if (context->description)
1084	{
1085	g_string_append (string, TRANSLATE (context, context->description));
1086	g_string_append (string, val: "\n");
1087	}
1088
1089	g_hash_table_destroy (hash_table: aliases);
1090
1091	return g_string_free (string, FALSE);
1092	}
1093
1094	G_NORETURN
1095	static void
1096	print_help (GOptionContext *context,
1097	gboolean main_help,
1098	GOptionGroup *group)
1099	{
1100	gchar *help;
1101
1102	help = g_option_context_get_help (context, main_help, group);
1103	g_print (format: "%s", help);
1104	g_free (mem: help);
1105
1106	exit (status: 0);
1107	}
1108
1109	static gboolean
1110	parse_int (const gchar *arg_name,
1111	const gchar *arg,
1112	gint *result,
1113	GError **error)
1114	{
1115	gchar *end;
1116	glong tmp;
1117
1118	errno = 0;
1119	tmp = strtol (nptr: arg, endptr: &end, base: 0);
1120
1121	if (*arg == '\0' || *end != '\0')
1122	{
1123	g_set_error (err: error,
1124	G_OPTION_ERROR, code: G_OPTION_ERROR_BAD_VALUE,
1125	_("Cannot parse integer value “%s” for %s"),
1126	arg, arg_name);
1127	return FALSE;
1128	}
1129
1130	*result = tmp;
1131	if (*result != tmp || errno == ERANGE)
1132	{
1133	g_set_error (err: error,
1134	G_OPTION_ERROR, code: G_OPTION_ERROR_BAD_VALUE,
1135	_("Integer value “%s” for %s out of range"),
1136	arg, arg_name);
1137	return FALSE;
1138	}
1139
1140	return TRUE;
1141	}
1142
1143
1144	static gboolean
1145	parse_double (const gchar *arg_name,
1146	const gchar *arg,
1147	gdouble *result,
1148	GError **error)
1149	{
1150	gchar *end;
1151	gdouble tmp;
1152
1153	errno = 0;
1154	tmp = g_strtod (nptr: arg, endptr: &end);
1155
1156	if (*arg == '\0' || *end != '\0')
1157	{
1158	g_set_error (err: error,
1159	G_OPTION_ERROR, code: G_OPTION_ERROR_BAD_VALUE,
1160	_("Cannot parse double value “%s” for %s"),
1161	arg, arg_name);
1162	return FALSE;
1163	}
1164	if (errno == ERANGE)
1165	{
1166	g_set_error (err: error,
1167	G_OPTION_ERROR, code: G_OPTION_ERROR_BAD_VALUE,
1168	_("Double value “%s” for %s out of range"),
1169	arg, arg_name);
1170	return FALSE;
1171	}
1172
1173	*result = tmp;
1174
1175	return TRUE;
1176	}
1177
1178
1179	static gboolean
1180	parse_int64 (const gchar *arg_name,
1181	const gchar *arg,
1182	gint64 *result,
1183	GError **error)
1184	{
1185	gchar *end;
1186	gint64 tmp;
1187
1188	errno = 0;
1189	tmp = g_ascii_strtoll (nptr: arg, endptr: &end, base: 0);
1190
1191	if (*arg == '\0' || *end != '\0')
1192	{
1193	g_set_error (err: error,
1194	G_OPTION_ERROR, code: G_OPTION_ERROR_BAD_VALUE,
1195	_("Cannot parse integer value “%s” for %s"),
1196	arg, arg_name);
1197	return FALSE;
1198	}
1199	if (errno == ERANGE)
1200	{
1201	g_set_error (err: error,
1202	G_OPTION_ERROR, code: G_OPTION_ERROR_BAD_VALUE,
1203	_("Integer value “%s” for %s out of range"),
1204	arg, arg_name);
1205	return FALSE;
1206	}
1207
1208	*result = tmp;
1209
1210	return TRUE;
1211	}
1212
1213
1214	static Change *
1215	get_change (GOptionContext *context,
1216	GOptionArg arg_type,
1217	gpointer arg_data)
1218	{
1219	GList *list;
1220	Change *change = NULL;
1221
1222	for (list = context->changes; list != NULL; list = list->next)
1223	{
1224	change = list->data;
1225
1226	if (change->arg_data == arg_data)
1227	goto found;
1228	}
1229
1230	change = g_new0 (Change, 1);
1231	change->arg_type = arg_type;
1232	change->arg_data = arg_data;
1233
1234	context->changes = g_list_prepend (list: context->changes, data: change);
1235
1236	found:
1237
1238	return change;
1239	}
1240
1241	static void
1242	add_pending_null (GOptionContext *context,
1243	gchar **ptr,
1244	gchar *value)
1245	{
1246	PendingNull *n;
1247
1248	n = g_new0 (PendingNull, 1);
1249	n->ptr = ptr;
1250	n->value = value;
1251
1252	context->pending_nulls = g_list_prepend (list: context->pending_nulls, data: n);
1253	}
1254
1255	static gboolean
1256	parse_arg (GOptionContext *context,
1257	GOptionGroup *group,
1258	GOptionEntry *entry,
1259	const gchar *value,
1260	const gchar *option_name,
1261	GError **error)
1262
1263	{
1264	Change *change;
1265
1266	g_assert (value || OPTIONAL_ARG (entry) || NO_ARG (entry));
1267
1268	switch (entry->arg)
1269	{
1270	case G_OPTION_ARG_NONE:
1271	{
1272	(void) get_change (context, arg_type: G_OPTION_ARG_NONE,
1273	arg_data: entry->arg_data);
1274
1275	*(gboolean *)entry->arg_data = !(entry->flags & G_OPTION_FLAG_REVERSE);
1276	break;
1277	}
1278	case G_OPTION_ARG_STRING:
1279	{
1280	gchar *data;
1281
1282	#ifdef G_OS_WIN32
1283	if (!context->strv_mode)
1284	data = g_locale_to_utf8 (value, -1, NULL, NULL, error);
1285	else
1286	data = g_strdup (value);
1287	#else
1288	data = g_locale_to_utf8 (opsysstring: value, len: -1, NULL, NULL, error);
1289	#endif
1290
1291	if (!data)
1292	return FALSE;
1293
1294	change = get_change (context, arg_type: G_OPTION_ARG_STRING,
1295	arg_data: entry->arg_data);
1296
1297	if (!change->allocated.str)
1298	change->prev.str = *(gchar **)entry->arg_data;
1299	else
1300	g_free (mem: change->allocated.str);
1301
1302	change->allocated.str = data;
1303
1304	*(gchar **)entry->arg_data = data;
1305	break;
1306	}
1307	case G_OPTION_ARG_STRING_ARRAY:
1308	{
1309	gchar *data;
1310
1311	#ifdef G_OS_WIN32
1312	if (!context->strv_mode)
1313	data = g_locale_to_utf8 (value, -1, NULL, NULL, error);
1314	else
1315	data = g_strdup (value);
1316	#else
1317	data = g_locale_to_utf8 (opsysstring: value, len: -1, NULL, NULL, error);
1318	#endif
1319
1320	if (!data)
1321	return FALSE;
1322
1323	change = get_change (context, arg_type: G_OPTION_ARG_STRING_ARRAY,
1324	arg_data: entry->arg_data);
1325
1326	if (change->allocated.array.len == 0)
1327	{
1328	change->prev.array = *(gchar ***)entry->arg_data;
1329	change->allocated.array.data = g_new (gchar *, 2);
1330	}
1331	else
1332	change->allocated.array.data =
1333	g_renew (gchar *, change->allocated.array.data,
1334	change->allocated.array.len + 2);
1335
1336	change->allocated.array.data[change->allocated.array.len] = data;
1337	change->allocated.array.data[change->allocated.array.len + 1] = NULL;
1338
1339	change->allocated.array.len ++;
1340
1341	*(gchar ***)entry->arg_data = change->allocated.array.data;
1342
1343	break;
1344	}
1345
1346	case G_OPTION_ARG_FILENAME:
1347	{
1348	gchar *data;
1349
1350	#ifdef G_OS_WIN32
1351	if (!context->strv_mode)
1352	data = g_locale_to_utf8 (value, -1, NULL, NULL, error);
1353	else
1354	data = g_strdup (value);
1355
1356	if (!data)
1357	return FALSE;
1358	#else
1359	data = g_strdup (str: value);
1360	#endif
1361	change = get_change (context, arg_type: G_OPTION_ARG_FILENAME,
1362	arg_data: entry->arg_data);
1363
1364	if (!change->allocated.str)
1365	change->prev.str = *(gchar **)entry->arg_data;
1366	else
1367	g_free (mem: change->allocated.str);
1368
1369	change->allocated.str = data;
1370
1371	*(gchar **)entry->arg_data = data;
1372	break;
1373	}
1374
1375	case G_OPTION_ARG_FILENAME_ARRAY:
1376	{
1377	gchar *data;
1378
1379	#ifdef G_OS_WIN32
1380	if (!context->strv_mode)
1381	data = g_locale_to_utf8 (value, -1, NULL, NULL, error);
1382	else
1383	data = g_strdup (value);
1384
1385	if (!data)
1386	return FALSE;
1387	#else
1388	data = g_strdup (str: value);
1389	#endif
1390	change = get_change (context, arg_type: G_OPTION_ARG_STRING_ARRAY,
1391	arg_data: entry->arg_data);
1392
1393	if (change->allocated.array.len == 0)
1394	{
1395	change->prev.array = *(gchar ***)entry->arg_data;
1396	change->allocated.array.data = g_new (gchar *, 2);
1397	}
1398	else
1399	change->allocated.array.data =
1400	g_renew (gchar *, change->allocated.array.data,
1401	change->allocated.array.len + 2);
1402
1403	change->allocated.array.data[change->allocated.array.len] = data;
1404	change->allocated.array.data[change->allocated.array.len + 1] = NULL;
1405
1406	change->allocated.array.len ++;
1407
1408	*(gchar ***)entry->arg_data = change->allocated.array.data;
1409
1410	break;
1411	}
1412
1413	case G_OPTION_ARG_INT:
1414	{
1415	gint data;
1416
1417	if (!parse_int (arg_name: option_name, arg: value,
1418	result: &data,
1419	error))
1420	return FALSE;
1421
1422	change = get_change (context, arg_type: G_OPTION_ARG_INT,
1423	arg_data: entry->arg_data);
1424	change->prev.integer = *(gint *)entry->arg_data;
1425	*(gint *)entry->arg_data = data;
1426	break;
1427	}
1428	case G_OPTION_ARG_CALLBACK:
1429	{
1430	gchar *data;
1431	gboolean retval;
1432
1433	if (!value && entry->flags & G_OPTION_FLAG_OPTIONAL_ARG)
1434	data = NULL;
1435	else if (entry->flags & G_OPTION_FLAG_NO_ARG)
1436	data = NULL;
1437	else if (entry->flags & G_OPTION_FLAG_FILENAME)
1438	{
1439	#ifdef G_OS_WIN32
1440	if (!context->strv_mode)
1441	data = g_locale_to_utf8 (value, -1, NULL, NULL, error);
1442	else
1443	data = g_strdup (value);
1444	#else
1445	data = g_strdup (str: value);
1446	#endif
1447	}
1448	else
1449	data = g_locale_to_utf8 (opsysstring: value, len: -1, NULL, NULL, error);
1450
1451	if (!(entry->flags & (G_OPTION_FLAG_NO_ARG|G_OPTION_FLAG_OPTIONAL_ARG)) &&
1452	!data)
1453	return FALSE;
1454
1455	retval = (* (GOptionArgFunc) entry->arg_data) (option_name, data, group->user_data, error);
1456
1457	if (!retval && error != NULL && *error == NULL)
1458	g_set_error (err: error,
1459	G_OPTION_ERROR, code: G_OPTION_ERROR_FAILED,
1460	_("Error parsing option %s"), option_name);
1461
1462	g_free (mem: data);
1463
1464	return retval;
1465
1466	break;
1467	}
1468	case G_OPTION_ARG_DOUBLE:
1469	{
1470	gdouble data;
1471
1472	if (!parse_double (arg_name: option_name, arg: value,
1473	result: &data,
1474	error))
1475	{
1476	return FALSE;
1477	}
1478
1479	change = get_change (context, arg_type: G_OPTION_ARG_DOUBLE,
1480	arg_data: entry->arg_data);
1481	change->prev.dbl = *(gdouble *)entry->arg_data;
1482	*(gdouble *)entry->arg_data = data;
1483	break;
1484	}
1485	case G_OPTION_ARG_INT64:
1486	{
1487	gint64 data;
1488
1489	if (!parse_int64 (arg_name: option_name, arg: value,
1490	result: &data,
1491	error))
1492	{
1493	return FALSE;
1494	}
1495
1496	change = get_change (context, arg_type: G_OPTION_ARG_INT64,
1497	arg_data: entry->arg_data);
1498	change->prev.int64 = *(gint64 *)entry->arg_data;
1499	*(gint64 *)entry->arg_data = data;
1500	break;
1501	}
1502	default:
1503	g_assert_not_reached ();
1504	}
1505
1506	return TRUE;
1507	}
1508
1509	static gboolean
1510	parse_short_option (GOptionContext *context,
1511	GOptionGroup *group,
1512	gint idx,
1513	gint *new_idx,
1514	gchar arg,
1515	gint *argc,
1516	gchar ***argv,
1517	GError **error,
1518	gboolean *parsed)
1519	{
1520	gsize j;
1521
1522	for (j = 0; j < group->n_entries; j++)
1523	{
1524	if (arg == group->entries[j].short_name)
1525	{
1526	gchar *option_name;
1527	gchar *value = NULL;
1528
1529	option_name = g_strdup_printf (format: "-%c", group->entries[j].short_name);
1530
1531	if (NO_ARG (&group->entries[j]))
1532	value = NULL;
1533	else
1534	{
1535	if (*new_idx > idx)
1536	{
1537	g_set_error (err: error,
1538	G_OPTION_ERROR, code: G_OPTION_ERROR_FAILED,
1539	_("Error parsing option %s"), option_name);
1540	g_free (mem: option_name);
1541	return FALSE;
1542	}
1543
1544	if (idx < *argc - 1)
1545	{
1546	if (!OPTIONAL_ARG (&group->entries[j]))
1547	{
1548	value = (*argv)[idx + 1];
1549	add_pending_null (context, ptr: &((*argv)[idx + 1]), NULL);
1550	*new_idx = idx + 1;
1551	}
1552	else
1553	{
1554	if ((*argv)[idx + 1][0] == '-')
1555	value = NULL;
1556	else
1557	{
1558	value = (*argv)[idx + 1];
1559	add_pending_null (context, ptr: &((*argv)[idx + 1]), NULL);
1560	*new_idx = idx + 1;
1561	}
1562	}
1563	}
1564	else if (idx >= *argc - 1 && OPTIONAL_ARG (&group->entries[j]))
1565	value = NULL;
1566	else
1567	{
1568	g_set_error (err: error,
1569	G_OPTION_ERROR, code: G_OPTION_ERROR_BAD_VALUE,
1570	_("Missing argument for %s"), option_name);
1571	g_free (mem: option_name);
1572	return FALSE;
1573	}
1574	}
1575
1576	if (!parse_arg (context, group, entry: &group->entries[j],
1577	value, option_name, error))
1578	{
1579	g_free (mem: option_name);
1580	return FALSE;
1581	}
1582
1583	g_free (mem: option_name);
1584	*parsed = TRUE;
1585	}
1586	}
1587
1588	return TRUE;
1589	}
1590
1591	static gboolean
1592	parse_long_option (GOptionContext *context,
1593	GOptionGroup *group,
1594	gint *idx,
1595	gchar *arg,
1596	gboolean aliased,
1597	gint *argc,
1598	gchar ***argv,
1599	GError **error,
1600	gboolean *parsed)
1601	{
1602	gsize j;
1603
1604	for (j = 0; j < group->n_entries; j++)
1605	{
1606	if (*idx >= *argc)
1607	return TRUE;
1608
1609	if (aliased && (group->entries[j].flags & G_OPTION_FLAG_NOALIAS))
1610	continue;
1611
1612	if (NO_ARG (&group->entries[j]) &&
1613	strcmp (s1: arg, s2: group->entries[j].long_name) == 0)
1614	{
1615	gchar *option_name;
1616	gboolean retval;
1617
1618	option_name = g_strconcat (string1: "--", group->entries[j].long_name, NULL);
1619	retval = parse_arg (context, group, entry: &group->entries[j],
1620	NULL, option_name, error);
1621	g_free (mem: option_name);
1622
1623	add_pending_null (context, ptr: &((*argv)[*idx]), NULL);
1624	*parsed = TRUE;
1625
1626	return retval;
1627	}
1628	else
1629	{
1630	gint len = strlen (s: group->entries[j].long_name);
1631
1632	if (strncmp (s1: arg, s2: group->entries[j].long_name, n: len) == 0 &&
1633	(arg[len] == '=' || arg[len] == 0))
1634	{
1635	gchar *value = NULL;
1636	gchar *option_name;
1637
1638	add_pending_null (context, ptr: &((*argv)[*idx]), NULL);
1639	option_name = g_strconcat (string1: "--", group->entries[j].long_name, NULL);
1640
1641	if (arg[len] == '=')
1642	value = arg + len + 1;
1643	else if (*idx < *argc - 1)
1644	{
1645	if (!OPTIONAL_ARG (&group->entries[j]))
1646	{
1647	value = (*argv)[*idx + 1];
1648	add_pending_null (context, ptr: &((*argv)[*idx + 1]), NULL);
1649	(*idx)++;
1650	}
1651	else
1652	{
1653	if ((*argv)[*idx + 1][0] == '-')
1654	{
1655	gboolean retval;
1656	retval = parse_arg (context, group, entry: &group->entries[j],
1657	NULL, option_name, error);
1658	*parsed = TRUE;
1659	g_free (mem: option_name);
1660	return retval;
1661	}
1662	else
1663	{
1664	value = (*argv)[*idx + 1];
1665	add_pending_null (context, ptr: &((*argv)[*idx + 1]), NULL);
1666	(*idx)++;
1667	}
1668	}
1669	}
1670	else if (*idx >= *argc - 1 && OPTIONAL_ARG (&group->entries[j]))
1671	{
1672	gboolean retval;
1673	retval = parse_arg (context, group, entry: &group->entries[j],
1674	NULL, option_name, error);
1675	*parsed = TRUE;
1676	g_free (mem: option_name);
1677	return retval;
1678	}
1679	else
1680	{
1681	g_set_error (err: error,
1682	G_OPTION_ERROR, code: G_OPTION_ERROR_BAD_VALUE,
1683	_("Missing argument for %s"), option_name);
1684	g_free (mem: option_name);
1685	return FALSE;
1686	}
1687
1688	if (!parse_arg (context, group, entry: &group->entries[j],
1689	value, option_name, error))
1690	{
1691	g_free (mem: option_name);
1692	return FALSE;
1693	}
1694
1695	g_free (mem: option_name);
1696	*parsed = TRUE;
1697	}
1698	}
1699	}
1700
1701	return TRUE;
1702	}
1703
1704	static gboolean
1705	parse_remaining_arg (GOptionContext *context,
1706	GOptionGroup *group,
1707	gint *idx,
1708	gint *argc,
1709	gchar ***argv,
1710	GError **error,
1711	gboolean *parsed)
1712	{
1713	gsize j;
1714
1715	for (j = 0; j < group->n_entries; j++)
1716	{
1717	if (*idx >= *argc)
1718	return TRUE;
1719
1720	if (group->entries[j].long_name[0])
1721	continue;
1722
1723	g_return_val_if_fail (group->entries[j].arg == G_OPTION_ARG_CALLBACK ||
1724	group->entries[j].arg == G_OPTION_ARG_STRING_ARRAY ||
1725	group->entries[j].arg == G_OPTION_ARG_FILENAME_ARRAY, FALSE);
1726
1727	add_pending_null (context, ptr: &((*argv)[*idx]), NULL);
1728
1729	if (!parse_arg (context, group, entry: &group->entries[j], value: (*argv)[*idx], option_name: "", error))
1730	return FALSE;
1731
1732	*parsed = TRUE;
1733	return TRUE;
1734	}
1735
1736	return TRUE;
1737	}
1738
1739	static void
1740	free_changes_list (GOptionContext *context,
1741	gboolean revert)
1742	{
1743	GList *list;
1744
1745	for (list = context->changes; list != NULL; list = list->next)
1746	{
1747	Change *change = list->data;
1748
1749	if (revert)
1750	{
1751	switch (change->arg_type)
1752	{
1753	case G_OPTION_ARG_NONE:
1754	*(gboolean *)change->arg_data = change->prev.bool;
1755	break;
1756	case G_OPTION_ARG_INT:
1757	*(gint *)change->arg_data = change->prev.integer;
1758	break;
1759	case G_OPTION_ARG_STRING:
1760	case G_OPTION_ARG_FILENAME:
1761	g_free (mem: change->allocated.str);
1762	*(gchar **)change->arg_data = change->prev.str;
1763	break;
1764	case G_OPTION_ARG_STRING_ARRAY:
1765	case G_OPTION_ARG_FILENAME_ARRAY:
1766	g_strfreev (str_array: change->allocated.array.data);
1767	*(gchar ***)change->arg_data = change->prev.array;
1768	break;
1769	case G_OPTION_ARG_DOUBLE:
1770	*(gdouble *)change->arg_data = change->prev.dbl;
1771	break;
1772	case G_OPTION_ARG_INT64:
1773	*(gint64 *)change->arg_data = change->prev.int64;
1774	break;
1775	default:
1776	g_assert_not_reached ();
1777	}
1778	}
1779
1780	g_free (mem: change);
1781	}
1782
1783	g_list_free (list: context->changes);
1784	context->changes = NULL;
1785	}
1786
1787	static void
1788	free_pending_nulls (GOptionContext *context,
1789	gboolean perform_nulls)
1790	{
1791	GList *list;
1792
1793	for (list = context->pending_nulls; list != NULL; list = list->next)
1794	{
1795	PendingNull *n = list->data;
1796
1797	if (perform_nulls)
1798	{
1799	if (n->value)
1800	{
1801	/* Copy back the short options */
1802	*(n->ptr)[0] = '-';
1803	strcpy (dest: *n->ptr + 1, src: n->value);
1804	}
1805	else
1806	{
1807	if (context->strv_mode)
1808	g_free (mem: *n->ptr);
1809
1810	*n->ptr = NULL;
1811	}
1812	}
1813
1814	g_free (mem: n->value);
1815	g_free (mem: n);
1816	}
1817
1818	g_list_free (list: context->pending_nulls);
1819	context->pending_nulls = NULL;
1820	}
1821
1822	/* Use a platform-specific mechanism to look up the first argument to
1823	* the current process.
1824	* Note if you implement this for other platforms, also add it to
1825	* tests/option-argv0.c
1826	*/
1827	static char *
1828	platform_get_argv0 (void)
1829	{
1830	#ifdef HAVE_PROC_SELF_CMDLINE
1831	char *cmdline;
1832	char *base_arg0;
1833	gsize len;
1834
1835	if (!g_file_get_contents (filename: "/proc/self/cmdline",
1836	contents: &cmdline,
1837	length: &len,
1838	NULL))
1839	return NULL;
1840
1841	/* g_file_get_contents() guarantees to put a NUL immediately after the
1842	* file's contents (at cmdline[len] here), even if the file itself was
1843	* not NUL-terminated. */
1844	g_assert (memchr (cmdline, 0, len + 1));
1845
1846	/* We could just return cmdline, but I think it's better
1847	* to hold on to a smaller malloc block; the arguments
1848	* could be large.
1849	*/
1850	base_arg0 = g_path_get_basename (file_name: cmdline);
1851	g_free (mem: cmdline);
1852	return base_arg0;
1853	#elif defined __OpenBSD__
1854	char **cmdline;
1855	char *base_arg0;
1856	gsize len;
1857
1858	int mib[] = { CTL_KERN, KERN_PROC_ARGS, getpid(), KERN_PROC_ARGV };
1859
1860	if (sysctl (mib, G_N_ELEMENTS (mib), NULL, &len, NULL, 0) == -1)
1861	return NULL;
1862
1863	cmdline = g_malloc0 (len);
1864
1865	if (sysctl (mib, G_N_ELEMENTS (mib), cmdline, &len, NULL, 0) == -1)
1866	{
1867	g_free (cmdline);
1868	return NULL;
1869	}
1870
1871	/* We could just return cmdline, but I think it's better
1872	* to hold on to a smaller malloc block; the arguments
1873	* could be large.
1874	*/
1875	base_arg0 = g_path_get_basename (*cmdline);
1876	g_free (cmdline);
1877	return base_arg0;
1878	#elif defined G_OS_WIN32
1879	const wchar_t *cmdline;
1880	wchar_t **wargv;
1881	int wargc;
1882	gchar *utf8_buf = NULL;
1883	char *base_arg0 = NULL;
1884
1885	/* Pretend it's const, since we're not allowed to free it */
1886	cmdline = (const wchar_t *) GetCommandLineW ();
1887	if (G_UNLIKELY (cmdline == NULL))
1888	return NULL;
1889
1890	/* Skip leading whitespace. CommandLineToArgvW() is documented
1891	* to behave weirdly with that. The character codes below
1892	* correspond to the *only* unicode characters that are
1893	* considered to be spaces by CommandLineToArgvW(). The rest
1894	* (such as 0xa0 - NO-BREAK SPACE) are treated as
1895	* normal characters.
1896	*/
1897	while (cmdline[0] == 0x09 ||
1898	cmdline[0] == 0x0a ||
1899	cmdline[0] == 0x0c ||
1900	cmdline[0] == 0x0d ||
1901	cmdline[0] == 0x20)
1902	cmdline++;
1903
1904	wargv = CommandLineToArgvW (cmdline, &wargc);
1905	if (G_UNLIKELY (wargv == NULL))
1906	return NULL;
1907
1908	if (wargc > 0)
1909	utf8_buf = g_utf16_to_utf8 (wargv[0], -1, NULL, NULL, NULL);
1910
1911	LocalFree (wargv);
1912
1913	if (G_UNLIKELY (utf8_buf == NULL))
1914	return NULL;
1915
1916	/* We could just return cmdline, but I think it's better
1917	* to hold on to a smaller malloc block; the arguments
1918	* could be large.
1919	*/
1920	base_arg0 = g_path_get_basename (utf8_buf);
1921	g_free (utf8_buf);
1922	return base_arg0;
1923	#endif
1924
1925	return NULL;
1926	}
1927
1928	/**
1929	* g_option_context_parse:
1930	* @context: a #GOptionContext
1931	* @argc: (inout) (optional): a pointer to the number of command line arguments
1932	* @argv: (inout) (array length=argc) (optional): a pointer to the array of command line arguments
1933	* @error: a return location for errors
1934	*
1935	* Parses the command line arguments, recognizing options
1936	* which have been added to @context. A side-effect of
1937	* calling this function is that g_set_prgname() will be
1938	* called.
1939	*
1940	* If the parsing is successful, any parsed arguments are
1941	* removed from the array and @argc and @argv are updated
1942	* accordingly. A '--' option is stripped from @argv
1943	* unless there are unparsed options before and after it,
1944	* or some of the options after it start with '-'. In case
1945	* of an error, @argc and @argv are left unmodified.
1946	*
1947	* If automatic `--help` support is enabled
1948	* (see g_option_context_set_help_enabled()), and the
1949	* @argv array contains one of the recognized help options,
1950	* this function will produce help output to stdout and
1951	* call `exit (0)`.
1952	*
1953	* Note that function depends on the [current locale][setlocale] for
1954	* automatic character set conversion of string and filename
1955	* arguments.
1956	*
1957	* Returns: %TRUE if the parsing was successful,
1958	* %FALSE if an error occurred
1959	*
1960	* Since: 2.6
1961	**/
1962	gboolean
1963	g_option_context_parse (GOptionContext *context,
1964	gint *argc,
1965	gchar ***argv,
1966	GError **error)
1967	{
1968	gint i, j, k;
1969	GList *list;
1970
1971	g_return_val_if_fail (context != NULL, FALSE);
1972
1973	/* Set program name */
1974	if (!g_get_prgname())
1975	{
1976	gchar *prgname;
1977
1978	if (argc && argv && *argc)
1979	prgname = g_path_get_basename (file_name: (*argv)[0]);
1980	else
1981	prgname = platform_get_argv0 ();
1982
1983	if (prgname)
1984	g_set_prgname (prgname);
1985	else
1986	g_set_prgname (prgname: "<unknown>");
1987
1988	g_free (mem: prgname);
1989	}
1990
1991	/* Call pre-parse hooks */
1992	list = context->groups;
1993	while (list)
1994	{
1995	GOptionGroup *group = list->data;
1996
1997	if (group->pre_parse_func)
1998	{
1999	if (!(* group->pre_parse_func) (context, group,
2000	group->user_data, error))
2001	goto fail;
2002	}
2003
2004	list = list->next;
2005	}
2006
2007	if (context->main_group && context->main_group->pre_parse_func)
2008	{
2009	if (!(* context->main_group->pre_parse_func) (context, context->main_group,
2010	context->main_group->user_data, error))
2011	goto fail;
2012	}
2013
2014	if (argc && argv)
2015	{
2016	gboolean stop_parsing = FALSE;
2017	gboolean has_unknown = FALSE;
2018	gint separator_pos = 0;
2019
2020	for (i = 1; i < *argc; i++)
2021	{
2022	gchar *arg, *dash;
2023	gboolean parsed = FALSE;
2024
2025	if ((*argv)[i][0] == '-' && (*argv)[i][1] != '\0' && !stop_parsing)
2026	{
2027	if ((*argv)[i][1] == '-')
2028	{
2029	/* -- option */
2030
2031	arg = (*argv)[i] + 2;
2032
2033	/* '--' terminates list of arguments */
2034	if (*arg == 0)
2035	{
2036	separator_pos = i;
2037	stop_parsing = TRUE;
2038	continue;
2039	}
2040
2041	/* Handle help options */
2042	if (context->help_enabled)
2043	{
2044	if (strcmp (s1: arg, s2: "help") == 0)
2045	print_help (context, TRUE, NULL);
2046	else if (strcmp (s1: arg, s2: "help-all") == 0)
2047	print_help (context, FALSE, NULL);
2048	else if (strncmp (s1: arg, s2: "help-", n: 5) == 0)
2049	{
2050	list = context->groups;
2051
2052	while (list)
2053	{
2054	GOptionGroup *group = list->data;
2055
2056	if (strcmp (s1: arg + 5, s2: group->name) == 0)
2057	print_help (context, FALSE, group);
2058
2059	list = list->next;
2060	}
2061	}
2062	}
2063
2064	if (context->main_group &&
2065	!parse_long_option (context, group: context->main_group, idx: &i, arg,
2066	FALSE, argc, argv, error, parsed: &parsed))
2067	goto fail;
2068
2069	if (parsed)
2070	continue;
2071
2072	/* Try the groups */
2073	list = context->groups;
2074	while (list)
2075	{
2076	GOptionGroup *group = list->data;
2077
2078	if (!parse_long_option (context, group, idx: &i, arg,
2079	FALSE, argc, argv, error, parsed: &parsed))
2080	goto fail;
2081
2082	if (parsed)
2083	break;
2084
2085	list = list->next;
2086	}
2087
2088	if (parsed)
2089	continue;
2090
2091	/* Now look for --<group>-<option> */
2092	dash = strchr (s: arg, c: '-');
2093	if (dash && arg < dash)
2094	{
2095	/* Try the groups */
2096	list = context->groups;
2097	while (list)
2098	{
2099	GOptionGroup *group = list->data;
2100
2101	if (strncmp (s1: group->name, s2: arg, n: dash - arg) == 0)
2102	{
2103	if (!parse_long_option (context, group, idx: &i, arg: dash + 1,
2104	TRUE, argc, argv, error, parsed: &parsed))
2105	goto fail;
2106
2107	if (parsed)
2108	break;
2109	}
2110
2111	list = list->next;
2112	}
2113	}
2114
2115	if (context->ignore_unknown)
2116	continue;
2117	}
2118	else
2119	{ /* short option */
2120	gint new_i = i, arg_length;
2121	gboolean *nulled_out = NULL;
2122	gboolean has_h_entry = context_has_h_entry (context);
2123	arg = (*argv)[i] + 1;
2124	arg_length = strlen (s: arg);
2125	nulled_out = g_newa (gboolean, arg_length);
2126	memset (s: nulled_out, c: 0, n: arg_length * sizeof (gboolean));
2127	for (j = 0; j < arg_length; j++)
2128	{
2129	if (context->help_enabled && (arg[j] == '?' ||
2130	(arg[j] == 'h' && !has_h_entry)))
2131	print_help (context, TRUE, NULL);
2132	parsed = FALSE;
2133	if (context->main_group &&
2134	!parse_short_option (context, group: context->main_group,
2135	idx: i, new_idx: &new_i, arg: arg[j],
2136	argc, argv, error, parsed: &parsed))
2137	goto fail;
2138	if (!parsed)
2139	{
2140	/* Try the groups */
2141	list = context->groups;
2142	while (list)
2143	{
2144	GOptionGroup *group = list->data;
2145	if (!parse_short_option (context, group, idx: i, new_idx: &new_i, arg: arg[j],
2146	argc, argv, error, parsed: &parsed))
2147	goto fail;
2148	if (parsed)
2149	break;
2150	list = list->next;
2151	}
2152	}
2153
2154	if (context->ignore_unknown && parsed)
2155	nulled_out[j] = TRUE;
2156	else if (context->ignore_unknown)
2157	continue;
2158	else if (!parsed)
2159	break;
2160	/* !context->ignore_unknown && parsed */
2161	}
2162	if (context->ignore_unknown)
2163	{
2164	gchar *new_arg = NULL;
2165	gint arg_index = 0;
2166	for (j = 0; j < arg_length; j++)
2167	{
2168	if (!nulled_out[j])
2169	{
2170	if (!new_arg)
2171	new_arg = g_malloc (n_bytes: arg_length + 1);
2172	new_arg[arg_index++] = arg[j];
2173	}
2174	}
2175	if (new_arg)
2176	new_arg[arg_index] = '\0';
2177	add_pending_null (context, ptr: &((*argv)[i]), value: new_arg);
2178	i = new_i;
2179	}
2180	else if (parsed)
2181	{
2182	add_pending_null (context, ptr: &((*argv)[i]), NULL);
2183	i = new_i;
2184	}
2185	}
2186
2187	if (!parsed)
2188	has_unknown = TRUE;
2189
2190	if (!parsed && !context->ignore_unknown)
2191	{
2192	g_set_error (err: error,
2193	G_OPTION_ERROR, code: G_OPTION_ERROR_UNKNOWN_OPTION,
2194	_("Unknown option %s"), (*argv)[i]);
2195	goto fail;
2196	}
2197	}
2198	else
2199	{
2200	if (context->strict_posix)
2201	stop_parsing = TRUE;
2202
2203	/* Collect remaining args */
2204	if (context->main_group &&
2205	!parse_remaining_arg (context, group: context->main_group, idx: &i,
2206	argc, argv, error, parsed: &parsed))
2207	goto fail;
2208
2209	if (!parsed && (has_unknown || (*argv)[i][0] == '-'))
2210	separator_pos = 0;
2211	}
2212	}
2213
2214	if (separator_pos > 0)
2215	add_pending_null (context, ptr: &((*argv)[separator_pos]), NULL);
2216
2217	}
2218
2219	/* Call post-parse hooks */
2220	list = context->groups;
2221	while (list)
2222	{
2223	GOptionGroup *group = list->data;
2224
2225	if (group->post_parse_func)
2226	{
2227	if (!(* group->post_parse_func) (context, group,
2228	group->user_data, error))
2229	goto fail;
2230	}
2231
2232	list = list->next;
2233	}
2234
2235	if (context->main_group && context->main_group->post_parse_func)
2236	{
2237	if (!(* context->main_group->post_parse_func) (context, context->main_group,
2238	context->main_group->user_data, error))
2239	goto fail;
2240	}
2241
2242	if (argc && argv)
2243	{
2244	free_pending_nulls (context, TRUE);
2245
2246	for (i = 1; i < *argc; i++)
2247	{
2248	for (k = i; k < *argc; k++)
2249	if ((*argv)[k] != NULL)
2250	break;
2251
2252	if (k > i)
2253	{
2254	k -= i;
2255	for (j = i + k; j < *argc; j++)
2256	{
2257	(*argv)[j-k] = (*argv)[j];
2258	(*argv)[j] = NULL;
2259	}
2260	*argc -= k;
2261	}
2262	}
2263	}
2264
2265	return TRUE;
2266
2267	fail:
2268
2269	/* Call error hooks */
2270	list = context->groups;
2271	while (list)
2272	{
2273	GOptionGroup *group = list->data;
2274
2275	if (group->error_func)
2276	(* group->error_func) (context, group,
2277	group->user_data, error);
2278
2279	list = list->next;
2280	}
2281
2282	if (context->main_group && context->main_group->error_func)
2283	(* context->main_group->error_func) (context, context->main_group,
2284	context->main_group->user_data, error);
2285
2286	free_changes_list (context, TRUE);
2287	free_pending_nulls (context, FALSE);
2288
2289	return FALSE;
2290	}
2291
2292	/**
2293	* g_option_group_new:
2294	* @name: the name for the option group, this is used to provide
2295	* help for the options in this group with `--help-`@name
2296	* @description: a description for this group to be shown in
2297	* `--help`. This string is translated using the translation
2298	* domain or translation function of the group
2299	* @help_description: a description for the `--help-`@name option.
2300	* This string is translated using the translation domain or translation function
2301	* of the group
2302	* @user_data: (nullable): user data that will be passed to the pre- and post-parse hooks,
2303	* the error hook and to callbacks of %G_OPTION_ARG_CALLBACK options, or %NULL
2304	* @destroy: (nullable): a function that will be called to free @user_data, or %NULL
2305	*
2306	* Creates a new #GOptionGroup.
2307	*
2308	* Returns: a newly created option group. It should be added
2309	* to a #GOptionContext or freed with g_option_group_unref().
2310	*
2311	* Since: 2.6
2312	**/
2313	GOptionGroup *
2314	g_option_group_new (const gchar *name,
2315	const gchar *description,
2316	const gchar *help_description,
2317	gpointer user_data,
2318	GDestroyNotify destroy)
2319
2320	{
2321	GOptionGroup *group;
2322
2323	group = g_new0 (GOptionGroup, 1);
2324	group->ref_count = 1;
2325	group->name = g_strdup (str: name);
2326	group->description = g_strdup (str: description);
2327	group->help_description = g_strdup (str: help_description);
2328	group->user_data = user_data;
2329	group->destroy_notify = destroy;
2330
2331	return group;
2332	}
2333
2334
2335	/**
2336	* g_option_group_free:
2337	* @group: a #GOptionGroup
2338	*
2339	* Frees a #GOptionGroup. Note that you must not free groups
2340	* which have been added to a #GOptionContext.
2341	*
2342	* Since: 2.6
2343	*
2344	* Deprecated: 2.44: Use g_option_group_unref() instead.
2345	*/
2346	void
2347	g_option_group_free (GOptionGroup *group)
2348	{
2349	g_option_group_unref (group);
2350	}
2351
2352	/**
2353	* g_option_group_ref:
2354	* @group: a #GOptionGroup
2355	*
2356	* Increments the reference count of @group by one.
2357	*
2358	* Returns: a #GOptionGroup
2359	*
2360	* Since: 2.44
2361	*/
2362	GOptionGroup *
2363	g_option_group_ref (GOptionGroup *group)
2364	{
2365	g_return_val_if_fail (group != NULL, NULL);
2366
2367	group->ref_count++;
2368
2369	return group;
2370	}
2371
2372	/**
2373	* g_option_group_unref:
2374	* @group: a #GOptionGroup
2375	*
2376	* Decrements the reference count of @group by one.
2377	* If the reference count drops to 0, the @group will be freed.
2378	* and all memory allocated by the @group is released.
2379	*
2380	* Since: 2.44
2381	*/
2382	void
2383	g_option_group_unref (GOptionGroup *group)
2384	{
2385	g_return_if_fail (group != NULL);
2386
2387	if (--group->ref_count == 0)
2388	{
2389	g_free (mem: group->name);
2390	g_free (mem: group->description);
2391	g_free (mem: group->help_description);
2392
2393	g_free (mem: group->entries);
2394
2395	if (group->destroy_notify)
2396	(* group->destroy_notify) (group->user_data);
2397
2398	if (group->translate_notify)
2399	(* group->translate_notify) (group->translate_data);
2400
2401	g_free (mem: group);
2402	}
2403	}
2404
2405	/**
2406	* g_option_group_add_entries:
2407	* @group: a #GOptionGroup
2408	* @entries: (array zero-terminated=1): a %NULL-terminated array of #GOptionEntrys
2409	*
2410	* Adds the options specified in @entries to @group.
2411	*
2412	* Since: 2.6
2413	**/
2414	void
2415	g_option_group_add_entries (GOptionGroup *group,
2416	const GOptionEntry *entries)
2417	{
2418	gsize i, n_entries;
2419
2420	g_return_if_fail (group != NULL);
2421	g_return_if_fail (entries != NULL);
2422
2423	for (n_entries = 0; entries[n_entries].long_name != NULL; n_entries++) ;
2424
2425	g_return_if_fail (n_entries <= G_MAXSIZE - group->n_entries);
2426
2427	group->entries = g_renew (GOptionEntry, group->entries, group->n_entries + n_entries);
2428
2429	/* group->entries could be NULL in the trivial case where we add no
2430	* entries to no entries */
2431	if (n_entries != 0)
2432	memcpy (dest: group->entries + group->n_entries, src: entries, n: sizeof (GOptionEntry) * n_entries);
2433
2434	for (i = group->n_entries; i < group->n_entries + n_entries; i++)
2435	{
2436	gchar c = group->entries[i].short_name;
2437
2438	if (c == '-' || (c != 0 && !g_ascii_isprint (c)))
2439	{
2440	g_warning (G_STRLOC ": ignoring invalid short option '%c' (%d) in entry %s:%s",
2441	c, c, group->name, group->entries[i].long_name);
2442	group->entries[i].short_name = '\0';
2443	}
2444
2445	if (group->entries[i].arg != G_OPTION_ARG_NONE &&
2446	(group->entries[i].flags & G_OPTION_FLAG_REVERSE) != 0)
2447	{
2448	g_warning (G_STRLOC ": ignoring reverse flag on option of arg-type %d in entry %s:%s",
2449	group->entries[i].arg, group->name, group->entries[i].long_name);
2450
2451	group->entries[i].flags &= ~G_OPTION_FLAG_REVERSE;
2452	}
2453
2454	if (group->entries[i].arg != G_OPTION_ARG_CALLBACK &&
2455	(group->entries[i].flags & (G_OPTION_FLAG_NO_ARG|G_OPTION_FLAG_OPTIONAL_ARG|G_OPTION_FLAG_FILENAME)) != 0)
2456	{
2457	g_warning (G_STRLOC ": ignoring no-arg, optional-arg or filename flags (%d) on option of arg-type %d in entry %s:%s",
2458	group->entries[i].flags, group->entries[i].arg, group->name, group->entries[i].long_name);
2459
2460	group->entries[i].flags &= ~(G_OPTION_FLAG_NO_ARG|G_OPTION_FLAG_OPTIONAL_ARG|G_OPTION_FLAG_FILENAME);
2461	}
2462	}
2463
2464	group->n_entries += n_entries;
2465	}
2466
2467	/**
2468	* g_option_group_set_parse_hooks:
2469	* @group: a #GOptionGroup
2470	* @pre_parse_func: (nullable): a function to call before parsing, or %NULL
2471	* @post_parse_func: (nullable): a function to call after parsing, or %NULL
2472	*
2473	* Associates two functions with @group which will be called
2474	* from g_option_context_parse() before the first option is parsed
2475	* and after the last option has been parsed, respectively.
2476	*
2477	* Note that the user data to be passed to @pre_parse_func and
2478	* @post_parse_func can be specified when constructing the group
2479	* with g_option_group_new().
2480	*
2481	* Since: 2.6
2482	**/
2483	void
2484	g_option_group_set_parse_hooks (GOptionGroup *group,
2485	GOptionParseFunc pre_parse_func,
2486	GOptionParseFunc post_parse_func)
2487	{
2488	g_return_if_fail (group != NULL);
2489
2490	group->pre_parse_func = pre_parse_func;
2491	group->post_parse_func = post_parse_func;
2492	}
2493
2494	/**
2495	* g_option_group_set_error_hook:
2496	* @group: a #GOptionGroup
2497	* @error_func: a function to call when an error occurs
2498	*
2499	* Associates a function with @group which will be called
2500	* from g_option_context_parse() when an error occurs.
2501	*
2502	* Note that the user data to be passed to @error_func can be
2503	* specified when constructing the group with g_option_group_new().
2504	*
2505	* Since: 2.6
2506	**/
2507	void
2508	g_option_group_set_error_hook (GOptionGroup *group,
2509	GOptionErrorFunc error_func)
2510	{
2511	g_return_if_fail (group != NULL);
2512
2513	group->error_func = error_func;
2514	}
2515
2516
2517	/**
2518	* g_option_group_set_translate_func:
2519	* @group: a #GOptionGroup
2520	* @func: (nullable): the #GTranslateFunc, or %NULL
2521	* @data: (nullable): user data to pass to @func, or %NULL
2522	* @destroy_notify: (nullable): a function which gets called to free @data, or %NULL
2523	*
2524	* Sets the function which is used to translate user-visible strings,
2525	* for `--help` output. Different groups can use different
2526	* #GTranslateFuncs. If @func is %NULL, strings are not translated.
2527	*
2528	* If you are using gettext(), you only need to set the translation
2529	* domain, see g_option_group_set_translation_domain().
2530	*
2531	* Since: 2.6
2532	**/
2533	void
2534	g_option_group_set_translate_func (GOptionGroup *group,
2535	GTranslateFunc func,
2536	gpointer data,
2537	GDestroyNotify destroy_notify)
2538	{
2539	g_return_if_fail (group != NULL);
2540
2541	if (group->translate_notify)
2542	group->translate_notify (group->translate_data);
2543
2544	group->translate_func = func;
2545	group->translate_data = data;
2546	group->translate_notify = destroy_notify;
2547	}
2548
2549	static const gchar *
2550	dgettext_swapped (const gchar *msgid,
2551	const gchar *domainname)
2552	{
2553	return g_dgettext (domain: domainname, msgid);
2554	}
2555
2556	/**
2557	* g_option_group_set_translation_domain:
2558	* @group: a #GOptionGroup
2559	* @domain: the domain to use
2560	*
2561	* A convenience function to use gettext() for translating
2562	* user-visible strings.
2563	*
2564	* Since: 2.6
2565	**/
2566	void
2567	g_option_group_set_translation_domain (GOptionGroup *group,
2568	const gchar *domain)
2569	{
2570	g_return_if_fail (group != NULL);
2571
2572	g_option_group_set_translate_func (group,
2573	func: (GTranslateFunc)dgettext_swapped,
2574	data: g_strdup (str: domain),
2575	destroy_notify: g_free);
2576	}
2577
2578	/**
2579	* g_option_context_set_translate_func:
2580	* @context: a #GOptionContext
2581	* @func: (nullable): the #GTranslateFunc, or %NULL
2582	* @data: (nullable): user data to pass to @func, or %NULL
2583	* @destroy_notify: (nullable): a function which gets called to free @data, or %NULL
2584	*
2585	* Sets the function which is used to translate the contexts
2586	* user-visible strings, for `--help` output. If @func is %NULL,
2587	* strings are not translated.
2588	*
2589	* Note that option groups have their own translation functions,
2590	* this function only affects the @parameter_string (see g_option_context_new()),
2591	* the summary (see g_option_context_set_summary()) and the description
2592	* (see g_option_context_set_description()).
2593	*
2594	* If you are using gettext(), you only need to set the translation
2595	* domain, see g_option_context_set_translation_domain().
2596	*
2597	* Since: 2.12
2598	**/
2599	void
2600	g_option_context_set_translate_func (GOptionContext *context,
2601	GTranslateFunc func,
2602	gpointer data,
2603	GDestroyNotify destroy_notify)
2604	{
2605	g_return_if_fail (context != NULL);
2606
2607	if (context->translate_notify)
2608	context->translate_notify (context->translate_data);
2609
2610	context->translate_func = func;
2611	context->translate_data = data;
2612	context->translate_notify = destroy_notify;
2613	}
2614
2615	/**
2616	* g_option_context_set_translation_domain:
2617	* @context: a #GOptionContext
2618	* @domain: the domain to use
2619	*
2620	* A convenience function to use gettext() for translating
2621	* user-visible strings.
2622	*
2623	* Since: 2.12
2624	**/
2625	void
2626	g_option_context_set_translation_domain (GOptionContext *context,
2627	const gchar *domain)
2628	{
2629	g_return_if_fail (context != NULL);
2630
2631	g_option_context_set_translate_func (context,
2632	func: (GTranslateFunc)dgettext_swapped,
2633	data: g_strdup (str: domain),
2634	destroy_notify: g_free);
2635	}
2636
2637	/**
2638	* g_option_context_set_summary:
2639	* @context: a #GOptionContext
2640	* @summary: (nullable): a string to be shown in `--help` output
2641	* before the list of options, or %NULL
2642	*
2643	* Adds a string to be displayed in `--help` output before the list
2644	* of options. This is typically a summary of the program functionality.
2645	*
2646	* Note that the summary is translated (see
2647	* g_option_context_set_translate_func() and
2648	* g_option_context_set_translation_domain()).
2649	*
2650	* Since: 2.12
2651	*/
2652	void
2653	g_option_context_set_summary (GOptionContext *context,
2654	const gchar *summary)
2655	{
2656	g_return_if_fail (context != NULL);
2657
2658	g_free (mem: context->summary);
2659	context->summary = g_strdup (str: summary);
2660	}
2661
2662
2663	/**
2664	* g_option_context_get_summary:
2665	* @context: a #GOptionContext
2666	*
2667	* Returns the summary. See g_option_context_set_summary().
2668	*
2669	* Returns: the summary
2670	*
2671	* Since: 2.12
2672	*/
2673	const gchar *
2674	g_option_context_get_summary (GOptionContext *context)
2675	{
2676	g_return_val_if_fail (context != NULL, NULL);
2677
2678	return context->summary;
2679	}
2680
2681	/**
2682	* g_option_context_set_description:
2683	* @context: a #GOptionContext
2684	* @description: (nullable): a string to be shown in `--help` output
2685	* after the list of options, or %NULL
2686	*
2687	* Adds a string to be displayed in `--help` output after the list
2688	* of options. This text often includes a bug reporting address.
2689	*
2690	* Note that the summary is translated (see
2691	* g_option_context_set_translate_func()).
2692	*
2693	* Since: 2.12
2694	*/
2695	void
2696	g_option_context_set_description (GOptionContext *context,
2697	const gchar *description)
2698	{
2699	g_return_if_fail (context != NULL);
2700
2701	g_free (mem: context->description);
2702	context->description = g_strdup (str: description);
2703	}
2704
2705
2706	/**
2707	* g_option_context_get_description:
2708	* @context: a #GOptionContext
2709	*
2710	* Returns the description. See g_option_context_set_description().
2711	*
2712	* Returns: the description
2713	*
2714	* Since: 2.12
2715	*/
2716	const gchar *
2717	g_option_context_get_description (GOptionContext *context)
2718	{
2719	g_return_val_if_fail (context != NULL, NULL);
2720
2721	return context->description;
2722	}
2723
2724	/**
2725	* g_option_context_parse_strv:
2726	* @context: a #GOptionContext
2727	* @arguments: (inout) (array null-terminated=1) (optional): a pointer
2728	* to the command line arguments (which must be in UTF-8 on Windows).
2729	* Starting with GLib 2.62, @arguments can be %NULL, which matches
2730	* g_option_context_parse().
2731	* @error: a return location for errors
2732	*
2733	* Parses the command line arguments.
2734	*
2735	* This function is similar to g_option_context_parse() except that it
2736	* respects the normal memory rules when dealing with a strv instead of
2737	* assuming that the passed-in array is the argv of the main function.
2738	*
2739	* In particular, strings that are removed from the arguments list will
2740	* be freed using g_free().
2741	*
2742	* On Windows, the strings are expected to be in UTF-8. This is in
2743	* contrast to g_option_context_parse() which expects them to be in the
2744	* system codepage, which is how they are passed as @argv to main().
2745	* See g_win32_get_command_line() for a solution.
2746	*
2747	* This function is useful if you are trying to use #GOptionContext with
2748	* #GApplication.
2749	*
2750	* Returns: %TRUE if the parsing was successful,
2751	* %FALSE if an error occurred
2752	*
2753	* Since: 2.40
2754	**/
2755	gboolean
2756	g_option_context_parse_strv (GOptionContext *context,
2757	gchar ***arguments,
2758	GError **error)
2759	{
2760	gboolean success;
2761	gint argc;
2762
2763	g_return_val_if_fail (context != NULL, FALSE);
2764
2765	context->strv_mode = TRUE;
2766	argc = arguments && *arguments ? g_strv_length (str_array: *arguments) : 0;
2767	success = g_option_context_parse (context, argc: &argc, argv: arguments, error);
2768	context->strv_mode = FALSE;
2769
2770	return success;
2771	}
2772