[thirdparty/cups.git] / cups / options.c

/*
 * "$Id: options.c 8181 2008-12-10 17:29:57Z mike $"
 *
 *   Option routines for CUPS.
 *
 *   Copyright 2007-2010 by Apple Inc.
 *   Copyright 1997-2007 by Easy Software Products.
 *
 *   These coded instructions, statements, and computer programs are the
 *   property of Apple Inc. and are protected by Federal copyright
 *   law.  Distribution and use rights are outlined in the file "LICENSE.txt"
 *   which should have been included with this file.  If this file is
 *   file is missing or damaged, see the license at "http://www.cups.org/".
 *
 *   This file is subject to the Apple OS-Developed Software exception.
 *
 * Contents:
 *
 *   cupsAddOption()        - Add an option to an option array.
 *   cupsFreeOptions()      - Free all memory used by options.
 *   cupsGetOption()        - Get an option value.
 *   cupsParseOptions()     - Parse options from a command-line argument.
 *   cupsRemoveOption()     - Remove an option from an option array.
 *   _cupsGet1284Values()   - Get 1284 device ID keys and values.
 *   cups_compare_options() - Compare two options.
 *   cups_find_option()     - Find an option using a binary search.
 */

/*
 * Include necessary headers...
 */

#include "cups.h"
#include <stdlib.h>
#include <ctype.h>
#include "string.h"
#include "debug.h"


/*
 * Local functions...
 */

static int	cups_compare_options(cups_option_t *a, cups_option_t *b);
static int	cups_find_option(const char *name, int num_options,
	                         cups_option_t *option, int prev, int *rdiff);


/*
 * 'cupsAddOption()' - Add an option to an option array.
 *
 * New option arrays can be initialized simply by passing 0 for the
 * "num_options" parameter.
 */

int					/* O  - Number of options */
cupsAddOption(const char    *name,	/* I  - Name of option */
              const char    *value,	/* I  - Value of option */
	      int           num_options,/* I  - Number of options */
              cups_option_t **options)	/* IO - Pointer to options */
{
  cups_option_t	*temp;			/* Pointer to new option */
  int		insert,			/* Insertion point */
		diff;			/* Result of search */


  DEBUG_printf(("2cupsAddOption(name=\"%s\", value=\"%s\", num_options=%d, "
                "options=%p)", name, value, num_options, options));
 
  if (!name || !name[0] || !value || !options || num_options < 0)
  {
    DEBUG_printf(("3cupsAddOption: Returning %d", num_options));
    return (num_options);
  }

 /*
  * Look for an existing option with the same name...
  */

  if (num_options == 0)
  {
    insert = 0;
    diff   = 1;
  }
  else
  {
    insert = cups_find_option(name, num_options, *options, num_options - 1,
                              &diff);

    if (diff > 0)
      insert ++;
  }

  if (diff)
  {
   /*
    * No matching option name...
    */

    DEBUG_printf(("4cupsAddOption: New option inserted at index %d...",
                  insert));

    if (num_options == 0)
      temp = (cups_option_t *)malloc(sizeof(cups_option_t));
    else
      temp = (cups_option_t *)realloc(*options, sizeof(cups_option_t) *
                                        	(num_options + 1));

    if (temp == NULL)
    {
      DEBUG_puts("3cupsAddOption: Unable to expand option array, returning 0");
      return (0);
    }

    *options = temp;

    if (insert < num_options)
    {
      DEBUG_printf(("4cupsAddOption: Shifting %d options...",
                    (int)(num_options - insert)));
      memmove(temp + insert + 1, temp + insert,
	      (num_options - insert) * sizeof(cups_option_t));
    }

    temp        += insert;
    temp->name  = _cupsStrAlloc(name);
    num_options ++;
  }
  else
  {
   /*
    * Match found; free the old value...
    */

    DEBUG_printf(("4cupsAddOption: Option already exists at index %d...",
                  insert));

    temp = *options + insert;
    _cupsStrFree(temp->value);
  }

  temp->value = _cupsStrAlloc(value);

  DEBUG_printf(("3cupsAddOption: Returning %d", num_options));

  return (num_options);
}


/*
 * 'cupsFreeOptions()' - Free all memory used by options.
 */

void
cupsFreeOptions(
    int           num_options,		/* I - Number of options */
    cups_option_t *options)		/* I - Pointer to options */
{
  int	i;				/* Looping var */


  DEBUG_printf(("cupsFreeOptions(num_options=%d, options=%p)", num_options,
                options));

  if (num_options <= 0 || !options)
    return;

  for (i = 0; i < num_options; i ++)
  {
    _cupsStrFree(options[i].name);
    _cupsStrFree(options[i].value);
  }

  free(options);
}


/*
 * 'cupsGetOption()' - Get an option value.
 */

