[bison.git] / lib / argmatch.c

/* argmatch.c -- find a match for a string in an array
   Copyright (C) 1990, 1998, 1999 Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program 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 General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

/* Written by David MacKenzie <djm@ai.mit.edu>
   Modified by Akim Demaille <demaille@inf.enst.fr> */

#include "argmatch.h"

#include <stdio.h>
#ifdef STDC_HEADERS
# include <string.h>
#endif

#if HAVE_LOCALE_H
# include <locale.h>
#endif

#if ENABLE_NLS
# include <libintl.h>
# define _(Text) gettext (Text)
#else
# define _(Text) Text
#endif

#include "error.h"
#include "quotearg.h"

/* When reporting an invalid argument, show nonprinting characters
   by using the quoting style ARGMATCH_QUOTING_STYLE.  Do not use
   literal_quoting_style.  */
#ifndef ARGMATCH_QUOTING_STYLE
# define ARGMATCH_QUOTING_STYLE locale_quoting_style
#endif

/* The following test is to work around the gross typo in
   systems like Sony NEWS-OS Release 4.0C, whereby EXIT_FAILURE
   is defined to 0, not 1.  */
#if !EXIT_FAILURE
# undef EXIT_FAILURE
# define EXIT_FAILURE 1
#endif

/* Non failing version of argmatch call this function after failing. */
#ifndef ARGMATCH_DIE
# define ARGMATCH_DIE exit (EXIT_FAILURE)
#endif

#ifdef ARGMATCH_DIE_DECL
ARGMATCH_DIE_DECL;
#endif

static void
__argmatch_die (void)
{
  ARGMATCH_DIE;
}

/* Used by XARGMATCH and XARGCASEMATCH.  See description in argmatch.h.
   Default to __argmatch_die, but allow caller to change this at run-time. */
argmatch_exit_fn argmatch_die = __argmatch_die;

\f
/* If ARG is an unambiguous match for an element of the
   null-terminated array ARGLIST, return the index in ARGLIST
   of the matched element, else -1 if it does not match any element
   or -2 if it is ambiguous (is a prefix of more than one element).
   If SENSITIVE, comparison is case sensitive.

   If VALLIST is none null, use it to resolve ambiguities limited to
   synonyms, i.e., for
     "yes", "yop" -> 0
     "no", "nope" -> 1
   "y" is a valid argument, for `0', and "n" for `1'.  */

static int
__argmatch_internal (const char *arg, const char *const *arglist,
		     const char *vallist, size_t valsize,
		     int case_sensitive)
{
  int i;			/* Temporary index in ARGLIST.  */
  size_t arglen;		/* Length of ARG.  */
  int matchind = -1;		/* Index of first nonexact match.  */
  int ambiguous = 0;		/* If nonzero, multiple nonexact match(es).  */

  arglen = strlen (arg);

  /* Test all elements for either exact match or abbreviated matches.  */
  for (i = 0; arglist[i]; i++)
    {
      if (case_sensitive
	  ? !strncmp (arglist[i], arg, arglen)
	  : !strncasecmp (arglist[i], arg, arglen))
	{
	  if (strlen (arglist[i]) == arglen)
	    /* Exact match found.  */
	    return i;
	  else if (matchind == -1)
	    /* First nonexact match found.  */
	    matchind = i;
	  else
	    {
	      /* Second nonexact match found.  */
	      if (vallist == NULL
		  || memcmp (vallist + valsize * matchind,
			     vallist + valsize * i, valsize))
		{
		  /* There is a real ambiguity, or we could not
		     disambiguate. */
		  ambiguous = 1;
		}
	    }
	}
    }
  if (ambiguous)
    return -2;
  else
    return matchind;
}

/* argmatch - case sensitive version */
int
argmatch (const char *arg, const char *const *arglist,
	  const char *vallist, size_t valsize)
{
  return __argmatch_internal (arg, arglist, vallist, valsize, 1);
}

/* argcasematch - case insensitive version */
int
argcasematch (const char *arg, const char *const *arglist,
	      const char *vallist, size_t valsize)
{
  return __argmatch_internal (arg, arglist, vallist, valsize, 0);
}

/* Error reporting for argmatch.
   CONTEXT is a description of the type of entity that was being matched.
   VALUE is the invalid value that was given.
   PROBLEM is the return value from argmatch.  */

void
argmatch_invalid (const char *context, const char *value, int problem)
{
  char const *format = (problem == -1
			? _("invalid argument %s for `%s'")
			: _("ambiguous argument %s for `%s'"));

  error (0, 0, format, quotearg_style (ARGMATCH_QUOTING_STYLE, value), context);
}

