/* goption.c - Option parser

 *

 *  Copyright (C) 1999, 2003 Red Hat Software

 *  Copyright (C) 2004       Anders Carlsson <andersca@gnome.org>

 * Portions copyright (c) 2006 Nokia Corporation.  All rights reserved.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#include "config.h"

#include "goption.h"

#include "glib.h"

#include "glibintl.h"

#include "galias.h"

#include <string.h>

#include <stdlib.h>

#include <errno.h>

#ifdef __SYMBIAN32__

#include <glib_wsd.h>

#endif

#define TRANSLATE(group, str) (((group)->translate_func ? (* (group)->translate_func) ((str), (group)->translate_data) : (str)))

#define NO_ARG(entry) ((entry)->arg == G_OPTION_ARG_NONE ||       \

                       ((entry)->arg == G_OPTION_ARG_CALLBACK &&  \

                        ((entry)->flags & G_OPTION_FLAG_NO_ARG)))

#define OPTIONAL_ARG(entry) ((entry)->arg == G_OPTION_ARG_CALLBACK &&  \

                       (entry)->flags & G_OPTION_FLAG_OPTIONAL_ARG)

typedef struct 

{

  GOptionArg arg_type;

  gpointer arg_data;  

  union 

  {

    gboolean bool;

    gint integer;

    gchar *str;

    gchar **array;

  } prev;

  union 

  {

    gchar *str;

    struct 

    {

      gint len;

      gchar **data;

    } array;

  } allocated;

} Change;

typedef struct

{

  gchar **ptr;

  gchar *value;

} PendingNull;

struct _GOptionContext

{

  GList *groups;

  gchar *parameter_string;

  gboolean help_enabled;

  gboolean ignore_unknown;

  GOptionGroup *main_group;

  /* We keep a list of change so we can revert them */

  GList *changes;

  /* We also keep track of all argv elements that should be NULLed or

   * modified.

   */

  GList *pending_nulls;

};

struct _GOptionGroup

{

  gchar *name;

  gchar *description;

  gchar *help_description;

  GDestroyNotify  destroy_notify;

  gpointer        user_data;

  GTranslateFunc  translate_func;

  GDestroyNotify  translate_notify;

  gpointer	  translate_data;

  GOptionEntry *entries;

  gint         n_entries;

  GOptionParseFunc pre_parse_func;

  GOptionParseFunc post_parse_func;

  GOptionErrorFunc error_func;

};

static void free_changes_list (GOptionContext *context,

			       gboolean        revert);

static void free_pending_nulls (GOptionContext *context,

				gboolean        perform_nulls);

#if EMULATOR

PLS(q,g_option_error_quark,GQuark)

#define q (*FUNCTION_NAME(q,g_option_error_quark)())

#endif /* EMULATOR */

EXPORT_C GQuark

g_option_error_quark (void)

{

  #if !(EMULATOR)

  static GQuark q = 0;

  #endif /* EMULATOR */

  if (q == 0)

    q = g_quark_from_static_string ("g-option-context-error-quark");

  return q;

}

#if EMULATOR

#undef q

#endif /* EMULATOR */

/**

 * g_option_context_new:

 * @parameter_string: a string which is displayed in

 *    the first line of <option>--help</option> output, after the 

 *    usage summary 

 *    <literal><replaceable>programname</replaceable> [OPTION...]</literal>.

 *

 * Creates a new option context. 

 *

 * The @parameter_text can serve multiple purposes. It can be used

 * to add descriptions for "rest" arguments, which are not parsed by 

 * the #GOptionContext, typically something like "FILES" or 

 * "FILE1 FILE2...". (If you are using #G_OPTION_REMAINING for 

 * collecting "rest" arguments, GLib handles this automatically by 

 * using the @arg_description of the corresponding #GOptionEntry in 

 * the usage summary.)

 *

 * Another common usage is to give a summary of the program

 * functionality. This can be a short summary on the same line, 

 * like " - frob the strings", or a longer description in a paragraph 

 * below the usage summary. In this case, @parameter_string should start 

 * with two newlines, to separate the description from the usage summary:

 * "\n\nA program to frob strings, which will..."

 *

 * Returns: a newly created #GOptionContext, which must be

 *    freed with g_option_context_free() after use.

 *

 * Since: 2.6

 */

EXPORT_C GOptionContext *

g_option_context_new (const gchar *parameter_string)

{

  GOptionContext *context;

  context = g_new0 (GOptionContext, 1);

  context->parameter_string = g_strdup (parameter_string);

  context->help_enabled = TRUE;

  context->ignore_unknown = FALSE;

  return context;

}

/**

 * g_option_context_free:

 * @context: a #GOptionContext 

 *

 * Frees context and all the groups which have been 

 * added to it.

 *

 * Since: 2.6

 */