const char *				/* O - Option value or @code NULL@ */
cupsGetOption(const char    *name,	/* I - Name of option */
              int           num_options,/* I - Number of options */
              cups_option_t *options)	/* I - Options */
{
  int	diff,				/* Result of comparison */
	match;				/* Matching index */


  DEBUG_printf(("2cupsGetOption(name=\"%s\", num_options=%d, options=%p)",
                name, num_options, options));

  if (!name || num_options <= 0 || !options)
  {
    DEBUG_puts("3cupsGetOption: Returning NULL");
    return (NULL);
  }

  match = cups_find_option(name, num_options, options, -1, &diff);

  if (!diff)
  {
    DEBUG_printf(("3cupsGetOption: Returning \"%s\"", options[match].value));
    return (options[match].value);
  }

  DEBUG_puts("3cupsGetOption: Returning NULL");
  return (NULL);
}


/*
 * 'cupsParseOptions()' - Parse options from a command-line argument.
 *
 * This function converts space-delimited name/value pairs according
 * to the PAPI text option ABNF specification. Collection values
 * ("name={a=... b=... c=...}") are stored with the curley brackets
 * intact - use @code cupsParseOptions@ on the value to extract the
 * collection attributes.
 */

int					/* O - Number of options found */
cupsParseOptions(
    const char    *arg,			/* I - Argument to parse */
    int           num_options,		/* I - Number of options */
    cups_option_t **options)		/* O - Options found */
{
  char	*copyarg,			/* Copy of input string */
	*ptr,				/* Pointer into string */
	*name,				/* Pointer to name */
	*value,				/* Pointer to value */
	sep,				/* Separator character */
	quote;				/* Quote character */


  DEBUG_printf(("cupsParseOptions(arg=\"%s\", num_options=%d, options=%p)",
                arg, num_options, options));

 /*
  * Range check input...
  */

  if (!arg)
  {
    DEBUG_printf(("1cupsParseOptions: Returning %d", num_options));
    return (num_options);
  }

  if (!options || num_options < 0)
  {
    DEBUG_puts("1cupsParseOptions: Returning 0");
    return (0);
  }

 /*
  * Make a copy of the argument string and then divide it up...
  */

  if ((copyarg = strdup(arg)) == NULL)
  {
    DEBUG_puts("1cupsParseOptions: Unable to copy arg string");
    DEBUG_printf(("1cupsParseOptions: Returning %d", num_options));
    return (num_options);
  }

  if (*copyarg == '{')
  {
   /*
    * Remove surrounding {} so we can parse "{name=value ... name=value}"...
    */

    if ((ptr = copyarg + strlen(copyarg) - 1) > copyarg && *ptr == '}')
    {
      *ptr = '\0';
      ptr  = copyarg + 1;
    }
    else
      ptr = copyarg;
  }
  else
    ptr = copyarg;

 /*
  * Skip leading spaces...
  */

  while (isspace(*ptr & 255))
    ptr ++;

 /*
  * Loop through the string...
  */

  while (*ptr != '\0')
  {
   /*
    * Get the name up to a SPACE, =, or end-of-string...
    */

    name = ptr;
    while (!isspace(*ptr & 255) && *ptr != '=' && *ptr)
      ptr ++;

   /*
    * Avoid an empty name...
    */

    if (ptr == name)
      break;

   /*
    * Skip trailing spaces...
    */

    while (isspace(*ptr & 255))
      *ptr++ = '\0';

    if ((sep = *ptr) == '=')
      *ptr++ = '\0';

    DEBUG_printf(("2cupsParseOptions: name=\"%s\"", name));

    if (sep != '=')
    {
     /*
      * Boolean option...
      */

      if (!strncasecmp(name, "no", 2))
        num_options = cupsAddOption(name + 2, "false", num_options,
	                            options);
      else
        num_options = cupsAddOption(name, "true", num_options, options);

      continue;
    }

   /*
    * Remove = and parse the value...
    */

    value = ptr;

    while (*ptr && !isspace(*ptr & 255))
    {
      if (*ptr == ',')
        ptr ++;
      else if (*ptr == '\'' || *ptr == '\"')
      {
       /*
	* Quoted string constant...
	*/

	quote = *ptr;
	_cups_strcpy(ptr, ptr + 1);

	while (*ptr != quote && *ptr)
	{
	  if (*ptr == '\\' && ptr[1])
	    _cups_strcpy(ptr, ptr + 1);

	  ptr ++;
	}

	if (*ptr)
	  _cups_strcpy(ptr, ptr + 1);
      }
      else if (*ptr == '{')
      {
       /*
	* Collection value...
	*/

	int depth;

	for (depth = 0; *ptr; ptr ++)
	{
	  if (*ptr == '{')
	    depth ++;
	  else if (*ptr == '}')
	  {
	    depth --;
	    if (!depth)
	    {
	      ptr ++;
	      break;
	    }
	  }
	  else if (*ptr == '\\' && ptr[1])
	    _cups_strcpy(ptr, ptr + 1);
	}
      }
      else
      {
       /*
	* Normal space-delimited string...
	*/

	while (!isspace(*ptr & 255) && *ptr)
	{
	  if (*ptr == '\\' && ptr[1])
	    _cups_strcpy(ptr, ptr + 1);

	  ptr ++;
	}
      }
    }

    if (*ptr != '\0')
      *ptr++ = '\0';

    DEBUG_printf(("2cupsParseOptions: value=\"%s\"", value));

   /*
    * Skip trailing whitespace...
    */

    while (isspace(*ptr & 255))
      ptr ++;

   /*
    * Add the string value...
    */

    num_options = cupsAddOption(name, value, num_options, options);
  }

 /*
  * Free the copy of the argument we made and return the number of options
  * found.
  */

  free(copyarg);

  DEBUG_printf(("1cupsParseOptions: Returning %d", num_options));

  return (num_options);
}


