/* goption.c - Option parser

 *

 *  Copyright (C) 1999, 2003 Red Hat Software

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

 * Portions copyright (c) 2006-2009 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 "gprintf.h"

#include "galias.h"

#include <string.h>

#include <stdlib.h>

#include <stdio.h>

#include <errno.h>

#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;

    gdouble dbl;

    gint64 int64;

  } 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;

  gchar           *summary;

  gchar           *description;

  GTranslateFunc   translate_func;

  GDestroyNotify   translate_notify;

  gpointer	   translate_data;

  guint            help_enabled   : 1;

  guint            ignore_unknown : 1;

  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);

static int

_g_unichar_get_width (gunichar c)

{

  if (G_UNLIKELY (g_unichar_iszerowidth (c)))

    return 0;

  /* we ignore the fact that we should call g_unichar_iswide_cjk() under

   * some locales (legacy East Asian ones) */

  if (g_unichar_iswide (c))

    return 2;

  return 1;

}

static glong

_g_utf8_strwidth (const gchar *p,

                  gssize       max)

{

  glong len = 0;

  const gchar *start = p;

  g_return_val_if_fail (p != NULL || max == 0, 0);

  if (max < 0)

    {

      while (*p)

        {

          len += _g_unichar_get_width (g_utf8_get_char (p));

          p = g_utf8_next_char (p);

        }

    }

  else

    {

      if (max == 0 || !*p)

        return 0;

      /* this case may not be quite correct */

      len += _g_unichar_get_width (g_utf8_get_char (p));

      p = g_utf8_next_char (p);          

      while (p - start < max && *p)

        {

          len += _g_unichar_get_width (g_utf8_get_char (p));

          p = g_utf8_next_char (p);          

        }

    }

  return len;

}

EXPORT_C GQuark

g_option_error_quark (void)

{

  return g_quark_from_static_string ("g-option-context-error-quark");

}

/**

 * 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_string 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 usage is to give a short summary of the program

 * functionality, like " - frob the strings", which will be displayed

 * in the same line as the usage. For a longer description of the

 * program functionality that should be displayed as a paragraph

 * below the usage line, use g_option_context_set_summary().

 *

 * Note that the @parameter_string is translated using the

 * function set with g_option_context_set_translate_func(), so

 * it should normally be passed untranslated.

 *

 * 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->summary);

  g_free (context->description);

  if (context->translate_notify)

    (* context->translate_notify) (context->translate_data);

  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_strwidth (entry->long_name, -1);

      if (entry->short_name)

	len += 4;

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

	len += 1 + _g_utf8_strwidth (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            *string)

{

  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_string_append_printf (string, "%s%*s %s\n", str->str,

	                  (int) (max_length + 4 - _g_utf8_strwidth (str->str, -1)), "",

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

  g_string_free (str, TRUE);  

}

static gboolean

group_has_visible_entries (GOptionContext *context,

                           GOptionGroup *group,

                           gboolean      main_entries)

{

  GOptionFlags reject_filter = G_OPTION_FLAG_HIDDEN;