/* List the valid arguments for argmatch.
   ARGLIST is the same as in argmatch.
   VALLIST is a pointer to an array of values.
   VALSIZE is the size of the elements of VALLIST */
void
argmatch_valid (const char *const *arglist,
		const char *vallist, size_t valsize)
{
  int i;
  const char *last_val = NULL;

  /* We try to put synonyms on the same line.  The assumption is that
     synonyms follow each other */
  fprintf (stderr, _("Valid arguments are:"));
  for (i = 0; arglist[i]; i++)
    if ((i == 0)
	|| memcmp (last_val, vallist + valsize * i, valsize))
      {
	fprintf (stderr, "\n  - `%s'", arglist[i]);
	last_val = vallist + valsize * i;
      }
    else
      {
	fprintf (stderr, ", `%s'", arglist[i]);
      }
  putc ('\n', stderr);
}

/* Never failing versions of the previous functions.

   CONTEXT is the context for which argmatch is called (e.g.,
   "--version-control", or "$VERSION_CONTROL" etc.).  Upon failure,
   calls the (supposed never to return) function EXIT_FN. */

int
__xargmatch_internal (const char *context,
		      const char *arg, const char *const *arglist,
		      const char *vallist, size_t valsize,
		      int case_sensitive,
		      argmatch_exit_fn exit_fn)
{
  int res = __argmatch_internal (arg, arglist,
				 vallist, valsize,
				 case_sensitive);
  if (res >= 0)
    /* Success. */
    return res;

  /* We failed.  Explain why. */
  argmatch_invalid (context, arg, res);
  argmatch_valid (arglist, vallist, valsize);
  (*exit_fn) ();

  return -1; /* To please the compilers. */
}

/* Look for VALUE in VALLIST, an array of objects of size VALSIZE and
   return the first corresponding argument in ARGLIST */
const char *
argmatch_to_argument (const char *value,
		      const char *const *arglist,
		      const char *vallist, size_t valsize)
{
  int i;

  for (i = 0; arglist[i]; i++)
    if (!memcmp (value, vallist + valsize * i, valsize))
      return arglist[i];
  return NULL;
}

#ifdef TEST
/*
 * Based on "getversion.c" by David MacKenzie <djm@gnu.ai.mit.edu>
 */
char *program_name;
extern const char *getenv ();

/* When to make backup files.  */
enum backup_type
{
  /* Never make backups.  */
  none,

  /* Make simple backups of every file.  */
  simple,

  /* Make numbered backups of files that already have numbered backups,
     and simple backups of the others.  */
  numbered_existing,

  /* Make numbered backups of every file.  */
  numbered
};

/* Two tables describing arguments (keys) and their corresponding
   values */
static const char *const backup_args[] =
{
  "no", "none", "off",
  "simple", "never",
  "existing", "nil",
  "numbered", "t",
  0
};

static const enum backup_type backup_vals[] =
{
  none, none, none,
  simple, simple,
  numbered_existing, numbered_existing,
  numbered, numbered
};