/*
 * 'cupsRemoveOption()' - Remove an option from an option array.
 *
 * @since CUPS 1.2/Mac OS X 10.5@
 */

int					/* O  - New number of options */
cupsRemoveOption(
    const char    *name,		/* I  - Option name */
    int           num_options,		/* I  - Current number of options */
    cups_option_t **options)		/* IO - Options */
{
  int		i;			/* Looping var */
  cups_option_t	*option;		/* Current option */


  DEBUG_printf(("2cupsRemoveOption(name=\"%s\", num_options=%d, options=%p)",
                name, num_options, options));

 /*
  * Range check input...
  */

  if (!name || num_options < 1 || !options)
  {
    DEBUG_printf(("3cupsRemoveOption: Returning %d", num_options));
    return (num_options);
  }

 /*
  * Loop for the option...
  */

  for (i = num_options, option = *options; i > 0; i --, option ++)
    if (!strcasecmp(name, option->name))
      break;

  if (i)
  {
   /*
    * Remove this option from the array...
    */

    DEBUG_puts("4cupsRemoveOption: Found option, removing it...");

    num_options --;
    i --;

    _cupsStrFree(option->name);
    _cupsStrFree(option->value);

    if (i > 0)
      memmove(option, option + 1, i * sizeof(cups_option_t));
  }

 /*
  * Return the new number of options...
  */

  DEBUG_printf(("3cupsRemoveOption: Returning %d", num_options));
  return (num_options);
}


/*
 * '_cupsGet1284Values()' - Get 1284 device ID keys and values.
 *
 * The returned dictionary is a CUPS option array that can be queried with
 * cupsGetOption and freed with cupsFreeOptions.
 */

int					/* O - Number of key/value pairs */
_cupsGet1284Values(
    const char *device_id,		/* I - IEEE-1284 device ID string */
    cups_option_t **values)		/* O - Array of key/value pairs */
{
  int		num_values;		/* Number of values */
  char		key[256],		/* Key string */
		value[256],		/* Value string */
		*ptr;			/* Pointer into key/value */


 /*
  * Range check input...
  */

  if (values)
    *values = NULL;

  if (!device_id || !values)
    return (0);

 /*
  * Parse the 1284 device ID value into keys and values.  The format is
  * repeating sequences of:
  *
  *   [whitespace]key:value[whitespace];
  */

  num_values = 0;
  while (*device_id)
  {
    while (isspace(*device_id & 255))
      device_id ++;

    if (!*device_id)
      break;

    for (ptr = key; *device_id && *device_id != ':'; device_id ++)
      if (ptr < (key + sizeof(key) - 1))
        *ptr++ = *device_id;

    if (!*device_id)
      break;

    while (ptr > key && isspace(ptr[-1] & 255))
      ptr --;

    *ptr = '\0';
    device_id ++;

    while (isspace(*device_id & 255))
      device_id ++;

    if (!*device_id)
      break;

    for (ptr = value; *device_id && *device_id != ';'; device_id ++)
      if (ptr < (value + sizeof(value) - 1))
        *ptr++ = *device_id;

    if (!*device_id)
      break;

    while (ptr > value && isspace(ptr[-1] & 255))
      ptr --;

    *ptr = '\0';
    device_id ++;

    num_values = cupsAddOption(key, value, num_values, values);
  }

  return (num_values);
}


/*
 * 'cups_compare_options()' - Compare two options.
 */

static int				/* O - Result of comparison */
cups_compare_options(cups_option_t *a,	/* I - First option */
		     cups_option_t *b)	/* I - Second option */
{
  return (strcasecmp(a->name, b->name));
}


/*
 * 'cups_find_option()' - Find an option using a binary search.
 */