EXPORT_C void g_option_context_free (GOptionContext *context) 

{

  g_return_if_fail (context != NULL);

  g_list_foreach (context->groups, (GFunc)g_option_group_free, NULL);

  g_list_free (context->groups);

  if (context->main_group) 

    g_option_group_free (context->main_group);

  free_changes_list (context, FALSE);

  free_pending_nulls (context, FALSE);

  g_free (context->parameter_string);

  g_free (context);

}

/**

 * g_option_context_set_help_enabled:

 * @context: a #GOptionContext

 * @help_enabled: %TRUE to enable <option>--help</option>, %FALSE to disable it

 *

 * Enables or disables automatic generation of <option>--help</option> 

 * output. By default, g_option_context_parse() recognizes

 * <option>--help</option>, <option>-?</option>, <option>--help-all</option>

 * and <option>--help-</option><replaceable>groupname</replaceable> and creates

 * suitable output to stdout. 

 *

 * Since: 2.6

 */

EXPORT_C void g_option_context_set_help_enabled (GOptionContext *context,

                                        gboolean        help_enabled)

{

  g_return_if_fail (context != NULL);

  context->help_enabled = help_enabled;

}

/**

 * g_option_context_get_help_enabled:

 * @context: a #GOptionContext

 * 

 * Returns whether automatic <option>--help</option> generation

 * is turned on for @context. See g_option_context_set_help_enabled().

 * 

 * Returns: %TRUE if automatic help generation is turned on.

 *

 * Since: 2.6

 */

EXPORT_C gboolean 

g_option_context_get_help_enabled (GOptionContext *context) 

{

  g_return_val_if_fail (context != NULL, FALSE);

  return context->help_enabled;

}

/**

 * g_option_context_set_ignore_unknown_options:

 * @context: a #GOptionContext

 * @ignore_unknown: %TRUE to ignore unknown options, %FALSE to produce

 *    an error when unknown options are met

 * 

 * Sets whether to ignore unknown options or not. If an argument is 

 * ignored, it is left in the @argv array after parsing. By default, 

 * g_option_context_parse() treats unknown options as error.

 * 

 * This setting does not affect non-option arguments (i.e. arguments 

 * which don't start with a dash). But note that GOption cannot reliably

 * determine whether a non-option belongs to a preceding unknown option.

 *

 * Since: 2.6

 **/

EXPORT_C void

g_option_context_set_ignore_unknown_options (GOptionContext *context,

					     gboolean	     ignore_unknown)

{

  g_return_if_fail (context != NULL);

  context->ignore_unknown = ignore_unknown;

}

/**

 * g_option_context_get_ignore_unknown_options:

 * @context: a #GOptionContext

 * 

 * Returns whether unknown options are ignored or not. See

 * g_option_context_set_ignore_unknown_options().

 * 

 * Returns: %TRUE if unknown options are ignored.

 * 

 * Since: 2.6

 **/

EXPORT_C gboolean

g_option_context_get_ignore_unknown_options (GOptionContext *context)

{

  g_return_val_if_fail (context != NULL, FALSE);

  return context->ignore_unknown;

}

/**

 * g_option_context_add_group:

 * @context: a #GOptionContext

 * @group: the group to add

 * 

 * Adds a #GOptionGroup to the @context, so that parsing with @context

 * will recognize the options in the group. Note that the group will

 * be freed together with the context when g_option_context_free() is

 * called, so you must not free the group yourself after adding it

 * to a context.

 *

 * Since: 2.6

 **/

EXPORT_C void

g_option_context_add_group (GOptionContext *context,

			    GOptionGroup   *group)

{

  GList *list;

  g_return_if_fail (context != NULL);

  g_return_if_fail (group != NULL);

  g_return_if_fail (group->name != NULL);

  g_return_if_fail (group->description != NULL);

  g_return_if_fail (group->help_description != NULL);

  for (list = context->groups; list; list = list->next)

    {

      GOptionGroup *g = (GOptionGroup *)list->data;

      if ((group->name == NULL && g->name == NULL) ||

	  (group->name && g->name && strcmp (group->name, g->name) == 0))

	g_warning ("A group named \"%s\" is already part of this GOptionContext", 

		   group->name);

    }

  context->groups = g_list_append (context->groups, group);

}

/**

 * g_option_context_set_main_group:

 * @context: a #GOptionContext

 * @group: the group to set as main group

 * 

 * Sets a #GOptionGroup as main group of the @context. 

 * This has the same effect as calling g_option_context_add_group(), 

 * the only difference is that the options in the main group are 

 * treated differently when generating <option>--help</option> output.

 *

 * Since: 2.6

 **/

EXPORT_C void