int
main (int argc, const char *const *argv)
{
  const char *cp;
  enum backup_type backup_type = none;

  program_name = (char *) argv[0];

  if (argc > 2)
    {
      fprintf (stderr, "Usage: %s [VERSION_CONTROL]\n", program_name);
      exit (1);
    }

  if ((cp = getenv ("VERSION_CONTROL")))
    backup_type = XARGCASEMATCH ("$VERSION_CONTROL", cp,
				 backup_args, backup_vals);

  if (argc == 2)
    backup_type = XARGCASEMATCH (program_name, argv[1],
				 backup_args, backup_vals);

  printf ("The version control is `%s'\n",
	  ARGMATCH_TO_ARGUMENT (backup_type, backup_args, backup_vals));

  return 0;
}
#endif
Commit	Line	Data
54049e5d AD	1	/* argmatch.c -- find a match for a string in an array
	2	Copyright (C) 1990, 1998, 1999 Free Software Foundation, Inc.
	3
	4	This program is free software; you can redistribute it and/or modify
	5	it under the terms of the GNU General Public License as published by
	6	the Free Software Foundation; either version 2, or (at your option)
	7	any later version.
	8
	9	This program is distributed in the hope that it will be useful,
	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	GNU General Public License for more details.
	13
	14	You should have received a copy of the GNU General Public License
	15	along with this program; if not, write to the Free Software Foundation,
	16	Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	17
	18	/* Written by David MacKenzie <djm@ai.mit.edu>
	19	Modified by Akim Demaille <demaille@inf.enst.fr> */
	20
	21	#include "argmatch.h"
	22
	23	#include <stdio.h>
	24	#ifdef STDC_HEADERS
	25	# include <string.h>
	26	#endif
	27
	28	#if HAVE_LOCALE_H
	29	# include <locale.h>
	30	#endif
	31
	32	#if ENABLE_NLS
	33	# include <libintl.h>
	34	# define _(Text) gettext (Text)
	35	#else
	36	# define _(Text) Text
	37	#endif
	38
	39	#include "error.h"
	40	#include "quotearg.h"
	41
	42	/* When reporting an invalid argument, show nonprinting characters
	43	by using the quoting style ARGMATCH_QUOTING_STYLE. Do not use
	44	literal_quoting_style. */
	45	#ifndef ARGMATCH_QUOTING_STYLE
	46	# define ARGMATCH_QUOTING_STYLE locale_quoting_style
	47	#endif
	48
	49	/* The following test is to work around the gross typo in
	50	systems like Sony NEWS-OS Release 4.0C, whereby EXIT_FAILURE
	51	is defined to 0, not 1. */
	52	#if !EXIT_FAILURE
	53	# undef EXIT_FAILURE
	54	# define EXIT_FAILURE 1
	55	#endif
	56
	57	/* Non failing version of argmatch call this function after failing. */
	58	#ifndef ARGMATCH_DIE
	59	# define ARGMATCH_DIE exit (EXIT_FAILURE)
	60	#endif
	61
	62	#ifdef ARGMATCH_DIE_DECL
	63	ARGMATCH_DIE_DECL;
	64	#endif