static int				/* O - Index of match */
cups_find_option(
    const char    *name,		/* I - Option name */
    int           num_options,		/* I - Number of options */
    cups_option_t *options,		/* I - Options */
    int           prev,			/* I - Previous index */
    int           *rdiff)		/* O - Difference of match */
{
  int		left,			/* Low mark for binary search */
		right,			/* High mark for binary search */
		current,		/* Current index */
		diff;			/* Result of comparison */
  cups_option_t	key;			/* Search key */


  DEBUG_printf(("7cups_find_option(name=\"%s\", num_options=%d, options=%p, "
	        "prev=%d, rdiff=%p)", name, num_options, options, prev,
		rdiff));

#ifdef DEBUG
  for (left = 0; left < num_options; left ++)
    DEBUG_printf(("9cups_find_option: options[%d].name=\"%s\", .value=\"%s\"",
                  left, options[left].name, options[left].value));
#endif /* DEBUG */

  key.name = (char *)name;

  if (prev >= 0)
  {
   /*
    * Start search on either side of previous...
    */

    if ((diff = cups_compare_options(&key, options + prev)) == 0 ||
        (diff < 0 && prev == 0) ||
	(diff > 0 && prev == (num_options - 1)))
    {
      *rdiff = diff;
      return (prev);
    }
    else if (diff < 0)
    {
     /*
      * Start with previous on right side...
      */

      left  = 0;
      right = prev;
    }
    else
    {
     /*
      * Start wih previous on left side...
      */

      left  = prev;
      right = num_options - 1;
    }
  }
  else
  {
   /*
    * Start search in the middle...
    */

    left  = 0;
    right = num_options - 1;
  }

  do
  {
    current = (left + right) / 2;
    diff    = cups_compare_options(&key, options + current);

    if (diff == 0)
      break;
    else if (diff < 0)
      right = current;
    else
      left = current;
  }
  while ((right - left) > 1);

  if (diff != 0)
  {
   /*
    * Check the last 1 or 2 elements...
    */

    if ((diff = cups_compare_options(&key, options + left)) <= 0)
      current = left;
    else
    {
      diff    = cups_compare_options(&key, options + right);
      current = right;
    }
  }

 /*
  * Return the closest destination and the difference...
  */

  *rdiff = diff;

  return (current);
}


/*
 * End of "$Id: options.c 8181 2008-12-10 17:29:57Z mike $".
 */
Commit	Line	Data
ef416fc2	1	/*
426c6a59	2	* "$Id: options.c 8181 2008-12-10 17:29:57Z mike $"
ef416fc2	3	*
f8b3a85b	4	* Option routines for CUPS.
ef416fc2	5	*
f8b3a85b	6	* Copyright 2007-2010 by Apple Inc.
f7deaa1a	7	* Copyright 1997-2007 by Easy Software Products.
ef416fc2	8	*
ef416fc2	9	* These coded instructions, statements, and computer programs are the
bc44d920	10	* property of Apple Inc. and are protected by Federal copyright
	11	* law. Distribution and use rights are outlined in the file "LICENSE.txt"
	12	* which should have been included with this file. If this file is
	13	* file is missing or damaged, see the license at "http://www.cups.org/".
ef416fc2	14	*
	15	* This file is subject to the Apple OS-Developed Software exception.
	16	*
	17	* Contents:
	18	*
f8b3a85b MS	19	* cupsAddOption() - Add an option to an option array.
	20	* cupsFreeOptions() - Free all memory used by options.
	21	* cupsGetOption() - Get an option value.
	22	* cupsParseOptions() - Parse options from a command-line argument.
	23	* cupsRemoveOption() - Remove an option from an option array.
	24	* _cupsGet1284Values() - Get 1284 device ID keys and values.
	25	* cups_compare_options() - Compare two options.
	26	* cups_find_option() - Find an option using a binary search.
ef416fc2	27	*/
	28
	29	/*
	30	* Include necessary headers...
	31	*/
	32
	33	#include "cups.h"
	34	#include <stdlib.h>
	35	#include <ctype.h>
	36	#include "string.h"
	37	#include "debug.h"
	38
	39
426c6a59 MS	40	/*
	41	* Local functions...
	42	*/
	43
	44	static int cups_compare_options(cups_option_t a, cups_option_t b);
	45	static int cups_find_option(const char *name, int num_options,
	46	cups_option_t option, int prev, int rdiff);
	47
	48