g_option_context_set_main_group (GOptionContext *context,

				 GOptionGroup   *group)

{

  g_return_if_fail (context != NULL);

  g_return_if_fail (group != NULL);

  if (context->main_group)

    {

      g_warning ("This GOptionContext already has a main group");

      return;

    }

  context->main_group = group;

}

/**

 * g_option_context_get_main_group:

 * @context: a #GOptionContext

 * 

 * Returns a pointer to the main group of @context.

 * 

 * Return value: the main group of @context, or %NULL if @context doesn't

 *  have a main group. Note that group belongs to @context and should

 *  not be modified or freed.

 *

 * Since: 2.6

 **/

EXPORT_C GOptionGroup *

g_option_context_get_main_group (GOptionContext *context)

{

  g_return_val_if_fail (context != NULL, NULL);

  return context->main_group;

}

/**

 * g_option_context_add_main_entries:

 * @context: a #GOptionContext

 * @entries: a %NULL-terminated array of #GOptionEntry<!-- -->s

 * @translation_domain: a translation domain to use for translating

 *    the <option>--help</option> output for the options in @entries

 *    with gettext(), or %NULL

 * 

 * A convenience function which creates a main group if it doesn't 

 * exist, adds the @entries to it and sets the translation domain.

 * 

 * Since: 2.6

 **/

EXPORT_C void

g_option_context_add_main_entries (GOptionContext      *context,

				   const GOptionEntry  *entries,

				   const gchar         *translation_domain)

{

  g_return_if_fail (entries != NULL);

  if (!context->main_group)

    context->main_group = g_option_group_new (NULL, NULL, NULL, NULL, NULL);

  g_option_group_add_entries (context->main_group, entries);

  g_option_group_set_translation_domain (context->main_group, translation_domain);

}

static gint

calculate_max_length (GOptionGroup *group)

{

  GOptionEntry *entry;

  gint i, len, max_length;

  max_length = 0;

  for (i = 0; i < group->n_entries; i++)

    {

      entry = &group->entries[i];

      if (entry->flags & G_OPTION_FLAG_HIDDEN)

	continue;

      len = g_utf8_strlen (entry->long_name, -1);

      if (entry->short_name)

	len += 4;

      if (!NO_ARG (entry) && entry->arg_description)

	len += 1 + g_utf8_strlen (TRANSLATE (group, entry->arg_description), -1);

      max_length = MAX (max_length, len);

    }

  return max_length;

}

static void

print_entry (GOptionGroup       *group,

	     gint                max_length,

	     const GOptionEntry *entry)

{

  GString *str;

  if (entry->flags & G_OPTION_FLAG_HIDDEN)

    return;

  if (entry->long_name[0] == 0)

    return;

  str = g_string_new (NULL);

  if (entry->short_name)

    g_string_append_printf (str, "  -%c, --%s", entry->short_name, entry->long_name);

  else

    g_string_append_printf (str, "  --%s", entry->long_name);

  if (entry->arg_description)

    g_string_append_printf (str, "=%s", TRANSLATE (group, entry->arg_description));

  g_print ("%-*s %s\n", max_length + 4, str->str,

	   entry->description ? TRANSLATE (group, entry->description) : "");

  g_string_free (str, TRUE);  

}

static void

print_help (GOptionContext *context,

	    gboolean        main_help,

	    GOptionGroup   *group) 

{

  GList *list;

  gint max_length, len;

  gint i;

  GOptionEntry *entry;

  GHashTable *shadow_map;

  gboolean seen[256];

  const gchar *rest_description;

  rest_description = NULL;

  if (context->main_group)

    {

      for (i = 0; i < context->main_group->n_entries; i++)

	{

	  entry = &context->main_group->entries[i];

	  if (entry->long_name[0] == 0)

	    {

	      rest_description = entry->arg_description;

	      break;

	    }

	}

    }

  g_print ("%s\n  %s %s%s%s%s%s\n\n", 

	   _("Usage:"), g_get_prgname(), _("[OPTION...]"),

	   rest_description ? " " : "",

	   rest_description ? rest_description : "",

	   context->parameter_string ? " " : "",

	   context->parameter_string ? context->parameter_string : "");

  memset (seen, 0, sizeof (gboolean) * 256);

  shadow_map = g_hash_table_new (g_str_hash, g_str_equal);

  if (context->main_group)

    {

      for (i = 0; i < context->main_group->n_entries; i++)

	{

	  entry = &context->main_group->entries[i];

	  g_hash_table_insert (shadow_map, 

			       (gpointer)entry->long_name, 

			       entry);

	  if (seen[(guchar)entry->short_name])

	    entry->short_name = 0;

	  else

	    seen[(guchar)entry->short_name] = TRUE;

	}

    }

  list = context->groups;

  while (list != NULL)

    {