65
66	static void
67	__argmatch_die (void)
68	{
69	ARGMATCH_DIE;
70	}
71
72	/* Used by XARGMATCH and XARGCASEMATCH. See description in argmatch.h.
73	Default to __argmatch_die, but allow caller to change this at run-time. */
74	argmatch_exit_fn argmatch_die = __argmatch_die;
75
76	\f
77	/* If ARG is an unambiguous match for an element of the
78	null-terminated array ARGLIST, return the index in ARGLIST
79	of the matched element, else -1 if it does not match any element
80	or -2 if it is ambiguous (is a prefix of more than one element).
81	If SENSITIVE, comparison is case sensitive.
82
83	If VALLIST is none null, use it to resolve ambiguities limited to
84	synonyms, i.e., for
85	"yes", "yop" -> 0
86	"no", "nope" -> 1
87	"y" is a valid argument, for `0', and "n" for `1'. */
88
89	static int
90	__argmatch_internal (const char arg, const char const *arglist,
91	const char *vallist, size_t valsize,
92	int case_sensitive)
93	{
94	int i; /* Temporary index in ARGLIST. */
95	size_t arglen; /* Length of ARG. */
96	int matchind = -1; /* Index of first nonexact match. */
97	int ambiguous = 0; /* If nonzero, multiple nonexact match(es). */
98
99	arglen = strlen (arg);
100
101	/* Test all elements for either exact match or abbreviated matches. */
102	for (i = 0; arglist[i]; i++)
103	{
104	if (case_sensitive
105	? !strncmp (arglist[i], arg, arglen)
106	: !strncasecmp (arglist[i], arg, arglen))
107	{
108	if (strlen (arglist[i]) == arglen)
109	/* Exact match found. */
110	return i;
111	else if (matchind == -1)
112	/* First nonexact match found. */
113	matchind = i;
114	else
115	{
116	/* Second nonexact match found. */
117	if (vallist == NULL
118	\|\| memcmp (vallist + valsize * matchind,
119	vallist + valsize * i, valsize))
120	{
121	/* There is a real ambiguity, or we could not
122	disambiguate. */
123	ambiguous = 1;
124	}
125	}
126	}
127	}
128	if (ambiguous)
129	return -2;
130	else
131	return matchind;
132	}
133
134	/* argmatch - case sensitive version */
135	int
136	argmatch (const char arg, const char const *arglist,
137	const char *vallist, size_t valsize)
138	{
139	return __argmatch_internal (arg, arglist, vallist, valsize, 1);
140	}
141
142	/* argcasematch - case insensitive version */
143	int
144	argcasematch (const char arg, const char const *arglist,
145	const char *vallist, size_t valsize)
146	{
147	return __argmatch_internal (arg, arglist, vallist, valsize, 0);
148	}
149
150	/* Error reporting for argmatch.
151	CONTEXT is a description of the type of entity that was being matched.
152	VALUE is the invalid value that was given.
153	PROBLEM is the return value from argmatch. */
154
155	void
156	argmatch_invalid (const char context, const char value, int problem)
157	{
158	char const *format = (problem == -1
159	? _("invalid argument %s for `%s'")
160	: _("ambiguous argument %s for `%s'"));
161
162	error (0, 0, format, quotearg_style (ARGMATCH_QUOTING_STYLE, value), context);
163	}
164
165	/* List the valid arguments for argmatch.
166	ARGLIST is the same as in argmatch.
167	VALLIST is a pointer to an array of values.
168	VALSIZE is the size of the elements of VALLIST */
169	void
170	argmatch_valid (const char const arglist,
171	const char *vallist, size_t valsize)
172	{
173	int i;
174	const char *last_val = NULL;
175
176	/* We try to put synonyms on the same line. The assumption is that
177	synonyms follow each other */
178	fprintf (stderr, _("Valid arguments are:"));
179	for (i = 0; arglist[i]; i++)
180	if ((i == 0)
181	\|\| memcmp (last_val, vallist + valsize * i, valsize))
182	{
183	fprintf (stderr, "\n - `%s'", arglist[i]);
184	last_val = vallist + valsize * i;
185	}
186	else
187	{
188	fprintf (stderr, ", `%s'", arglist[i]);
189	}
190	putc ('\n', stderr);
191	}
192
193	/* Never failing versions of the previous functions.
194
195	CONTEXT is the context for which argmatch is called (e.g.,
196	"--version-control", or "$VERSION_CONTROL" etc.). Upon failure,
197	calls the (supposed never to return) function EXIT_FN. */
198
199	int
200	__xargmatch_internal (const char *context,
201	const char arg, const char const *arglist,
202	const char *vallist, size_t valsize,
203	int case_sensitive,
204	argmatch_exit_fn exit_fn)
205	{
206	int res = __argmatch_internal (arg, arglist,
207	vallist, valsize,
208	case_sensitive);
209	if (res >= 0)
210	/* Success. */
211	return res;
212
213	/* We failed. Explain why. */
214	argmatch_invalid (context, arg, res);
215	argmatch_valid (arglist, vallist, valsize);
216	(*exit_fn) ();
217
218	return -1; /* To please the compilers. */
219	}
220
221	/* Look for VALUE in VALLIST, an array of objects of size VALSIZE and
222	return the first corresponding argument in ARGLIST */
223	const char *
224	argmatch_to_argument (const char *value,
225	const char const arglist,
226	const char *vallist, size_t valsize)
227	{
228	int i;
229
230	for (i = 0; arglist[i]; i++)
231	if (!memcmp (value, vallist + valsize * i, valsize))
232	return arglist[i];
233	return NULL;
234	}
235
236	#ifdef TEST
237	/*
238	* Based on "getversion.c" by David MacKenzie <djm@gnu.ai.mit.edu>
239	*/
240	char *program_name;
241	extern const char *getenv ();
242
243	/* When to make backup files. */
244	enum backup_type
245	{
246	/* Never make backups. */
247	none,
248
249	/* Make simple backups of every file. */
250	simple,
251
252	/* Make numbered backups of files that already have numbered backups,
253	and simple backups of the others. */
254	numbered_existing,
255
256	/* Make numbered backups of every file. */
257	numbered
258	};
259
260	/* Two tables describing arguments (keys) and their corresponding
261	values */
262	static const char *const backup_args[] =
263	{
264	"no", "none", "off",
265	"simple", "never",
266	"existing", "nil",
267	"numbered", "t",
268	0
269	};
270
271	static const enum backup_type backup_vals[] =
272	{
273	none, none, none,
274	simple, simple,
275	numbered_existing, numbered_existing,
276	numbered, numbered
277	};
278
279	int
280	main (int argc, const char const argv)
281	{
282	const char *cp;
283	enum backup_type backup_type = none;
284
285	program_name = (char *) argv[0];
286
287	if (argc > 2)
288	{
289	fprintf (stderr, "Usage: %s [VERSION_CONTROL]\n", program_name);
290	exit (1);
291	}
292
293	if ((cp = getenv ("VERSION_CONTROL")))
294	backup_type = XARGCASEMATCH ("$VERSION_CONTROL", cp,
295	backup_args, backup_vals);
296
297	if (argc == 2)
298	backup_type = XARGCASEMATCH (program_name, argv[1],
299	backup_args, backup_vals);
300
301	printf ("The version control is `%s'\n",
302	ARGMATCH_TO_ARGUMENT (backup_type, backup_args, backup_vals));
303
304	return 0;
305	}
306	#endif