ef416fc2	49	/*
ef416fc2	50	* 'cupsAddOption()' - Add an option to an option array.
5a738aea MS	51	*
	52	* New option arrays can be initialized simply by passing 0 for the
	53	* "num_options" parameter.
ef416fc2	54	*/
ef416fc2	55
5a738aea MS	56	int /* O - Number of options */
	57	cupsAddOption(const char name, / I - Name of option */
	58	const char value, / I - Value of option */
	59	int num_options,/* I - Number of options */
ef416fc2	60	cups_option_t *options) / IO - Pointer to options */
ef416fc2	61	{
ef416fc2	62	cups_option_t temp; / Pointer to new option */
426c6a59 MS	63	int insert, /* Insertion point */
426c6a59 MS	64	diff; /* Result of search */
ef416fc2	65
ef416fc2	66
f11a948a	67	DEBUG_printf(("2cupsAddOption(name=\"%s\", value=\"%s\", num_options=%d, "
e07d4801	68	"options=%p)", name, value, num_options, options));
20fbc903 MS	69
	70	if (!name \|\| !name[0] \|\| !value \|\| !options \|\| num_options < 0)
	71	{
f11a948a	72	DEBUG_printf(("3cupsAddOption: Returning %d", num_options));
ef416fc2	73	return (num_options);
20fbc903	74	}
ef416fc2	75
	76	/*
	77	* Look for an existing option with the same name...
	78	*/
	79
426c6a59 MS	80	if (num_options == 0)
	81	{
	82	insert = 0;
	83	diff = 1;
	84	}
	85	else
	86	{
	87	insert = cups_find_option(name, num_options, *options, num_options - 1,
	88	&diff);
ef416fc2	89
426c6a59 MS	90	if (diff > 0)
	91	insert ++;
	92	}
	93
	94	if (diff)
ef416fc2	95	{
	96	/*
	97	* No matching option name...
	98	*/
	99
f11a948a	100	DEBUG_printf(("4cupsAddOption: New option inserted at index %d...",
426c6a59	101	insert));
20fbc903	102
ef416fc2	103	if (num_options == 0)
	104	temp = (cups_option_t *)malloc(sizeof(cups_option_t));
	105	else
	106	temp = (cups_option_t )realloc(options, sizeof(cups_option_t) *
	107	(num_options + 1));
	108
	109	if (temp == NULL)
20fbc903	110	{
f11a948a	111	DEBUG_puts("3cupsAddOption: Unable to expand option array, returning 0");
ef416fc2	112	return (0);
20fbc903	113	}
ef416fc2	114
426c6a59 MS	115	*options = temp;
	116
	117	if (insert < num_options)
	118	{
f11a948a	119	DEBUG_printf(("4cupsAddOption: Shifting %d options...",
426c6a59 MS	120	(int)(num_options - insert)));
	121	memmove(temp + insert + 1, temp + insert,
	122	(num_options - insert) * sizeof(cups_option_t));
	123	}
	124
	125	temp += insert;
2e4ff8af	126	temp->name = _cupsStrAlloc(name);
ef416fc2	127	num_options ++;
	128	}
	129	else
	130	{
	131	/*
	132	* Match found; free the old value...
	133	*/
	134
f11a948a	135	DEBUG_printf(("4cupsAddOption: Option already exists at index %d...",
426c6a59 MS	136	insert));
	137
	138	temp = *options + insert;
2e4ff8af	139	_cupsStrFree(temp->value);
ef416fc2	140	}
ef416fc2	141
2e4ff8af	142	temp->value = _cupsStrAlloc(value);
ef416fc2	143
f11a948a	144	DEBUG_printf(("3cupsAddOption: Returning %d", num_options));
20fbc903	145
ef416fc2	146	return (num_options);
	147	}
	148
	149
	150	/*
	151	* 'cupsFreeOptions()' - Free all memory used by options.
	152	*/
	153
	154	void
	155	cupsFreeOptions(
	156	int num_options, /* I - Number of options */
	157	cups_option_t options) / I - Pointer to options */
	158	{
	159	int i; /* Looping var */
	160
	161
e07d4801	162	DEBUG_printf(("cupsFreeOptions(num_options=%d, options=%p)", num_options,
20fbc903 MS	163	options));
	164
	165	if (num_options <= 0 \|\| !options)
ef416fc2	166	return;
	167
	168	for (i = 0; i < num_options; i ++)
	169	{
2e4ff8af MS	170	_cupsStrFree(options[i].name);
2e4ff8af MS	171	_cupsStrFree(options[i].value);
ef416fc2	172	}
	173
	174	free(options);
	175	}
	176
	177
	178	/*
	179	* 'cupsGetOption()' - Get an option value.
	180	*/
	181
5a738aea	182	const char * /* O - Option value or @code NULL@ */
ef416fc2	183	cupsGetOption(const char name, / I - Name of option */
	184	int num_options,/* I - Number of options */
	185	cups_option_t options) / I - Options */
	186	{
426c6a59 MS	187	int diff, /* Result of comparison */
426c6a59 MS	188	match; /* Matching index */
ef416fc2	189
ef416fc2	190
e07d4801	191	DEBUG_printf(("2cupsGetOption(name=\"%s\", num_options=%d, options=%p)",
20fbc903 MS	192	name, num_options, options));
	193
	194	if (!name \|\| num_options <= 0 \|\| !options)
	195	{
e07d4801	196	DEBUG_puts("3cupsGetOption: Returning NULL");
ef416fc2	197	return (NULL);
20fbc903	198	}
ef416fc2	199
426c6a59 MS	200	match = cups_find_option(name, num_options, options, -1, &diff);
	201
	202	if (!diff)
	203	{
e07d4801	204	DEBUG_printf(("3cupsGetOption: Returning \"%s\"", options[match].value));
426c6a59 MS	205	return (options[match].value);
426c6a59 MS	206	}
ef416fc2	207
e07d4801	208	DEBUG_puts("3cupsGetOption: Returning NULL");
ef416fc2	209	return (NULL);
	210	}
	211
	212
ef416fc2	213	/*
b423cd4c	214	* 'cupsParseOptions()' - Parse options from a command-line argument.
	215	*
	216	* This function converts space-delimited name/value pairs according
	217	* to the PAPI text option ABNF specification. Collection values
	218	* ("name={a=... b=... c=...}") are stored with the curley brackets
5a738aea MS	219	* intact - use @code cupsParseOptions@ on the value to extract the
5a738aea MS	220	* collection attributes.
b423cd4c	221	*/
	222
	223	int /* O - Number of options found */
	224	cupsParseOptions(
	225	const char arg, / I - Argument to parse */
	226	int num_options, /* I - Number of options */
	227	cups_option_t *options) / O - Options found */
	228	{
	229	char copyarg, / Copy of input string */
	230	ptr, / Pointer into string */
	231	name, / Pointer to name */
5a738aea	232	value, / Pointer to value */
426c6a59	233	sep, /* Separator character */
5a738aea	234	quote; /* Quote character */
b423cd4c	235
b423cd4c	236
e07d4801	237	DEBUG_printf(("cupsParseOptions(arg=\"%s\", num_options=%d, options=%p)",
20fbc903 MS	238	arg, num_options, options));
20fbc903 MS	239
91c84a35 MS	240	/*
	241	* Range check input...
	242	*/
	243
	244	if (!arg)
20fbc903	245	{
e07d4801	246	DEBUG_printf(("1cupsParseOptions: Returning %d", num_options));
91c84a35	247	return (num_options);
20fbc903	248	}
91c84a35 MS	249
91c84a35 MS	250	if (!options \|\| num_options < 0)
20fbc903	251	{
e07d4801	252	DEBUG_puts("1cupsParseOptions: Returning 0");
b423cd4c	253	return (0);
20fbc903	254	}
b423cd4c	255
	256	/*
	257	* Make a copy of the argument string and then divide it up...
	258	*/
	259
91c84a35	260	if ((copyarg = strdup(arg)) == NULL)
20fbc903	261	{
e07d4801 MS	262	DEBUG_puts("1cupsParseOptions: Unable to copy arg string");
e07d4801 MS	263	DEBUG_printf(("1cupsParseOptions: Returning %d", num_options));
91c84a35	264	return (num_options);
20fbc903	265	}
91c84a35	266
ee571f26 MS	267	if (*copyarg == '{')
	268	{
	269	/*
	270	* Remove surrounding {} so we can parse "{name=value ... name=value}"...
	271	*/
	272
	273	if ((ptr = copyarg + strlen(copyarg) - 1) > copyarg && *ptr == '}')
	274	{
	275	*ptr = '\0';
	276	ptr = copyarg + 1;
	277	}
	278	else
	279	ptr = copyarg;
	280	}
	281	else
	282	ptr = copyarg;
b423cd4c	283
	284	/*
	285	* Skip leading spaces...
	286	*/
	287
	288	while (isspace(*ptr & 255))
	289	ptr ++;
	290
	291	/*
	292	* Loop through the string...
	293	*/
	294
	295	while (*ptr != '\0')
	296	{
	297	/*
	298	* Get the name up to a SPACE, =, or end-of-string...
	299	*/
	300
	301	name = ptr;
5a738aea	302	while (!isspace(ptr & 255) && ptr != '=' && *ptr)
b423cd4c	303	ptr ++;
	304
	305	/*
	306	* Avoid an empty name...
	307	*/
	308
	309	if (ptr == name)
	310	break;
	311
	312	/*
	313	* Skip trailing spaces...
	314	*/
	315
	316	while (isspace(*ptr & 255))
	317	*ptr++ = '\0';
	318
426c6a59 MS	319	if ((sep = *ptr) == '=')
	320	*ptr++ = '\0';
	321
e07d4801	322	DEBUG_printf(("2cupsParseOptions: name=\"%s\"", name));
20fbc903	323
426c6a59	324	if (sep != '=')
b423cd4c	325	{
b423cd4c	326	/*
5a738aea	327	* Boolean option...
b423cd4c	328	*/
b423cd4c	329
5a738aea	330	if (!strncasecmp(name, "no", 2))
b423cd4c	331	num_options = cupsAddOption(name + 2, "false", num_options,
	332	options);
	333	else
	334	num_options = cupsAddOption(name, "true", num_options, options);
	335
	336	continue;
	337	}
	338
	339	/*
	340	* Remove = and parse the value...
	341	*/
	342
426c6a59	343	value = ptr;
b423cd4c	344
20fbc903	345	while (ptr && !isspace(ptr & 255))
b423cd4c	346	{
20fbc903 MS	347	if (*ptr == ',')
	348	ptr ++;
	349	else if (ptr == '\'' \|\| ptr == '\"')
b423cd4c	350	{
20fbc903 MS	351	/*
	352	* Quoted string constant...
	353	*/
b423cd4c	354
20fbc903 MS	355	quote = *ptr;
20fbc903 MS	356	_cups_strcpy(ptr, ptr + 1);
b423cd4c	357
20fbc903 MS	358	while (ptr != quote && ptr)
	359	{
	360	if (*ptr == '\\' && ptr[1])
	361	_cups_strcpy(ptr, ptr + 1);
	362
	363	ptr ++;
	364	}
b423cd4c	365
20fbc903 MS	366	if (*ptr)
	367	_cups_strcpy(ptr, ptr + 1);
	368	}
	369	else if (*ptr == '{')
	370	{
	371	/*
	372	* Collection value...
	373	*/
b423cd4c	374
20fbc903	375	int depth;
b423cd4c	376
20fbc903	377	for (depth = 0; *ptr; ptr ++)
b423cd4c	378	{
20fbc903 MS	379	if (*ptr == '{')
	380	depth ++;
	381	else if (*ptr == '}')
b423cd4c	382	{
20fbc903 MS	383	depth --;
	384	if (!depth)
	385	{
	386	ptr ++;
b423cd4c	387	break;
20fbc903	388	}
b423cd4c	389	}
20fbc903 MS	390	else if (*ptr == '\\' && ptr[1])
	391	_cups_strcpy(ptr, ptr + 1);
	392	}
	393	}
	394	else
b423cd4c	395	{
20fbc903 MS	396	/*
	397	* Normal space-delimited string...
	398	*/
b423cd4c	399
20fbc903 MS	400	while (!isspace(ptr & 255) && ptr)
	401	{
	402	if (*ptr == '\\' && ptr[1])
	403	_cups_strcpy(ptr, ptr + 1);
	404
	405	ptr ++;
	406	}
b423cd4c	407	}
	408	}
	409
20fbc903 MS	410	if (*ptr != '\0')
	411	*ptr++ = '\0';
	412
e07d4801	413	DEBUG_printf(("2cupsParseOptions: value=\"%s\"", value));
20fbc903	414
b423cd4c	415	/*
	416	* Skip trailing whitespace...
	417	*/
	418
	419	while (isspace(*ptr & 255))
20fbc903	420	ptr ++;
b423cd4c	421
	422	/*
	423	* Add the string value...
	424	*/
	425
	426	num_options = cupsAddOption(name, value, num_options, options);
	427	}
	428
	429	/*
	430	* Free the copy of the argument we made and return the number of options
	431	* found.
	432	*/
	433
	434	free(copyarg);
	435
e07d4801	436	DEBUG_printf(("1cupsParseOptions: Returning %d", num_options));
20fbc903	437
b423cd4c	438	return (num_options);
	439	}
	440
	441
	442	/*
f7deaa1a	443	* 'cupsRemoveOption()' - Remove an option from an option array.
b423cd4c	444	*
426c6a59	445	* @since CUPS 1.2/Mac OS X 10.5@
b423cd4c	446	*/
	447
	448	int /* O - New number of options */
	449	cupsRemoveOption(
	450	const char name, / I - Option name */
	451	int num_options, /* I - Current number of options */
	452	cups_option_t *options) / IO - Options */
	453	{
	454	int i; /* Looping var */
	455	cups_option_t option; / Current option */
	456
	457
f11a948a	458	DEBUG_printf(("2cupsRemoveOption(name=\"%s\", num_options=%d, options=%p)",
20fbc903 MS	459	name, num_options, options));
20fbc903 MS	460
b423cd4c	461	/*
	462	* Range check input...
	463	*/
	464
	465	if (!name \|\| num_options < 1 \|\| !options)
20fbc903	466	{
f11a948a	467	DEBUG_printf(("3cupsRemoveOption: Returning %d", num_options));
b423cd4c	468	return (num_options);
20fbc903	469	}
b423cd4c	470
	471	/*
	472	* Loop for the option...
	473	*/
	474
	475	for (i = num_options, option = *options; i > 0; i --, option ++)
	476	if (!strcasecmp(name, option->name))
	477	break;
	478
	479	if (i)
	480	{
	481	/*
	482	* Remove this option from the array...
	483	*/
	484
f11a948a	485	DEBUG_puts("4cupsRemoveOption: Found option, removing it...");
20fbc903	486
b423cd4c	487	num_options --;
	488	i --;
	489
2e4ff8af MS	490	_cupsStrFree(option->name);
2e4ff8af MS	491	_cupsStrFree(option->value);
b423cd4c	492
b423cd4c	493	if (i > 0)
f7deaa1a	494	memmove(option, option + 1, i * sizeof(cups_option_t));
b423cd4c	495	}
	496
	497	/*
	498	* Return the new number of options...
	499	*/
	500
f11a948a	501	DEBUG_printf(("3cupsRemoveOption: Returning %d", num_options));
b423cd4c	502	return (num_options);
	503	}
	504
	505
f8b3a85b MS	506	/*
	507	* '_cupsGet1284Values()' - Get 1284 device ID keys and values.
	508	*
	509	* The returned dictionary is a CUPS option array that can be queried with
	510	* cupsGetOption and freed with cupsFreeOptions.
	511	*/
	512
	513	int /* O - Number of key/value pairs */
	514	_cupsGet1284Values(
	515	const char device_id, / I - IEEE-1284 device ID string */
	516	cups_option_t *values) / O - Array of key/value pairs */
	517	{
	518	int num_values; /* Number of values */
	519	char key[256], /* Key string */
	520	value[256], /* Value string */
	521	ptr; / Pointer into key/value */
	522
	523
	524	/*
	525	* Range check input...
	526	*/
	527
	528	if (values)
	529	*values = NULL;
	530
	531	if (!device_id \|\| !values)
	532	return (0);
	533
	534	/*
	535	* Parse the 1284 device ID value into keys and values. The format is
	536	* repeating sequences of:
	537	*
	538	* [whitespace]key:value[whitespace];
	539	*/
	540
	541	num_values = 0;
	542	while (*device_id)
	543	{
	544	while (isspace(*device_id & 255))
	545	device_id ++;
	546
	547	if (!*device_id)
	548	break;
	549
	550	for (ptr = key; device_id && device_id != ':'; device_id ++)
	551	if (ptr < (key + sizeof(key) - 1))
	552	ptr++ = device_id;
	553
	554	if (!*device_id)
	555	break;
	556
	557	while (ptr > key && isspace(ptr[-1] & 255))
	558	ptr --;
	559
	560	*ptr = '\0';
	561	device_id ++;
	562
	563	while (isspace(*device_id & 255))
	564	device_id ++;
	565
	566	if (!*device_id)
	567	break;
	568
	569	for (ptr = value; device_id && device_id != ';'; device_id ++)
570	if (ptr < (value + sizeof(value) - 1))
571	ptr++ = device_id;
572
573	if (!*device_id)
574	break;
575
576	while (ptr > value && isspace(ptr[-1] & 255))
577	ptr --;
578
579	*ptr = '\0';
580	device_id ++;
581
582	num_values = cupsAddOption(key, value, num_values, values);
583	}
584
585	return (num_values);
586	}
587
588
09a101d6	589	/*
426c6a59 MS	590	* 'cups_compare_options()' - Compare two options.
	591	*/
	592
	593	static int /* O - Result of comparison */
	594	cups_compare_options(cups_option_t a, / I - First option */
	595	cups_option_t b) / I - Second option */
	596	{
	597	return (strcasecmp(a->name, b->name));
	598	}
	599
	600
	601	/*
	602	* 'cups_find_option()' - Find an option using a binary search.
	603	*/
	604
	605	static int /* O - Index of match */
	606	cups_find_option(
	607	const char name, / I - Option name */
	608	int num_options, /* I - Number of options */
	609	cups_option_t options, / I - Options */
	610	int prev, /* I - Previous index */
	611	int rdiff) / O - Difference of match */
	612	{
	613	int left, /* Low mark for binary search */
	614	right, /* High mark for binary search */
	615	current, /* Current index */
	616	diff; /* Result of comparison */
	617	cups_option_t key; /* Search key */
	618
	619
e07d4801 MS	620	DEBUG_printf(("7cups_find_option(name=\"%s\", num_options=%d, options=%p, "
e07d4801 MS	621	"prev=%d, rdiff=%p)", name, num_options, options, prev,
426c6a59 MS	622	rdiff));
	623
	624	#ifdef DEBUG
	625	for (left = 0; left < num_options; left ++)
e07d4801	626	DEBUG_printf(("9cups_find_option: options[%d].name=\"%s\", .value=\"%s\"",
426c6a59 MS	627	left, options[left].name, options[left].value));
	628	#endif /* DEBUG */
	629
	630	key.name = (char *)name;
	631
	632	if (prev >= 0)
	633	{
	634	/*
	635	* Start search on either side of previous...
	636	*/
	637
	638	if ((diff = cups_compare_options(&key, options + prev)) == 0 \|\|
	639	(diff < 0 && prev == 0) \|\|
	640	(diff > 0 && prev == (num_options - 1)))
	641	{
	642	*rdiff = diff;
	643	return (prev);
	644	}
	645	else if (diff < 0)
	646	{
	647	/*
	648	* Start with previous on right side...
	649	*/
	650
	651	left = 0;
	652	right = prev;
	653	}
	654	else
	655	{
	656	/*
	657	* Start wih previous on left side...
	658	*/
	659
	660	left = prev;
	661	right = num_options - 1;
	662	}
	663	}
	664	else
	665	{
	666	/*
	667	* Start search in the middle...
	668	*/
	669
	670	left = 0;
	671	right = num_options - 1;
	672	}
	673
	674	do
	675	{
	676	current = (left + right) / 2;
	677	diff = cups_compare_options(&key, options + current);
	678
	679	if (diff == 0)
	680	break;
	681	else if (diff < 0)
	682	right = current;
	683	else
	684	left = current;
	685	}
	686	while ((right - left) > 1);
	687
	688	if (diff != 0)
	689	{
	690	/*
691	* Check the last 1 or 2 elements...
692	*/
693
694	if ((diff = cups_compare_options(&key, options + left)) <= 0)
695	current = left;
696	else
697	{
698	diff = cups_compare_options(&key, options + right);
699	current = right;
700	}
701	}
702
703	/*
704	* Return the closest destination and the difference...
705	*/
706
707	*rdiff = diff;
708
709	return (current);
710	}
711
712
713	/*
714	* End of "$Id: options.c 8181 2008-12-10 17:29:57Z mike $".
ef416fc2	715	*/