//
// "$Id: ppdc-source.cxx 303 2007-02-14 21:53:07Z mike $"
//
//   Source class for the CUPS PPD Compiler.
//
//   Copyright 2002-2007 by Easy Software Products.
//
//   These coded instructions, statements, and computer programs are the
//   property of Easy Software Products 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 missing or damaged please contact Easy Software Products
//   at:
//
//       Attn: CUPS Licensing Information
//       Easy Software Products
//       44141 Airport View Drive, Suite 204
//       Hollywood, Maryland 20636 USA
//
//       Voice: (301) 373-9600
//       EMail: cups-info@cups.org
//         WWW: http://www.cups.org
//
// Contents:
//
//   ppdcSource::ppdcSource()         - Load a driver source file.
//   ppdcSource::~ppdcSource()        - Free a driver source file.
//   ppdcSource::add_include()        - Add an include directory.
//   ppdcSource::find_driver()        - Find a driver.
//   ppdcSource::find_include()       - Find an include file.
//   ppdcSource::find_size()          - Find a media size.
//   ppdcSource::find_variable()      - Find a variable.
//   ppdcSource::get_attr()           - Get an attribute.
//   ppdcSource::get_boolean()        - Get a boolean value.
//   ppdcSource::get_choice()         - Get a choice.
//   ppdcSource::get_color_model()    - Get an old-style color model option.
//   ppdcSource::get_color_order()    - Get an old-style color order value.
//   ppdcSource::get_color_profile()  - Get a color profile definition.
//   ppdcSource::get_color_space()    - Get an old-style colorspace value.
//   ppdcSource::get_constraint()     - Get a constraint.
//   ppdcSource::get_custom_size()    - Get a custom media size definition
//                                      from a file.
//   ppdcSource::get_filter()         - Get a filter.
//   ppdcSource::get_float()          - Get a single floating-point number.
//   ppdcSource::get_font()           - Get a font definition.
//   ppdcSource::get_generic()        - Get a generic old-style option.
//   ppdcSource::get_group()          - Get an option group.
//   ppdcSource::get_installable()    - Get an installable option.
//   ppdcSource::get_integer()        - Get an integer value from a string.
//   ppdcSource::get_integer()        - Get an integer value from a file.
//   ppdcSource::get_measurement()    - Get a measurement value.
//   ppdcSource::get_option()         - Get an option definition.
//   ppdcSource::get_resolution()     - Get an old-style resolution option.
//   ppdcSource::get_simple_profile() - Get a simple color profile definition.
//   ppdcSource::get_size()           - Get a media size definition from a file.
//   ppdcSource::get_token()          - Get a token from a file.
//   ppdcSource::get_variable()       - Get a variable definition.
//   ppdcSource::quotef()             - Write a formatted, quoted string...
//   ppdcSource::read_file()          - Read a driver source file.
//   ppdcSource::scan_file()          - Scan a driver source file.
//   ppdcSource::set_variable()       - Set a variable.
//   ppdcSource::write_file()         - Write the current source data to a file.
//

//
// Include necessary headers...
//

#include "ppdc.h"
#include <limits.h>
#include <math.h>
#include <unistd.h>
#include <cups/raster.h>
#include "data/epson.h"
#include "data/escp.h"
#include "data/hp.h"
#include "data/label.h"
#include "data/pcl.h"


//
// Class globals...
//

ppdcArray	*ppdcSource::includes = 0;
const char	*ppdcSource::driver_types[] =
		{
		  "custom",
		  "ps",
		  "escp",
		  "pcl",
		  "label",
		  "epson",
		  "hp"
		};


//
// 'ppdcSource::ppdcSource()' - Load a driver source file.
//

ppdcSource::ppdcSource(const char *f)	// I - File to read
{
  filename   = new ppdcString(f);
  base_fonts = new ppdcArray();
  drivers    = new ppdcArray();
  po_files   = new ppdcArray();
  sizes      = new ppdcArray();
  vars       = new ppdcArray();

  if (f)
    read_file(f);
  else
  {
    // #include <font.defs>
    char	incname[1024];		// Include filename
    ppdcFile	*incfile;		// Include file


    // Find the include file...
    if (find_include("font.defs", ".", incname, sizeof(incname)))
    {
      // Open the include file, scan it, and then close it...
      incfile = new ppdcFile(incname);
      scan_file(incfile);
      delete incfile;
    }
  }
}


//
// 'ppdcSource::~ppdcSource()' - Free a driver source file.
//

ppdcSource::~ppdcSource()
{
  delete filename;
  delete base_fonts;
  delete drivers;
  delete po_files;
  delete sizes;
  delete vars;
}


//
// 'ppdcSource::add_include()' - Add an include directory.
//

void
ppdcSource::add_include(const char *d)	// I - Include directory
{
  if (!d)
    return;

  if (!includes)
    includes = new ppdcArray();

  includes->add(new ppdcString(d));
}


//
// 'ppdcSource::find_driver()' - Find a driver.
//

ppdcDriver *				// O - Driver
ppdcSource::find_driver(const char *f)	// I - Driver file name
{
  ppdcDriver	*d;			// Current driver


  for (d = (ppdcDriver *)drivers->first(); d; d = (ppdcDriver *)drivers->next())
    if (!strcasecmp(f, d->pc_file_name->value))
      return (d);

  return (NULL);
}


//
// 'ppdcSource::find_include()' - Find an include file.
//

char *					// O - Found path or NULL
ppdcSource::find_include(
    const char *f,			// I - Include filename
    const char *base,			// I - Current directory
    char       *n,			// I - Path buffer
    int        nlen)			// I - Path buffer length
{
  ppdcString	*dir;			// Include directory
  char		temp[1024],		// Temporary path
		*ptr;			// Pointer to end of path


  // Range check input...
  if (!f || !*f || !n || nlen < 2)
    return (0);

  // Check the first character to see if we have <name> or "name"...
  if (*f == '<')
  {
    // Remove the surrounding <> from the name...
    strlcpy(temp, f + 1, sizeof(temp));
    ptr = temp + strlen(temp) - 1;

    if (*ptr != '>')
    {
      fprintf(stderr, "ppdc: Invalid #include/#po filename \"%s\"!\n", n);
      return (0);
    }

    *ptr = '\0';
    f    = temp;
  }
  else
  {
    // Check for the local file relative to the current directory...
    if (base && *base && f[0] != '/')
      snprintf(n, nlen, "%s/%s", base, f);
    else
      strlcpy(n, f, nlen);

    if (!access(n, 0))
      return (n);
    else if (*f == '/')
    {
      // Absolute path that doesn't exist...
      return (0);
    }
  }

  // Search the include directories, if any...
  if (includes)
  {
    for (dir = (ppdcString *)includes->first(); dir; dir = (ppdcString *)includes->next())
    {
      snprintf(n, nlen, "%s/%s", dir->value, f);
      if (!access(n, 0))
        return (n);
    }
  }

  // Search the standard include directories...
  const char *env;			// Directory environment variable

  if ((env = getenv("PPDC_INCLUDE_DIR")) == NULL)
    env = PPDC_INCLUDE_DIR;

  snprintf(n, nlen, "%s/%s", env, f);
  if (!access(n, 0))
    return (n);

  if ((env = getenv("PPDC_PO_DIR")) == NULL)
    env = PPDC_PO_DIR;

  snprintf(n, nlen, "%s/%s", env, f);
  if (!access(n, 0))
    return (n);
  else
    return (0);
}


//
// 'ppdcSource::find_po()' - Find a message catalog for the given locale...
//

ppdcCatalog *				// O - Message catalog or NULL
ppdcSource::find_po(const char *l)	// I - Locale name
{
  ppdcCatalog	*cat;			// Current message catalog


  for (cat = (ppdcCatalog *)po_files->first();
       cat;
       cat = (ppdcCatalog *)po_files->next())
    if (!strcasecmp(l, cat->locale->value))
      return (cat);

  return (NULL);
}


//
// 'ppdcSource::find_size()' - Find a media size.
//

ppdcMediaSize *				// O - Size
ppdcSource::find_size(const char *s)	// I - Size name
{
  ppdcMediaSize	*m;			// Current media size


  for (m = (ppdcMediaSize *)sizes->first(); m; m = (ppdcMediaSize *)sizes->next())
    if (!strcasecmp(s, m->name->value))
      return (m);

  return (NULL);
}


//
// 'ppdcSource::find_variable()' - Find a variable.
//

ppdcVariable *				// O - Variable
ppdcSource::find_variable(const char *n)// I - Variable name
{
  ppdcVariable	*v;			// Current variable


  for (v = (ppdcVariable *)vars->first(); v; v = (ppdcVariable *)vars->next())
    if (!strcasecmp(n, v->name->value))
      return (v);

  return (NULL);
}


//
// 'ppdcSource::get_attr()' - Get an attribute.
//

ppdcAttr *				// O - Attribute
ppdcSource::get_attr(ppdcFile *fp)	// I - File to read
{
  char	name[1024],			// Name string
	selector[1024],			// Selector string
	*text,				// Text string
	value[1024];			// Value string


  // Get the attribute parameters:
  //
  // Attribute name selector value
  if (!get_token(fp, name, sizeof(name)))
  {
    fprintf(stderr, "ppdc: Expected name after Attribute on line %d of %s!\n",
            fp->line, fp->filename);
    return (0);
  }

  if (!get_token(fp, selector, sizeof(selector)))
  {
    fprintf(stderr, "ppdc: Expected selector after Attribute on line %d of %s!\n",
            fp->line, fp->filename);
    return (0);
  }

  if ((text = strchr(selector, '/')) != NULL)
    *text++ = '\0';

  if (!get_token(fp, value, sizeof(value)))
  {
    fprintf(stderr, "ppdc: Expected value after Attribute on line %d of %s!\n",
            fp->line, fp->filename);
    return (0);
  }

//  printf("name=\"%s\", selector=\"%s\", value=\"%s\"\n", name, selector, value);

  return (new ppdcAttr(name, selector, text, value));
}


//
// 'ppdcSource::get_boolean()' - Get a boolean value.
//

int					// O - Boolean value
ppdcSource::get_boolean(ppdcFile *fp)	// I - File to read
{
  char	buffer[256];			// String buffer


  if (!get_token(fp, buffer, sizeof(buffer)))
  {
    fprintf(stderr, "ppdc: Expected boolean value on line %d of %s.\n",
            fp->line, fp->filename);
    return (-1);
  }

  if (!strcasecmp(buffer, "on") ||
      !strcasecmp(buffer, "yes") ||
      !strcasecmp(buffer, "true"))
    return (1);
  else if (!strcasecmp(buffer, "off") ||
	   !strcasecmp(buffer, "no") ||
	   !strcasecmp(buffer, "false"))
    return (0);
  else
  {
    fprintf(stderr, "ppdc: Bad boolean value (%s) on line %d of %s.\n",
            buffer, fp->line, fp->filename);
    return (-1);
  }
}


//
// 'ppdcSource::get_choice()' - Get a choice.
//

ppdcChoice *				// O - Choice data
ppdcSource::get_choice(ppdcFile *fp)	// I - File to read
{
  char	name[1024],			// Name
	*text,				// Text
	code[10240];			// Code


  // Read a choice from the file:
  //
  // Choice name/text code
  if (!get_token(fp, name, sizeof(name)))
  {
    fprintf(stderr, "ppdc: Expected choice name/text on line %d of %s.\n",
            fp->line, fp->filename);
    return (NULL);
  }

  if ((text = strchr(name, '/')) != NULL)
    *text++ = '\0';
  else
    text = name;

  if (!get_token(fp, code, sizeof(code)))
  {
    fprintf(stderr, "ppdc: Expected choice code on line %d of %s.\n",
            fp->line, fp->filename);
    return (NULL);
  }

  // Return the new choice
  return (new ppdcChoice(name, text, code));
}


//
// 'ppdcSource::get_color_model()' - Get an old-style color model option.
//

ppdcChoice *				// O - Choice data
ppdcSource::get_color_model(ppdcFile *fp)
					// I - File to read
{
  char		name[1024],		// Option name
		*text,			// Text option
		temp[256];		// Temporary string
  int		color_space,		// Colorspace
		color_order,		// Color order
		compression;		// Compression mode


  // Get the ColorModel parameters:
  //
  // ColorModel name/text colorspace colororder compression
  if (!get_token(fp, name, sizeof(name)))
  {
    fprintf(stderr,
            "ppdc: Expected name/text combination for ColorModel on line "
	    "%d of %s!\n",
            fp->line, fp->filename);
    return (NULL);
  }

  if ((text = strchr(name, '/')) != NULL)
    *text++ = '\0';
  else
    text = name;

  if (!get_token(fp, temp, sizeof(temp)))
  {
    fprintf(stderr,
            "ppdc: Expected colorspace for ColorModel on line %d of %s!\n",
            fp->line, fp->filename);
    return (NULL);
  }

  if ((color_space = get_color_space(temp)) < 0)
    color_space = get_integer(temp);

  if (!get_token(fp, temp, sizeof(temp)))
  {
    fprintf(stderr,
            "ppdc: Expected color order for ColorModel on line %d of %s!\n",
            fp->line, fp->filename);
    return (NULL);
  }

  if ((color_order = get_color_order(temp)) < 0)
    color_order = get_integer(temp);

  if (!get_token(fp, temp, sizeof(temp)))
  {
    fprintf(stderr,
            "ppdc: Expected compression for ColorModel on line %d of %s!\n",
            fp->line, fp->filename);
    return (NULL);
  }

  compression = get_integer(temp);

  snprintf(temp, sizeof(temp),
           "<</cupsColorSpace %d/cupsColorOrder %d/cupsCompression %d>>"
	   "setpagedevice",
           color_space, color_order, compression);

  return (new ppdcChoice(name, text, temp));
}


//
// 'ppdcSource::get_color_order()' - Get an old-style color order value.
//

int					// O - Color order value
ppdcSource::get_color_order(
    const char *co)			// I - Color order string
{
  if (!strcasecmp(co, "chunked") ||
      !strcasecmp(co, "chunky"))
    return (CUPS_ORDER_CHUNKED);
  else if (!strcasecmp(co, "banded"))
    return (CUPS_ORDER_BANDED);
  else if (!strcasecmp(co, "planar"))
    return (CUPS_ORDER_PLANAR);
  else
    return (-1);
}


//
// 'ppdcSource::get_color_profile()' - Get a color profile definition.
//

ppdcProfile *				// O - Color profile
ppdcSource::get_color_profile(
    ppdcFile *fp)			// I - File to read
{
  char		resolution[1024],	// Resolution/media type
		*media_type;		// Media type
  int		i;			// Looping var
  float		g,			// Gamma value
		d,			// Density value
		m[9];			// Transform matrix


  // Get the ColorProfile parameters:
  //
  // ColorProfile resolution/mediatype gamma density m00 m01 m02 ... m22
  if (!get_token(fp, resolution, sizeof(resolution)))
  {
    fprintf(stderr, "ppdc: Expected resolution/mediatype following ColorProfile on line %d of %s!\n",
	    fp->line, fp->filename);
    return (NULL);
  }

  if ((media_type = strchr(resolution, '/')) != NULL)
    *media_type++ = '\0';
  else
    media_type = resolution;

  g = get_float(fp);
  d = get_float(fp);
  for (i = 0; i < 9; i ++)
    m[i] = get_float(fp);

  return (new ppdcProfile(resolution, media_type, g, d, m));
}


//
// 'ppdcSource::get_color_space()' - Get an old-style colorspace value.
//

int					// O - Colorspace value
ppdcSource::get_color_space(
    const char *cs)			// I - Colorspace string
{
  if (!strcasecmp(cs, "w"))
    return (CUPS_CSPACE_W);
  else if (!strcasecmp(cs, "rgb"))
    return (CUPS_CSPACE_RGB);
  else if (!strcasecmp(cs, "rgba"))
    return (CUPS_CSPACE_RGBA);
  else if (!strcasecmp(cs, "k"))
    return (CUPS_CSPACE_K);
  else if (!strcasecmp(cs, "cmy"))
    return (CUPS_CSPACE_CMY);
  else if (!strcasecmp(cs, "ymc"))
    return (CUPS_CSPACE_YMC);
  else if (!strcasecmp(cs, "cmyk"))
    return (CUPS_CSPACE_CMYK);
  else if (!strcasecmp(cs, "ymck"))
    return (CUPS_CSPACE_YMCK);
  else if (!strcasecmp(cs, "kcmy"))
    return (CUPS_CSPACE_KCMY);
  else if (!strcasecmp(cs, "kcmycm"))
    return (CUPS_CSPACE_KCMYcm);
  else if (!strcasecmp(cs, "gmck"))
    return (CUPS_CSPACE_GMCK);
  else if (!strcasecmp(cs, "gmcs"))
    return (CUPS_CSPACE_GMCS);
  else if (!strcasecmp(cs, "white"))
    return (CUPS_CSPACE_WHITE);
  else if (!strcasecmp(cs, "gold"))
    return (CUPS_CSPACE_GOLD);
  else if (!strcasecmp(cs, "silver"))
    return (CUPS_CSPACE_SILVER);
  else if (!strcasecmp(cs, "CIEXYZ"))
    return (CUPS_CSPACE_CIEXYZ);
  else if (!strcasecmp(cs, "CIELab"))
    return (CUPS_CSPACE_CIELab);
  else if (!strcasecmp(cs, "RGBW"))
    return (CUPS_CSPACE_RGBW);
  else if (!strcasecmp(cs, "ICC1"))
    return (CUPS_CSPACE_ICC1);
  else if (!strcasecmp(cs, "ICC2"))
    return (CUPS_CSPACE_ICC2);
  else if (!strcasecmp(cs, "ICC3"))
    return (CUPS_CSPACE_ICC3);
  else if (!strcasecmp(cs, "ICC4"))
    return (CUPS_CSPACE_ICC4);
  else if (!strcasecmp(cs, "ICC5"))
    return (CUPS_CSPACE_ICC5);
  else if (!strcasecmp(cs, "ICC6"))
    return (CUPS_CSPACE_ICC6);
  else if (!strcasecmp(cs, "ICC7"))
    return (CUPS_CSPACE_ICC7);
  else if (!strcasecmp(cs, "ICC8"))
    return (CUPS_CSPACE_ICC8);
  else if (!strcasecmp(cs, "ICC9"))
    return (CUPS_CSPACE_ICC9);
  else if (!strcasecmp(cs, "ICCA"))
    return (CUPS_CSPACE_ICCA);
  else if (!strcasecmp(cs, "ICCB"))
    return (CUPS_CSPACE_ICCB);
  else if (!strcasecmp(cs, "ICCC"))
    return (CUPS_CSPACE_ICCC);
  else if (!strcasecmp(cs, "ICCD"))
    return (CUPS_CSPACE_ICCD);
  else if (!strcasecmp(cs, "ICCE"))
    return (CUPS_CSPACE_ICCE);
  else if (!strcasecmp(cs, "ICCF"))
    return (CUPS_CSPACE_ICCF);
  else
    return (-1);
}


//
// 'ppdcSource::get_constraint()' - Get a constraint.
//

ppdcConstraint *			// O - Constraint
ppdcSource::get_constraint(ppdcFile *fp)// I - File to read
{
  char		temp[1024],		// One string to rule them all
		*ptr,			// Pointer into string
		*option1,		// Constraint option 1
		*choice1,		// Constraint choice 1
		*option2,		// Constraint option 2
		*choice2;		// Constraint choice 2


  // Read the UIConstaints parameter in one of the following forms:
  //
  // UIConstraints "*Option1 *Option2"
  // UIConstraints "*Option1 Choice1 *Option2"
  // UIConstraints "*Option1 *Option2 Choice2"
  // UIConstraints "*Option1 Choice1 *Option2 Choice2"
  if (!get_token(fp, temp, sizeof(temp)))
  {
    fprintf(stderr, "ppdc: Expected constraints string for UIConstraints on line %d of %s!\n",
            fp->line, fp->filename);
    return (NULL);
  }

  for (ptr = temp; isspace(*ptr); ptr ++);

  if (*ptr != '*')
  {
    fprintf(stderr, "ppdc: Option constraint must *name on line %d of %s!\n",
            fp->line, fp->filename);
    return (NULL);
  }

  option1 = ptr;

  for (; *ptr && !isspace(*ptr); ptr ++);
  for (; isspace(*ptr); *ptr++ = '\0');

  if (*ptr != '*')
  {
    choice1 = ptr;

    for (; *ptr && !isspace(*ptr); ptr ++);
    for (; isspace(*ptr); *ptr++ = '\0');
  }
  else
    choice1 = NULL;

  if (*ptr != '*')
  {
    fprintf(stderr, "ppdc: Expected two option names on line %d of %s!\n",
            fp->line, fp->filename);
    return (NULL);
  }

  option2 = ptr;

  for (; *ptr && !isspace(*ptr); ptr ++);
  for (; isspace(*ptr); *ptr++ = '\0');

  if (*ptr)
    choice2 = ptr;
  else
    choice2 = NULL;

  return (new ppdcConstraint(option1, choice1, option2, choice2));
}


//
// 'ppdcSource::get_custom_size()' - Get a custom media size definition from a file.
//

ppdcMediaSize *				// O - Media size
ppdcSource::get_custom_size(ppdcFile *fp)
					// I - File to read
{
  char		name[1024],		// Name
		*text,			// Text
		size_code[10240],	// PageSize code
		region_code[10240];	// PageRegion
  float		width,			// Width
		length,			// Length
		left,			// Left margin
		bottom,			// Bottom margin
		right,			// Right margin
		top;			// Top margin


  // Get the name, text, width, length, margins, and code:
  //
  // CustomMedia name/text width length left bottom right top size-code region-code
  if (!get_token(fp, name, sizeof(name)))
    return (NULL);

  if ((text = strchr(name, '/')) != NULL)
    *text++ = '\0';
  else
    text = name;

  if ((width = get_measurement(fp)) < 0.0f)
    return (NULL);

  if ((length = get_measurement(fp)) < 0.0f)
    return (NULL);

  if ((left = get_measurement(fp)) < 0.0f)
    return (NULL);

  if ((bottom = get_measurement(fp)) < 0.0f)
    return (NULL);

  if ((right = get_measurement(fp)) < 0.0f)
    return (NULL);

  if ((top = get_measurement(fp)) < 0.0f)
    return (NULL);

  if (!get_token(fp, size_code, sizeof(size_code)))
    return (NULL);

  if (!get_token(fp, region_code, sizeof(region_code)))
    return (NULL);

  // Return the new media size...
  return (new ppdcMediaSize(name, text, width, length, left, bottom,
                            right, top, size_code, region_code));
}


//
// 'ppdcSource::get_duplex()' - Get a duplex option.
//

void
ppdcSource::get_duplex(ppdcFile   *fp,	// I - File to read from
                       ppdcDriver *d)	// I - Current driver
{
  char		temp[256];		// Duplex keyword
  ppdcAttr	*attr;			// cupsFlipDuplex attribute
  ppdcGroup	*g;			// Current group
  ppdcOption	*o;			// Duplex option


  // Duplex {boolean|none|normal|flip}
  if (!get_token(fp, temp, sizeof(temp)))
  {
    fprintf(stderr, "ppdc: Expected duplex type after Duplex on line %d of %s!\n",
	    fp->line, fp->filename);
    return;
  }

  if (!strcasecmp(temp, "none") || !strcasecmp(temp, "false") ||
      !strcasecmp(temp, "no") || !strcasecmp(temp, "off"))
  {
    g = d->find_group("General");
    if ((o = g->find_option("Duplex")) != NULL)
      g->options->remove(o);

    for (attr = (ppdcAttr *)d->attrs->first();
         attr;
	 attr = (ppdcAttr *)d->attrs->next())
      if (!strcmp(attr->name->value, "cupsFlipDuplex"))
      {
        d->attrs->remove(attr);
	break;
      }
  }
  else if (!strcasecmp(temp, "normal") || !strcasecmp(temp, "true") ||
	   !strcasecmp(temp, "yes") || !strcasecmp(temp, "on") ||
	   !strcasecmp(temp, "flip"))
  {
    g = d->find_group("General");
    o = g->find_option("Duplex");

    if (!o)
    {
      o = new ppdcOption(PPDC_PICKONE, "Duplex", "Double-Sided Printing",
                	 !strcasecmp(temp, "flip") ? PPDC_SECTION_PAGE :
			                             PPDC_SECTION_ANY, 10.0f);
      o->add_choice(new ppdcChoice("None", "Off",
                        	   "<</Duplex false>>setpagedevice"));
      o->add_choice(new ppdcChoice("DuplexNoTumble", "Long-Edge Binding",
                                   "<</Duplex true/Tumble false>>setpagedevice"));
      o->add_choice(new ppdcChoice("DuplexTumble", "Short-Edge Binding",
                                   "<</Duplex true/Tumble true>>setpagedevice"));

      g->add_option(o);
    }

    for (attr = (ppdcAttr *)d->attrs->first();
         attr;
	 attr = (ppdcAttr *)d->attrs->next())
      if (!strcmp(attr->name->value, "cupsFlipDuplex"))
      {
        if (strcasecmp(temp, "flip"))
          d->attrs->remove(attr);
	break;
      }

    if (!strcasecmp(temp, "flip") && !attr)
      d->add_attr(new ppdcAttr("cupsFlipDuplex", NULL, NULL, "true"));
  }
  else
    fprintf(stderr, "ppdc: Unknown duplex type \"%s\" on line %d of %s!\n",
	    temp, fp->line, fp->filename);
}


//
// 'ppdcSource::get_filter()' - Get a filter.
//

ppdcFilter *				// O - Filter
ppdcSource::get_filter(ppdcFile *fp)	// I - File to read
{
  char	type[1024],			// MIME type
	program[1024],			// Filter program
	*ptr;				// Pointer into MIME type
  int	cost;				// Relative cost


  // Read filter parameters in one of the following formats:
  //
  // Filter "type cost program"
  // Filter type cost program

  if (!get_token(fp, type, sizeof(type)))
  {
    fprintf(stderr, "ppdc: Expected a filter definition on line %d of %s!\n",
            fp->line, fp->filename);
    return (NULL);
  }

  if ((ptr = strchr(type, ' ')) != NULL)
  {
    // Old-style filter definition in one string...
    *ptr++ = '\0';
    cost = strtol(ptr, &ptr, 10);

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

    strcpy(program, ptr);
  }
  else
  {
    cost = get_integer(fp);

    if (!get_token(fp, program, sizeof(program)))
    {
      fprintf(stderr, "ppdc: Expected a program name on line %d of %s!\n",
              fp->line, fp->filename);
      return (NULL);
    }
  }

  if (!type[0])
  {
    fprintf(stderr, "ppdc: Invalid empty MIME type for filter on line %d of %s!\n",
            fp->line, fp->filename);
    return (NULL);
  }

  if (cost < 0 || cost > 200)
  {
    fprintf(stderr, "ppdc: Invalid cost for filter on line %d of %s!\n",
            fp->line, fp->filename);
    return (NULL);
  }

  if (!program[0])
  {
    fprintf(stderr, "ppdc: Invalid empty program name for filter on line %d of %s!\n",
            fp->line, fp->filename);
    return (NULL);
  }

  return (new ppdcFilter(type, program, cost));
}


//
// 'ppdcSource::get_float()' - Get a single floating-point number.
//

float					// O - Number
ppdcSource::get_float(ppdcFile *fp)	// I - File to read
{
  char	temp[256],			// String buffer
	*ptr;				// Pointer into buffer
  float	val;				// Floating point value


  // Get the number from the file and range-check...
  if (!get_token(fp, temp, sizeof(temp)))
  {
    fprintf(stderr, "ppdc: Expected real number on line %d of %s!\n",
            fp->line, fp->filename);
    return (-1.0f);
  }

  val = (float)strtod(temp, &ptr);

  if (*ptr)
  {
    fprintf(stderr, "ppdc: Unknown trailing characters in real number \"%s\" on line %d of %s!\n",
            temp, fp->line, fp->filename);
    return (-1.0f);
  }
  else
    return (val);
}


//
// 'ppdcSource::get_font()' - Get a font definition.
//

ppdcFont *				// O - Font data
ppdcSource::get_font(ppdcFile *fp)	// I - File to read
{
  char			name[256],	// Font name
			encoding[256],	// Font encoding
			version[256],	// Font version
			charset[256],	// Font charset
			temp[256];	// Font status string
  ppdcFontStatus	status;		// Font status enumeration


  // Read font parameters as follows:
  //
  // Font *
  // Font name encoding version charset status
  // %font name encoding version charset status
  //
  // "Name" is the PostScript font name.
  //
  // "Encoding" is the default encoding of the font: Standard, ISOLatin1,
  // Special, Expert, ExpertSubset, etc.
  //
  // "Version" is the version number string.
  //
  // "Charset" specifies the characters that are included in the font:
  // Standard, Special, Expert, Adobe-Identity, etc.
  //
  // "Status" is the keyword ROM or Disk.
  if (!get_token(fp, name, sizeof(name)))
  {
    fprintf(stderr, "ppdc: Expected name after Font on line %d of %s!\n",
            fp->line, fp->filename);
    return (0);
  }

  if (!strcmp(name, "*"))
  {
    // Include all base fonts...
    encoding[0] = '\0';
    version[0]  = '\0';
    charset[0]  = '\0';
    status      = PPDC_FONT_ROM;
  }
  else
  {
    // Load a full font definition...
    if (!get_token(fp, encoding, sizeof(encoding)))
    {
      fprintf(stderr, "ppdc: Expected encoding after Font on line %d of %s!\n",
              fp->line, fp->filename);
      return (0);
    }

    if (!get_token(fp, version, sizeof(version)))
    {
      fprintf(stderr, "ppdc: Expected version after Font on line %d of %s!\n",
              fp->line, fp->filename);
      return (0);
    }

    if (!get_token(fp, charset, sizeof(charset)))
    {
      fprintf(stderr, "ppdc: Expected charset after Font on line %d of %s!\n",
              fp->line, fp->filename);
      return (0);
    }

    if (!get_token(fp, temp, sizeof(temp)))
    {
      fprintf(stderr, "ppdc: Expected status after Font on line %d of %s!\n",
              fp->line, fp->filename);
      return (0);
    }

    if (!strcasecmp(temp, "ROM"))
      status = PPDC_FONT_ROM;
    else if (!strcasecmp(temp, "Disk"))
      status = PPDC_FONT_DISK;
    else
    {
      fprintf(stderr, "ppdc: Bad status keyword %s on line %d of %s!\n",
              temp, fp->line, fp->filename);
      return (0);
    }
  }

//  printf("Font %s %s %s %s %s\n", name, encoding, version, charset, temp);

  return (new ppdcFont(name, encoding, version, charset, status));
}


//
// 'ppdcSource::get_generic()' - Get a generic old-style option.
//

ppdcChoice *				// O - Choice data
ppdcSource::get_generic(ppdcFile   *fp,	// I - File to read
                        const char *keyword,
					// I - Keyword name
                        const char *tattr,
					// I - Text attribute
			const char *nattr)
					// I - Numeric attribute
{
  char		name[1024],		// Name
		*text,			// Text
		command[256];		// Command string
  int		val;			// Numeric value


  // Read one of the following parameters:
  //
  // Foo name/text
  // Foo integer name/text
  if (nattr)
    val = get_integer(fp);
  else
    val = 0;

  if (!get_token(fp, name, sizeof(name)))
  {
    fprintf(stderr, "ppdc: Expected name/text after %s on line %d of %s!\n",
            keyword, fp->line, fp->filename);
    return (NULL);
  }

  if ((text = strchr(name, '/')) != NULL)
    *text++ = '\0';
  else
    text = name;

  if (nattr)
  {
    if (tattr)
      snprintf(command, sizeof(command),
               "<</%s(%s)/%s %d>>setpagedevice",
               tattr, name, nattr, val);
    else
      snprintf(command, sizeof(command),
               "<</%s %d>>setpagedevice",
               nattr, val);
  }
  else
    snprintf(command, sizeof(command),
             "<</%s(%s)>>setpagedevice",
             tattr, name);

  return (new ppdcChoice(name, text, command));
}


//
// 'ppdcSource::get_group()' - Get an option group.
//

ppdcGroup *				// O - Group
ppdcSource::get_group(ppdcFile   *fp,	// I - File to read
                      ppdcDriver *d)	// I - Printer driver
{
  char		name[1024],		// UI name
		*text;			// UI text
  ppdcGroup	*g;			// Group


  // Read the Group parameters:
  //
  // Group name/text
  if (!get_token(fp, name, sizeof(name)))
  {
    fprintf(stderr, "ppdc: Expected group name/text on line %d of %s!\n",
            fp->line, fp->filename);
    return (NULL);
  }

  if ((text = strchr(name, '/')) != NULL)
    *text++ = '\0';
  else
    text = name;

  // See if the group already exists...
  if ((g = d->find_group(name)) == NULL)
  {
    // Nope, add a new one...
    g = new ppdcGroup(name, text);
    d->add_group(g);
  }

  return (g);
}


//
// 'ppdcSource::get_installable()' - Get an installable option.
//

ppdcOption *				// O - Option
ppdcSource::get_installable(ppdcFile *fp)
					// I - File to read
{
  char		name[1024],		// Name for installable option
		*text;			// Text for installable option
  ppdcOption	*o;			// Option


  // Read the parameter for an installable option:
  //
  // Installable name/text
  if (!get_token(fp, name, sizeof(name)))
  {
    fprintf(stderr, "ppdc: Expected name/text after Installable on line %d of %s!\n",
            fp->line, fp->filename);
    return (NULL);
  }

  if ((text = strchr(name, '/')) != NULL)
    *text++ = '\0';
  else
    text = name;

  // Create the option...
  o = new ppdcOption(PPDC_BOOLEAN, name, text, PPDC_SECTION_ANY, 10.0f);

  // Add the false and true choices...
  o->add_choice(new ppdcChoice("False", "Not Installed", ""));
  o->add_choice(new ppdcChoice("True", "Installed", ""));

  return (o);
}


//
// 'ppdcSource::get_integer()' - Get an integer value from a string.
//

int					// O - Integer value
ppdcSource::get_integer(const char *v)	// I - Value string
{
  int	val;				// Value
  int	temp;				// Temporary value
  char	*newv;				// New value string pointer


  // Parse the value string...
  if (!v)
    return (-1);

  if (isdigit(*v) || *v == '-' || *v == '+')
  {
    // Return a simple integer value
    val = strtol(v, (char **)&v, 0);
    if (*v || val == LONG_MIN)
      return (-1);
    else
      return (val);
  }
  else if (*v == '(')
  {
    // Return the bitwise OR of each integer in parenthesis...
    v ++;
    val = 0;

    while (*v && *v != ')')
    {
      temp = strtol(v, &newv, 0);

      if (!*newv || newv == v || !(isspace(*newv) || *newv == ')') ||
          temp == LONG_MIN)
        return (-1);

      val |= temp;
      v   = newv;
    }

    if (*v == ')')
      return (val);
    else
      return (-1);
  }
  else
    return (-1);
}


//
// 'ppdcSource::get_integer()' - Get an integer value from a file.
//

int					// O - Integer value
ppdcSource::get_integer(ppdcFile *fp)	// I - File to read
{
  char	temp[1024];			// String buffer


  if (!get_token(fp, temp, sizeof(temp)))
  {
    fprintf(stderr, "ppdc: Expected integer on line %d of %s!\n",
            fp->line, fp->filename);
    return (-1);
  }
  else
    return (get_integer(temp));
}


//
// 'ppdcSource::get_measurement()' - Get a measurement value.
//

float					// O - Measurement value in points
ppdcSource::get_measurement(ppdcFile *fp)
					// I - File to read
{
  char	buffer[256],			// Number buffer
	*ptr;				// Pointer into buffer
  float	val;				// Measurement value


  // Grab a token from the file...
  if (!get_token(fp, buffer, sizeof(buffer)))
    return (-1.0f);

  // Get the floating point value of "s" and skip all digits and decimal points.
  val = (float)strtod(buffer, &ptr);

  // Check for a trailing unit specifier...
  if (!strcasecmp(ptr, "mm"))
    val *= 72.0f / 25.4f;
  else if (!strcasecmp(ptr, "cm"))
    val *= 72.0f / 2.54f;
  else if (!strcasecmp(ptr, "m"))
    val *= 72.0f / 0.0254f;
  else if (!strcasecmp(ptr, "in"))
    val *= 72.0f;
  else if (!strcasecmp(ptr, "ft"))
    val *= 72.0f * 12.0f;
  else if (strcasecmp(ptr, "pt") && *ptr)
    return (-1.0f);

  return (val);
}


//
// 'ppdcSource::get_option()' - Get an option definition.
//

ppdcOption *				// O - Option
ppdcSource::get_option(ppdcFile   *fp,	// I - File to read
                       ppdcDriver *d,	// I - Printer driver
		       ppdcGroup  *g)	// I - Current group
{
  char		name[1024],		// UI name
		*text,			// UI text
		type[256];		// UI type string
  ppdcOptType	ot;			// Option type value
  ppdcOptSection section;		// Option section
  float		order;			// Option order
  ppdcOption	*o;			// Option


  // Read the Option parameters:
  //
  // Option name/text type section order
  if (!get_token(fp, name, sizeof(name)))
  {
    fprintf(stderr, "ppdc: Expected option name/text on line %d of %s!\n",
            fp->line, fp->filename);
    return (NULL);
  }

  if ((text = strchr(name, '/')) != NULL)
    *text++ = '\0';
  else
    text = name;

  if (!get_token(fp, type, sizeof(type)))
  {
    fprintf(stderr, "ppdc: Expected option type on line %d of %s!\n",
            fp->line, fp->filename);
    return (NULL);
  }

  if (!strcasecmp(type, "boolean"))
    ot = PPDC_BOOLEAN;
  else if (!strcasecmp(type, "pickone"))
    ot = PPDC_PICKONE;
  else if (!strcasecmp(type, "pickmany"))
    ot = PPDC_PICKMANY;
  else
  {
    fprintf(stderr, "ppdc: Invalid option type \"%s\" on line %d of %s!\n",
            type, fp->line, fp->filename);
    return (NULL);
  }

  if (!get_token(fp, type, sizeof(type)))
  {
    fprintf(stderr, "ppdc: Expected option section on line %d of %s!\n",
            fp->line, fp->filename);
    return (NULL);
  }

  if (!strcasecmp(type, "AnySetup"))
    section = PPDC_SECTION_ANY;
  else if (!strcasecmp(type, "DocumentSetup"))
    section = PPDC_SECTION_DOCUMENT;
  else if (!strcasecmp(type, "ExitServer"))
    section = PPDC_SECTION_EXIT;
  else if (!strcasecmp(type, "JCLSetup"))
    section = PPDC_SECTION_JCL;
  else if (!strcasecmp(type, "PageSetup"))
    section = PPDC_SECTION_PAGE;
  else if (!strcasecmp(type, "Prolog"))
    section = PPDC_SECTION_PROLOG;
  else
  {
    fprintf(stderr, "ppdc: Invalid option section \"%s\" on line %d of %s!\n",
            type, fp->line, fp->filename);
    return (NULL);
  }

  order = get_float(fp);

  // See if the option already exists...
  if ((o = d->find_option(name)) == NULL)
  {
    // Nope, add a new one...
    o = new ppdcOption(ot, name, text, section, order);
    g->add_option(o);
  }
  else if (o->type != ot)
  {
//    printf("o=%p, o->type=%d, o->name=%s, ot=%d, name=%s\n",
//           o, o->type, o->name->value, ot, name);
    fprintf(stderr, "ppdc: Option already defined with a different type on line %d of %s!\n",
            fp->line, fp->filename);
    return (NULL);
  }

  return (o);
}


//
// 'ppdcSource::get_po()' - Get a message catalog.
//

ppdcCatalog *				// O - Message catalog
ppdcSource::get_po(ppdcFile *fp)	// I - File to read
{
  char		locale[32],		// Locale name
		poname[1024],		// Message catalog filename
		basedir[1024],		// Base directory
		*baseptr,		// Pointer into directory
		pofilename[1024];	// Full filename of message catalog
  ppdcCatalog	*cat;			// Message catalog


  // Read the #po parameters:
  //
  // #po locale "filename.po"
  if (!get_token(fp, locale, sizeof(locale)))
  {
    fprintf(stderr, "ppdc: Expected locale after #po on line %d of %s!\n",
            fp->line, fp->filename);
    return (NULL);
  }

  if (!get_token(fp, poname, sizeof(poname)))
  {
    fprintf(stderr, "ppdc: Expected filename after #po %s on line %d of %s!\n",
            locale, fp->line, fp->filename);
    return (NULL);
  }

  // See if the locale is already loaded...
  if (find_po(locale))
  {
    fprintf(stderr, "ppdc: Duplicate #po for locale %s on line %d of %s!\n",
            locale, fp->line, fp->filename);
    return (NULL);
  }

  // Figure out the current directory...
  strlcpy(basedir, fp->filename, sizeof(basedir));

  if ((baseptr = strrchr(basedir, '/')) != NULL)
    *baseptr = '\0';
  else
    strcpy(basedir, ".");

  // Find the po file...
  if (find_include(poname, basedir, pofilename, sizeof(pofilename)))
  {
    // Found it, so load it...
    cat = new ppdcCatalog(locale, pofilename);

    // Reset the filename to the name supplied by the user...
    delete cat->filename;
    cat->filename = new ppdcString(poname);

    // Return the catalog...
    return (cat);
  }
  else
  {
    fprintf(stderr, "ppdc: Unable to find #po file %s on line %d of %s!\n",
            poname, fp->line, fp->filename);
    return (NULL);
  }
}


//
// 'ppdcSource::get_resolution()' - Get an old-style resolution option.
//

ppdcChoice *				// O - Choice data
ppdcSource::get_resolution(ppdcFile *fp)// I - File to read
{
  char		name[1024],		// Name
		*text,			// Text
		temp[256],		// Temporary string
		command[256],		// Command string
		*commptr;		// Pointer into command
  int		xdpi, ydpi,		// X + Y resolution
		color_order,		// Color order
		color_space,		// Colorspace
		compression,		// Compression mode
		depth,			// Bits per color
		row_count,		// Row count
		row_feed,		// Row feed
		row_step;		// Row step/interval


  // Read the resolution parameters:
  //
  // Resolution colorspace bits row-count row-feed row-step name/text
  if (!get_token(fp, temp, sizeof(temp)))
  {
    fprintf(stderr, "ppdc: Expected override field after Resolution on line %d of %s!\n",
            fp->line, fp->filename);
    return (NULL);
  }

  color_order = get_color_order(temp);
  color_space = get_color_space(temp);
  compression = get_integer(temp);

  depth       = get_integer(fp);
  row_count   = get_integer(fp);
  row_feed    = get_integer(fp);
  row_step    = get_integer(fp);

  if (!get_token(fp, name, sizeof(name)))
  {
    fprintf(stderr, "ppdc: Expected name/text after Resolution on line %d of %s!\n",
            fp->line, fp->filename);
    return (NULL);
  }

  if ((text = strchr(name, '/')) != NULL)
    *text++ = '\0';
  else
    text = name;

  switch (sscanf(name, "%dx%d", &xdpi, &ydpi))
  {
    case 0 :
        fprintf(stderr, "ppdc: Bad resolution name \"%s\" on line %d of %s!\n",
	        name, fp->line, fp->filename);
        break;
    case 1 :
        ydpi = xdpi;
	break;
  }

  // Create the necessary PS commands...
  snprintf(command, sizeof(command),
           "<</HWResolution[%d %d]/cupsBitsPerColor %d/cupsRowCount %d"
           "/cupsRowFeed %d/cupsRowStep %d",
	   xdpi, ydpi, depth, row_count, row_feed, row_step);
  commptr = command + strlen(command);

  if (color_order >= 0)
  {
    snprintf(commptr, sizeof(command) - (commptr - command),
             "/cupsColorOrder %d", color_order);
    commptr += strlen(commptr);
  }

  if (color_space >= 0)
  {
    snprintf(commptr, sizeof(command) - (commptr - command),
             "/cupsColorSpace %d", color_space);
    commptr += strlen(commptr);
  }

  if (compression >= 0)
  {
    snprintf(commptr, sizeof(command) - (commptr - command),
             "/cupsCompression %d", compression);
    commptr += strlen(commptr);
  }

  snprintf(commptr, sizeof(command) - (commptr - command), ">>setpagedevice");

  // Return the new choice...
  return (new ppdcChoice(name, text, command));
}


//
// 'ppdcSource::get_simple_profile()' - Get a simple color profile definition.
//

ppdcProfile *				// O - Color profile
ppdcSource::get_simple_profile(ppdcFile *fp)
					// I - File to read
{
  char		resolution[1024],	// Resolution/media type
		*media_type;		// Media type
  float		m[9];			// Transform matrix
  float		kd, rd, g;		// Densities and gamma
  float		red, green, blue;	// RGB adjustments
  float		yellow;			// Yellow density
  float		color;			// Color density values


  // Get the SimpleColorProfile parameters:
  //
  // SimpleColorProfile resolution/mediatype black-density yellow-density
  //     red-density gamma red-adjust green-adjust blue-adjust
  if (!get_token(fp, resolution, sizeof(resolution)))
  {
    fprintf(stderr, "ppdc: Expected resolution/mediatype following SimpleColorProfile on line %d of %s!\n",
	    fp->line, fp->filename);
    return (NULL);
  }

  if ((media_type = strchr(resolution, '/')) != NULL)
    *media_type++ = '\0';
  else
    media_type = resolution;

  // Collect the profile parameters...
  kd     = get_float(fp);
  yellow = get_float(fp);
  rd     = get_float(fp);
  g      = get_float(fp);
  red    = get_float(fp);
  green  = get_float(fp);
  blue   = get_float(fp);

  // Build the color profile...
  color = 0.5f * rd / kd - kd;
  m[0]  = 1.0f;				// C
  m[1]  = color + blue;			// C + M (blue)
  m[2]  = color - green;		// C + Y (green)
  m[3]  = color - blue;			// M + C (blue)
  m[4]  = 1.0f;				// M
  m[5]  = color + red;			// M + Y (red)
  m[6]  = yellow * (color + green);	// Y + C (green)
  m[7]  = yellow * (color - red);	// Y + M (red)
  m[8]  = yellow;			// Y

  if (m[1] > 0.0f)
  {
    m[3] -= m[1];
    m[1] = 0.0f;
  }
  else if (m[3] > 0.0f)
  {
    m[1] -= m[3];
    m[3] = 0.0f;
  }

  if (m[2] > 0.0f)
  {
    m[6] -= m[2];
    m[2] = 0.0f;
  }
  else if (m[6] > 0.0f)
  {
    m[2] -= m[6];
    m[6] = 0.0f;
  }

  if (m[5] > 0.0f)
  {
    m[7] -= m[5];
    m[5] = 0.0f;
  }
  else if (m[7] > 0.0f)
  {
    m[5] -= m[7];
    m[7] = 0.0f;
  }

  // Return the new profile...
  return (new ppdcProfile(resolution, media_type, g, kd, m));
}


//
// 'ppdcSource::get_size()' - Get a media size definition from a file.
//

ppdcMediaSize *				// O - Media size
ppdcSource::get_size(ppdcFile *fp)	// I - File to read
{
  char		name[1024],		// Name
		*text;			// Text
  float		width,			// Width
		length;			// Length


  // Get the name, text, width, and length:
  //
  // #media name/text width length
  if (!get_token(fp, name, sizeof(name)))
    return (NULL);

  if ((text = strchr(name, '/')) != NULL)
    *text++ = '\0';
  else
    text = name;

  if ((width = get_measurement(fp)) < 0.0f)
    return (NULL);

  if ((length = get_measurement(fp)) < 0.0f)
    return (NULL);

  // Return the new media size...
  return (new ppdcMediaSize(name, text, width, length, 0.0f, 0.0f, 0.0f, 0.0f));
}


//
// 'ppdcSource::get_token()' - Get a token from a file.
//

char *					// O - Token string or NULL
ppdcSource::get_token(ppdcFile *fp,	// I - File to read
                      char     *buffer,	// I - Buffer
		      int      buflen)	// I - Length of buffer
{
  char		*bufptr,		// Pointer into string buffer
		*bufend;		// End of string buffer
  int		ch,			// Character from file
		nextch,			// Next char in file
		quote,			// Quote character used...
		empty,			// Empty input?
		startline;		// Start line for quote
  char		name[256],		// Name string
		*nameptr;		// Name pointer
  ppdcVariable	*var;			// Variable pointer


  // Mark the beginning and end of the buffer...
  bufptr = buffer;
  bufend = buffer + buflen - 1;

  // Loop intil we've read a token...
  quote     = 0;
  startline = 0;
  empty     = 1;

  while ((ch = fp->get()) != EOF)
  {
    if (isspace(ch) && !quote)
    {
      if (empty)
        continue;
      else
        break;
    }
    else if (ch == '$')
    {
      // Variable substitution
      empty = 0;

      for (nameptr = name; (ch = fp->peek()) != EOF;)
      {
        if (!isalnum(ch) && ch != '_')
	  break;
	else if (nameptr < (name + sizeof(name) - 1))
	  *nameptr++ = fp->get();
      }

      if (nameptr == name)
      {
        // Just substitute this character...
	if (ch == '$')
	{
	  // $$ = $
	  if (bufptr < bufend)
	    *bufptr++ = fp->get();
	}
	else
	{
	  // $ch = $ch
          fprintf(stderr, "ppdc: Bad variable substitution ($%c) on line %d of %s.\n",
                  ch, fp->line, fp->filename);

	  if (bufptr < bufend)
	    *bufptr++ = '$';
	}
      }
      else
      {
        // Substitute the variable value...
	*nameptr = '\0';
	var = find_variable(name);
	if (var)
	{
	  strncpy(bufptr, var->value->value, bufend - bufptr);
	  bufptr += strlen(var->value->value);
	}
	else
	{
	  fprintf(stderr, "ppdc: Undefined variable (%s) on line %d of %s.\n",
        	  name, fp->line, fp->filename);
	  snprintf(bufptr, bufend - bufptr + 1, "$%s", name);
	  bufptr += strlen(name) + 1;
	}
      }
    }
    else if (ch == '/' && !quote)
    {
      // Possibly a comment...
      nextch = fp->peek();

      if (nextch == '*')
      {
        // C comment...
	fp->get();
	ch = fp->get();
	while ((nextch = fp->get()) != EOF)
	{
	  if (ch == '*' && nextch == '/')
	    break;

	  ch = nextch;
	}

        if (nextch == EOF)
          break;
      }
      else if (nextch == '/')
      {
        // C++ comment...
        while ((nextch = fp->get()) != EOF)
          if (nextch == '\n')
	    break;

        if (nextch == EOF)
          break;
      }
      else
      {
        // Not a comment...
        empty = 0;

	if (bufptr < bufend)
	  *bufptr++ = ch;
      }
    }
    else if (ch == '\'' || ch == '\"')
    {
      empty = 0;

      if (quote == ch)
      {
        // Ending the current quoted string...
        quote = 0;
      }
      else if (quote)
      {
        // Insert the opposing quote char...
	if (bufptr < bufend)
          *bufptr++ = ch;
      }
      else
      {
        // Start a new quoted string...
        startline = fp->line;
        quote     = ch;
      }
    }
    else if (ch == '(' && !quote)
    {
      empty     = 0;
      quote     = ch;
      startline = fp->line;

      if (bufptr < bufend)
	*bufptr++ = ch;
    }
    else if (ch == ')' && quote == '(')
    {
      quote = 0;

      if (bufptr < bufend)
	*bufptr++ = ch;
    }
    else if (ch == '\\')
    {
      empty = 0;

      if ((ch = fp->get()) == EOF)
        break;

      if (bufptr < bufend)
        *bufptr++ = ch;
    }
    else if (bufptr < bufend)
    {
      empty = 0;

      *bufptr++ = ch;

      if ((ch == '{' || ch == '}') && !quote)
        break;
    }
  }

  if (quote)
  {
    fprintf(stderr, "ppdc: Unterminated string starting with %c on line %d of %s!\n",
            quote, startline, fp->filename);
    return (NULL);
  }

  if (empty)
    return (NULL);
  else
  {
    *bufptr = '\0';
//    puts(buffer);
    return (buffer);
  }
}


//
// 'ppdcSource::get_variable()' - Get a variable definition.
//

ppdcVariable *				// O - Variable
ppdcSource::get_variable(ppdcFile *fp)	// I - File to read
{
  char		name[1024],		// Name
		value[1024];		// Value


  // Get the name and value:
  //
  // #define name value
  if (!get_token(fp, name, sizeof(name)))
    return (NULL);

  if (!get_token(fp, value, sizeof(value)))
    return (NULL);

  // Set the variable...
  return (set_variable(name, value));
}


//
// 'ppdcSource::quotef()' - Write a formatted, quoted string...
//

int					// O - Number bytes on success, -1 on failure
ppdcSource::quotef(cups_file_t *fp,	// I - File to write to
                   const char  *format,	// I - Printf-style format string
		   ...)			// I - Additional args as needed
{
  va_list	ap;			// Pointer to additional arguments
  int		bytes;			// Bytes written
  char		sign,			// Sign of format width
		size,			// Size character (h, l, L)
		type;			// Format type character
  const char	*bufformat;		// Start of format
  int		width,			// Width of field
		prec;			// Number of characters of precision
  char		tformat[100];		// Temporary format string for fprintf()
  char		*s;			// Pointer to string
  int		slen;			// Length of string
  int		i;			// Looping var


  // Range check input...
  if (!fp || !format)
    return (-1);

  // Loop through the format string, formatting as needed...
  va_start(ap, format);

  bytes = 0;

  while (*format)
  {
    if (*format == '%')
    {
      bufformat = format;
      format ++;

      if (*format == '%')
      {
        cupsFilePutChar(fp, *format++);
	bytes ++;
	continue;
      }
      else if (strchr(" -+#\'", *format))
        sign = *format++;
      else
        sign = 0;

      width = 0;
      while (isdigit(*format))
        width = width * 10 + *format++ - '0';

      if (*format == '.')
      {
        format ++;
	prec = 0;

	while (isdigit(*format))
          prec = prec * 10 + *format++ - '0';
      }
      else
        prec = -1;

      if (*format == 'l' && format[1] == 'l')
      {
        size = 'L';
	format += 2;
      }
      else if (*format == 'h' || *format == 'l' || *format == 'L')
        size = *format++;

      if (!*format)
        break;

      type = *format++;

      switch (type)
      {
	case 'E' : // Floating point formats
	case 'G' :
	case 'e' :
	case 'f' :
	case 'g' :
	    if ((format - bufformat + 1) > (int)sizeof(tformat))
	      break;

	    strncpy(tformat, bufformat, format - bufformat);
	    tformat[format - bufformat] = '\0';

	    bytes += cupsFilePrintf(fp, tformat, va_arg(ap, double));
	    break;

        case 'B' : // Integer formats
	case 'X' :
	case 'b' :
        case 'd' :
	case 'i' :
	case 'o' :
	case 'u' :
	case 'x' :
	    if ((format - bufformat + 1) > (int)sizeof(tformat))
	      break;

	    strncpy(tformat, bufformat, format - bufformat);
	    tformat[format - bufformat] = '\0';

	    bytes += cupsFilePrintf(fp, tformat, va_arg(ap, int));
	    break;
	    
	case 'p' : // Pointer value
	    if ((format - bufformat + 1) > (int)sizeof(tformat))
	      break;

	    strncpy(tformat, bufformat, format - bufformat);
	    tformat[format - bufformat] = '\0';

	    bytes += cupsFilePrintf(fp, tformat, va_arg(ap, void *));
	    break;

        case 'c' : // Character or character array
	    if (width <= 1)
	    {
	      bytes ++;
	      cupsFilePutChar(fp, va_arg(ap, int));
	    }
	    else
	    {
	      cupsFileWrite(fp, va_arg(ap, char *), width);
	      bytes += width;
	    }
	    break;

	case 's' : // String
	    if ((s = va_arg(ap, char *)) == NULL)
	      s = (char *)"(nil)";

	    slen = strlen(s);
	    if (slen > width && prec != width)
	      width = slen;

            if (slen > width)
	      slen = width;

            if (sign != '-')
	    {
	      for (i = width - slen; i > 0; i --, bytes ++)
	        cupsFilePutChar(fp, ' ');
	    }

            for (i = slen; i > 0; i --, s ++, bytes ++)
	    {
	      if (*s == '\\' || *s == '\"')
	      {
	        cupsFilePutChar(fp, '\\');
		bytes ++;
	      }

	      cupsFilePutChar(fp, *s);
	    }

            if (sign == '-')
	    {
	      for (i = width - slen; i > 0; i --, bytes ++)
	        cupsFilePutChar(fp, ' ');
	    }
	    break;
      }
    }
    else
    {
      cupsFilePutChar(fp, *format++);
      bytes ++;
    }
  }

  va_end(ap);

  // Return the number of characters written.
  return (bytes);
}


//
// 'ppdcSource::read_file()' - Read a driver source file.
//

void
ppdcSource::read_file(const char *f)	// I - File to read
{
  ppdcFile *fp = new ppdcFile(f);
  scan_file(fp);
  delete fp;
}


//
// 'ppdcSource::scan_file()' - Scan a driver source file.
//

void
ppdcSource::scan_file(ppdcFile   *fp,	// I - File to read
                      ppdcDriver *td)	// I - Driver template
{
  ppdcDriver	*d;			// Current driver
  ppdcGroup	*g,			// Current group
		*general,		// General options group
		*install;		// Installable options group
  ppdcOption	*o;			// Current option
  ppdcChoice	*c;			// Current choice
  char		temp[256],		// Token from file...
		*ptr;			// Pointer into token
  int		isdefault;		// Default option?


  // Initialize things as needed...
  d = new ppdcDriver(td);

  if ((general = d->find_group("General")) == NULL)
  {
    general = new ppdcGroup("General", NULL);
    d->add_group(general);
  }

  if ((install = d->find_group("InstallableOptions")) == NULL)
  {
    install = new ppdcGroup("InstallableOptions", "Installable Options");
    d->add_group(install);
  }

  // Loop until EOF or }
  o = 0;
  g = general;
  while (get_token(fp, temp, sizeof(temp)))
  {
    if (temp[0] == '*')
    {
      // Mark the next choice as the default
      isdefault = 1;

      for (ptr = temp; ptr[1]; ptr ++)
        *ptr = ptr[1];

      *ptr = '\0';
    }
    else
    {
      // Don't mark the next choice as the default
      isdefault = 0;
    }

    if (!strcasecmp(temp, "}"))
    {
      // Close this one out...
      break;
    }
    else if (!strcasecmp(temp, "{"))
    {
      // Open a new child...
      scan_file(fp, d);
    }
    else if (!strcasecmp(temp, "#define"))
    {
      // Get the variable...
      get_variable(fp);
    }
    else if (!strcasecmp(temp, "#include"))
    {
      // #include filename
      char	basedir[1024],		// Base directory
		*baseptr,		// Pointer into directory
		inctemp[1024],		// Initial filename
		incname[1024];		// Include filename
      ppdcFile	*incfile;		// Include file


      // Get the include name...
      if (!get_token(fp, inctemp, sizeof(inctemp)))
      {
        fprintf(stderr, "ppdc: Expected include filename on line %d of %s!\n",
	        fp->line, fp->filename);
        break;
      }

      // Figure out the current directory...
      strlcpy(basedir, fp->filename, sizeof(basedir));

      if ((baseptr = strrchr(basedir, '/')) != NULL)
        *baseptr = '\0';
      else
        strcpy(basedir, ".");

      // Find the include file...
      if (find_include(inctemp, basedir, incname, sizeof(incname)))
      {
	// Open the include file, scan it, and then close it...
	incfile = new ppdcFile(incname);
	scan_file(incfile, d);
	delete incfile;
      }
      else
      {
        // Can't find it!
	fprintf(stderr,
	        "ppdc: Unable to find include file \"%s\" on line %d of %s!\n",
	        inctemp, fp->line, fp->filename);
	break;
      }
    }
    else if (!strcasecmp(temp, "#media"))
    {
      ppdcMediaSize	*m;		// Media size


      // Get a media size...
      m = get_size(fp);
      if (m)
        sizes->add(m);
    }
    else if (!strcasecmp(temp, "#po"))
    {
      ppdcCatalog	*cat;		// Message catalog


      // Get a message catalog...
      cat = get_po(fp);
      if (cat)
        po_files->add(cat);
    }
    else if (!strcasecmp(temp, "Attribute"))
    {
      ppdcAttr	*a;			// Attribute


      // Get an attribute...
      a = get_attr(fp);
      if (a)
        d->add_attr(a);
    }
    else if (!strcasecmp(temp, "Choice"))
    {
      // Get a choice...
      if (!o)
      {
        fprintf(stderr, "ppdc: Choice found on line %d of %s with no Option!\n",
	        fp->line, fp->filename);
        break;
      }

      c = get_choice(fp);
      if (!c)
        break;

      // Add it to the current option...
      o->add_choice(c);

      if (isdefault)
        o->set_defchoice(c);
    }
    else if (!strcasecmp(temp, "ColorDevice"))
    {
      // ColorDevice boolean
      d->color_device = get_boolean(fp);
    }
    else if (!strcasecmp(temp, "ColorModel"))
    {
      // Get the color model
      c = get_color_model(fp);
      if (!c)
        continue;

      // Add the choice to the ColorModel option...
      if ((o = d->find_option("ColorModel")) == NULL)
      {
	// Create the ColorModel option...
	o = new ppdcOption(PPDC_PICKONE, "ColorModel", "Color Mode", PPDC_SECTION_ANY, 10.0f);
	g = general;
	g->add_option(o);
      }

      o->add_choice(c);

      if (isdefault)
	o->set_defchoice(c);

      o = NULL;
    }
    else if (!strcasecmp(temp, "ColorProfile"))
    {
      ppdcProfile	*p;		// Color profile


      // Get the color profile...
      p = get_color_profile(fp);

      if (p)
        d->profiles->add(p);
    }
    else if (!strcasecmp(temp, "Copyright"))
    {
      // Copyright string
      char	copytemp[8192],		// Copyright string
		*copyptr,		// Pointer into string
		*copyend;		// Pointer to end of string


      // Get the copyright string...
      if (!get_token(fp, copytemp, sizeof(temp)))
      {
        fprintf(stderr,
	        "ppdc: Expected string after Copyright on line %d of %s!\n",
	        fp->line, fp->filename);
	break;
      }

      // Break it up into individual lines...
      for (copyptr = copytemp; copyptr; copyptr = copyend)
      {
        if ((copyend = strchr(copyptr, '\n')) != NULL)
	  *copyend++ = '\0';

        d->copyright->add(new ppdcString(copyptr));
      }
    }
    else if (!strcasecmp(temp, "CustomMedia"))
    {
      ppdcMediaSize	*m;		// Media size


      // Get a custom media size...
      m = get_custom_size(fp);
      if (m)
        d->sizes->add(m);

      if (isdefault)
        d->set_default_size(m);
    }
    else if (!strcasecmp(temp, "Cutter"))
    {
      // Cutter boolean
      int	have_cutter;		// Have a paper cutter?


      have_cutter = get_boolean(fp);
      if (have_cutter <= 0)
        continue;

      if ((o = d->find_option("CutMedia")) == NULL)
      {
        o = new ppdcOption(PPDC_BOOLEAN, "CutMedia", "Cut Media", PPDC_SECTION_ANY, 10.0f);

	g = general;
	g->add_option(o);

	c = new ppdcChoice("False", NULL, "<</CutMedia 0>>setpagedevice");
	o->add_choice(c);
	o->set_defchoice(c);

	c = new ppdcChoice("True", NULL, "<</CutMedia 4>>setpagedevice");
	o->add_choice(c);
      }

      o = NULL;
    }
    else if (!strcasecmp(temp, "Darkness"))
    {
      // Get the darkness choice...
      c = get_generic(fp, "Darkness", NULL, "cupsCompression");
      if (!c)
        continue;

      // Add the choice to the cupsDarkness option...
      if ((o = d->find_option("cupsDarkness")) == NULL)
      {
	// Create the cupsDarkness option...
	o = new ppdcOption(PPDC_PICKONE, "cupsDarkness", "Darkness", PPDC_SECTION_ANY, 10.0f);
	g = general;
	g->add_option(o);
      }

      o->add_choice(c);

      if (isdefault)
	o->set_defchoice(c);

      o = NULL;
    }
    else if (!strcasecmp(temp, "DriverType"))
    {
      int	i;			// Looping var


      // DriverType keyword
      if (!get_token(fp, temp, sizeof(temp)))
      {
        fprintf(stderr, "ppdc: Expected driver type keyword following DriverType on line %d of %s!\n",
	        fp->line, fp->filename);
        continue;
      }

      for (i = 0; i < (int)(sizeof(driver_types) / sizeof(driver_types[0])); i ++)
        if (!strcasecmp(temp, driver_types[i]))
	  break;

      if (i < (int)(sizeof(driver_types) / sizeof(driver_types[0])))
        d->type = (ppdcDrvType)i;
      else if (!strcasecmp(temp, "dymo"))
        d->type = PPDC_DRIVER_LABEL;
      else
        fprintf(stderr, "ppdc: Unknown driver type %s on line %d of %s!\n",
	        temp, fp->line, fp->filename);
    }
    else if (!strcasecmp(temp, "Duplex"))
      get_duplex(fp, d);
    else if (!strcasecmp(temp, "Filter"))
    {
      ppdcFilter	*f;		// Filter


      // Get the filter value...
      f = get_filter(fp);
      if (f)
        d->filters->add(f);
    }
    else if (!strcasecmp(temp, "Finishing"))
    {
      // Get the finishing choice...
      c = get_generic(fp, "Finishing", "OutputType", NULL);
      if (!c)
        continue;

      // Add the choice to the cupsFinishing option...
      if ((o = d->find_option("cupsFinishing")) == NULL)
      {
	// Create the cupsFinishing option...
	o = new ppdcOption(PPDC_PICKONE, "cupsFinishing", "Finishing", PPDC_SECTION_ANY, 10.0f);
	g = general;
	g->add_option(o);
      }

      o->add_choice(c);

      if (isdefault)
	o->set_defchoice(c);

      o = NULL;
    }
    else if (!strcasecmp(temp, "Font") ||
             !strcasecmp(temp, "#font"))
    {
      ppdcFont	*f;			// Font


      // Get a font...
      f = get_font(fp);
      if (f)
      {
	if (!strcasecmp(temp, "#font"))
	  base_fonts->add(f);
        else
	  d->add_font(f);

        if (isdefault)
          d->set_default_font(f);
      }
    }
    else if (!strcasecmp(temp, "Group"))
    {
      // Get a group...
      g = get_group(fp, d);
      if (!g)
        break;
    }
    else if (!strcasecmp(temp, "HWMargins"))
    {
      // HWMargins left bottom right top
      d->left_margin   = get_measurement(fp);
      d->bottom_margin = get_measurement(fp);
      d->right_margin  = get_measurement(fp);
      d->top_margin    = get_measurement(fp);
    }
    else if (!strcasecmp(temp, "InputSlot"))
    {
      // Get the input slot choice...
      c = get_generic(fp, "InputSlot", NULL, "MediaPosition");
      if (!c)
        continue;

      // Add the choice to the InputSlot option...
      if ((o = d->find_option("InputSlot")) == NULL)
      {
	// Create the InputSlot option...
	o = new ppdcOption(PPDC_PICKONE, "InputSlot", NULL, PPDC_SECTION_ANY, 10.0f);
	g = general;
	g->add_option(o);
      }

      o->add_choice(c);

      if (isdefault)
	o->set_defchoice(c);

      o = NULL;
    }
    else if (!strcasecmp(temp, "Installable"))
    {
      // Get the installable option...
      o = get_installable(fp);

      // Add it as needed...
      if (o)
      {
        install->add_option(o);
        o = NULL;
      }
    }
    else if (!strcasecmp(temp, "ManualCopies"))
    {
      // ManualCopies boolean
      d->manual_copies = get_boolean(fp);
    }
    else if (!strcasecmp(temp, "Manufacturer"))
    {
      // Manufacturer name
      char	name[256];		// Model name string


      if (!get_token(fp, name, sizeof(name)))
      {
        fprintf(stderr, "ppdc: Expected name after Manufacturer on line %d of %s!\n",
	        fp->line, fp->filename);
	break;
      }

      d->set_manufacturer(name);
    }
    else if (!strcasecmp(temp, "MaxSize"))
    {
      // MaxSize width length
      d->max_width  = get_measurement(fp);
      d->max_length = get_measurement(fp);
    }
    else if (!strcasecmp(temp, "MediaSize"))
    {
      // MediaSize keyword
      char		name[41];	// Media size name
      ppdcMediaSize	*m,		// Matching media size...
			*dm;		// Driver media size...


      if (get_token(fp, name, sizeof(name)) == NULL)
      {
        fprintf(stderr, "ppdc: Expected name after MediaSize on line %d of %s!\n",
	        fp->line, fp->filename);
	break;
      }

      m = find_size(name);

      if (!m)
      {
        fprintf(stderr, "ppdc: Unknown media size \"%s\" on line %d of %s!\n",
	        name, fp->line, fp->filename);
	break;
      }

      // Add this size to the driver...
      dm = new ppdcMediaSize(m->name->value, m->text->value,
                             m->width, m->length, d->left_margin,
			     d->bottom_margin, d->right_margin,
			     d->top_margin);
      d->sizes->add(dm);

      if (isdefault)
        d->set_default_size(dm);
    }
    else if (!strcasecmp(temp, "MediaType"))
    {
      // Get the media type choice...
      c = get_generic(fp, "MediaType", "MediaType", "cupsMediaType");
      if (!c)
        continue;

      // Add the choice to the MediaType option...
      if ((o = d->find_option("MediaType")) == NULL)
      {
	// Create the MediaType option...
	o = new ppdcOption(PPDC_PICKONE, "MediaType", NULL, PPDC_SECTION_ANY, 10.0f);
	g = general;
	g->add_option(o);
      }

      o->add_choice(c);

      if (isdefault)
	o->set_defchoice(c);

      o = NULL;
    }
    else if (!strcasecmp(temp, "MinSize"))
    {
      // MinSize width length
      d->min_width  = get_measurement(fp);
      d->min_length = get_measurement(fp);
    }
    else if (!strcasecmp(temp, "ModelName"))
    {
      // ModelName name
      char	name[256];		// Model name string


      if (!get_token(fp, name, sizeof(name)))
      {
        fprintf(stderr, "ppdc: Expected name after ModelName on line %d of %s!\n",
	        fp->line, fp->filename);
	break;
      }

      d->set_model_name(name);
    }
    else if (!strcasecmp(temp, "ModelNumber"))
    {
      // ModelNumber number
      d->model_number = get_integer(fp);
    }
    else if (!strcasecmp(temp, "Option"))
    {
      // Get an option...
      o = get_option(fp, d, g);
      if (!o)
        break;
    }
    else if (!strcasecmp(temp, "PCFileName"))
    {
      // PCFileName name
      char	name[256];		// Model name string


      if (!get_token(fp, name, sizeof(name)))
      {
        fprintf(stderr, "ppdc: Expected name after PCFileName on line %d of %s!\n",
	        fp->line, fp->filename);
	break;
      }

      d->set_pc_file_name(name);
    }
    else if (!strcasecmp(temp, "Resolution"))
    {
      // Get the resolution choice...
      c = get_resolution(fp);
      if (!c)
        continue;

      // Add the choice to the Resolution option...
      if ((o = d->find_option("Resolution")) == NULL)
      {
	// Create the Resolution option...
	o = new ppdcOption(PPDC_PICKONE, "Resolution", NULL, PPDC_SECTION_ANY, 10.0f);
	g = general;
	g->add_option(o);
      }

      o->add_choice(c);

      if (isdefault)
	o->set_defchoice(c);

      o = NULL;
    }
    else if (!strcasecmp(temp, "SimpleColorProfile"))
    {
      ppdcProfile	*p;		// Color profile


      // Get the color profile...
      p = get_simple_profile(fp);

      if (p)
        d->profiles->add(p);
    }
    else if (!strcasecmp(temp, "Throughput"))
    {
      // Throughput number
      d->throughput = get_integer(fp);
    }
    else if (!strcasecmp(temp, "UIConstraints"))
    {
      ppdcConstraint	*con;		// Constraint


      con = get_constraint(fp);

      if (con)
        d->constraints->add(con);
    }
    else if (!strcasecmp(temp, "VariablePaperSize"))
    {
      // VariablePaperSize boolean
      d->variable_paper_size = get_boolean(fp);
    }
    else if (!strcasecmp(temp, "Version"))
    {
      // Version string
      char	name[256];		// Model name string


      if (!get_token(fp, name, sizeof(name)))
      {
        fprintf(stderr, "ppdc: Expected string after Version on line %d of %s!\n",
	        fp->line, fp->filename);
	break;
      }

      d->set_version(name);
    }
    else
    {
      fprintf(stderr, "ppdc: Unknown token \"%s\" seen on line %d of %s!\n",
              temp, fp->line, fp->filename);
      break;
    }
  }

  // Done processing this block, is there anything to save?
  if (!d->pc_file_name || !d->model_name || !d->manufacturer || !d->version ||
      !d->sizes->count)
  {
    // Nothing to save...
    d->release();
  }
  else
  {
    // Got a driver, save it...
    drivers->add(d);
  }
}


//
// 'ppdcSource::set_variable()' - Set a variable.
//

ppdcVariable *				// O - Variable
ppdcSource::set_variable(
    const char *name,			// I - Name
    const char *value)			// I - Value
{
  ppdcVariable	*v;			// Variable


  // See if the variable exists already...
  v = find_variable(name);
  if (v)
  {
    // Change the variable value...
    v->set_value(value);
  }
  else
  {
    // Create a new variable and add it...
    v = new ppdcVariable(name, value);
    vars->add(v);
  }

  return (v);
}


//
// 'ppdcSource::write_file()' - Write the current source data to a file.
//

int					// O - 0 on success, -1 on error
ppdcSource::write_file(const char *f)	// I - File to write
{
  cups_file_t	*fp;			// Output file
  char		bckname[1024];		// Backup file
  ppdcDriver	*d;			// Current driver
  ppdcString	*st;			// Current string
  ppdcAttr	*a;			// Current attribute
  ppdcConstraint *co;			// Current constraint
  ppdcFilter	*fi;			// Current filter
  ppdcFont	*fo;			// Current font
  ppdcGroup	*g;			// Current group
  ppdcOption	*o;			// Current option
  ppdcChoice	*ch;			// Current choice
  ppdcProfile	*p;			// Current color profile
  ppdcMediaSize	*si;			// Current media size
  float		left,			// Current left margin
		bottom,			// Current bottom margin
		right,			// Current right margin
		top;			// Current top margin
  int		dtused[PPDC_DRIVER_MAX];// Driver type usage...


  // Rename the current file, if any, to .bck...
  snprintf(bckname, sizeof(bckname), "%s.bck", f);
  rename(f, bckname);

  // Open the output file...
  fp = cupsFileOpen(f, "w");

  if (!fp)
  {
    // Can't create file; restore backup and return...
    rename(bckname, f);
    return (-1);
  }

  cupsFilePuts(fp, "// CUPS PPD Compiler " DDK_VERSION "\n\n");

  // Include standard files...
  cupsFilePuts(fp, "// Include necessary files...\n");
  cupsFilePuts(fp, "#include <font.defs>\n");
  cupsFilePuts(fp, "#include <media.defs>\n");

  memset(dtused, 0, sizeof(dtused));

  for (d = (ppdcDriver *)drivers->first(); d; d = (ppdcDriver *)drivers->next())
    if (d->type > PPDC_DRIVER_PS && !dtused[d->type])
    {
      cupsFilePrintf(fp, "#include <%s.h>\n", driver_types[d->type]);
      dtused[d->type] = 1;
    }

  // Output each driver...
  for (d = (ppdcDriver *)drivers->first(); d; d = (ppdcDriver *)drivers->next())
  {
    // Start the driver...
    cupsFilePrintf(fp, "\n// %s %s\n", d->manufacturer->value, d->model_name->value);
    cupsFilePuts(fp, "{\n");

    // Write the copyright stings...
    for (st = (ppdcString *)d->copyright->first();
         st;
	 st = (ppdcString *)d->copyright->next())
      quotef(fp, "  Copyright \"%s\"\n", st->value);

    // Write other strings and values...
    if (d->manufacturer->value)
      quotef(fp, "  Manufacturer \"%s\"\n", d->manufacturer->value);
    if (d->model_name->value)
      quotef(fp, "  ModelName \"%s\"\n", d->model_name->value);
    if (d->pc_file_name->value)
      quotef(fp, "  PCFileName \"%s\"\n", d->pc_file_name->value);
    if (d->version->value)
      quotef(fp, "  Version \"%s\"\n", d->version->value);

    cupsFilePrintf(fp, "  DriverType %s\n", driver_types[d->type]);

    if (d->model_number)
    {
      switch (d->type)
      {
        case PPDC_DRIVER_ESCP :
	    cupsFilePuts(fp, "  ModelNumber (");

	    if (d->model_number & ESCP_DOTMATRIX)
	      cupsFilePuts(fp, " $ESCP_DOTMATRIX");
	    if (d->model_number & ESCP_MICROWEAVE)
	      cupsFilePuts(fp, " $ESCP_MICROWEAVE");
	    if (d->model_number & ESCP_STAGGER)
	      cupsFilePuts(fp, " $ESCP_STAGGER");
	    if (d->model_number & ESCP_ESCK)
	      cupsFilePuts(fp, " $ESCP_ESCK");
	    if (d->model_number & ESCP_EXT_UNITS)
	      cupsFilePuts(fp, " $ESCP_EXT_UNITS");
	    if (d->model_number & ESCP_EXT_MARGINS)
	      cupsFilePuts(fp, " $ESCP_EXT_MARGINS");
	    if (d->model_number & ESCP_USB)
	      cupsFilePuts(fp, " $ESCP_USB");
	    if (d->model_number & ESCP_PAGE_SIZE)
	      cupsFilePuts(fp, " $ESCP_PAGE_SIZE");
	    if (d->model_number & ESCP_RASTER_ESCI)
	      cupsFilePuts(fp, " $ESCP_RASTER_ESCI");
	    if (d->model_number & ESCP_REMOTE)
	      cupsFilePuts(fp, " $ESCP_REMOTE");

	    cupsFilePuts(fp, ")\n");
	    break;

	case PPDC_DRIVER_PCL :
	    cupsFilePuts(fp, "  ModelNumber (");

	    if (d->model_number & PCL_PAPER_SIZE)
	      cupsFilePuts(fp, " $PCL_PAPER_SIZE");
	    if (d->model_number & PCL_INKJET)
	      cupsFilePuts(fp, " $PCL_INKJET");
	    if (d->model_number & PCL_RASTER_END_COLOR)
	      cupsFilePuts(fp, " $PCL_RASTER_END_COLOR");
	    if (d->model_number & PCL_RASTER_CID)
	      cupsFilePuts(fp, " $PCL_RASTER_CID");
	    if (d->model_number & PCL_RASTER_CRD)
	      cupsFilePuts(fp, " $PCL_RASTER_CRD");
	    if (d->model_number & PCL_RASTER_SIMPLE)
	      cupsFilePuts(fp, " $PCL_RASTER_SIMPLE");
	    if (d->model_number & PCL_RASTER_RGB24)
	      cupsFilePuts(fp, " $PCL_RASTER_RGB24");
	    if (d->model_number & PCL_PJL)
	      cupsFilePuts(fp, " $PCL_PJL");
	    if (d->model_number & PCL_PJL_PAPERWIDTH)
	      cupsFilePuts(fp, " $PCL_PJL_PAPERWIDTH");
	    if (d->model_number & PCL_PJL_HPGL2)
	      cupsFilePuts(fp, " $PCL_PJL_HPGL2");
	    if (d->model_number & PCL_PJL_PCL3GUI)
	      cupsFilePuts(fp, " $PCL_PJL_PCL3GUI");
	    if (d->model_number & PCL_PJL_RESOLUTION)
	      cupsFilePuts(fp, " $PCL_PJL_RESOLUTION");

	    cupsFilePuts(fp, ")\n");
	    break;

	case PPDC_DRIVER_LABEL :
	    cupsFilePuts(fp, "  ModelNumber ");

	    switch (d->model_number)
	    {
	      case DYMO_3x0 :
		  cupsFilePuts(fp, "$DYMO_3x0\n");
		  break;

	      case ZEBRA_EPL_LINE :
		  cupsFilePuts(fp, "$ZEBRA_EPL_LINE\n");
		  break;

	      case ZEBRA_EPL_PAGE :
		  cupsFilePuts(fp, "$ZEBRA_EPL_PAGE\n");
		  break;

	      case ZEBRA_ZPL :
		  cupsFilePuts(fp, "$ZEBRA_ZPL\n");
		  break;

	      case ZEBRA_CPCL :
		  cupsFilePuts(fp, "$ZEBRA_CPCL\n");
		  break;

	      case INTELLITECH_PCL :
		  cupsFilePuts(fp, "$INTELLITECH_PCL\n");
		  break;

	      default :
		  cupsFilePrintf(fp, "%d\n", d->model_number);
		  break;
	    }
	    break;

	case PPDC_DRIVER_EPSON :
	    cupsFilePuts(fp, "  ModelNumber ");

	    switch (d->model_number)
	    {
	      case EPSON_9PIN :
		  cupsFilePuts(fp, "$EPSON_9PIN\n");
		  break;

	      case EPSON_24PIN :
		  cupsFilePuts(fp, "$EPSON_24PIN\n");
		  break;

	      case EPSON_COLOR :
		  cupsFilePuts(fp, "$EPSON_COLOR\n");
		  break;

	      case EPSON_PHOTO :
		  cupsFilePuts(fp, "$EPSON_PHOTO\n");
		  break;

	      case EPSON_ICOLOR :
		  cupsFilePuts(fp, "$EPSON_ICOLOR\n");
		  break;

	      case EPSON_IPHOTO :
		  cupsFilePuts(fp, "$EPSON_IPHOTO\n");
		  break;

	      default :
		  cupsFilePrintf(fp, "%d\n", d->model_number);
	          break;
	    }
	    break;

	case PPDC_DRIVER_HP :
	    cupsFilePuts(fp, "  ModelNumber ");
	    switch (d->model_number)
	    {
	      case HP_LASERJET :
	          cupsFilePuts(fp, "$HP_LASERJET\n");
		  break;

	      case HP_DESKJET :
	          cupsFilePuts(fp, "$HP_DESKJET\n");
		  break;

	      case HP_DESKJET2 :
	          cupsFilePuts(fp, "$HP_DESKJET2\n");
		  break;

	      default :
		  cupsFilePrintf(fp, "%d\n", d->model_number);
		  break;
	    }

	    cupsFilePuts(fp, ")\n");
	    break;

        default :
            cupsFilePrintf(fp, "  ModelNumber %d\n", d->model_number);
	    break;
      }
    }

    if (d->manual_copies)
      cupsFilePuts(fp, "  ManualCopies Yes\n");

    if (d->color_device)
      cupsFilePuts(fp, "  ColorDevice Yes\n");

    if (d->throughput)
      cupsFilePrintf(fp, "  Throughput %d\n", d->throughput);

    // Output all of the attributes...
    for (a = (ppdcAttr *)d->attrs->first();
         a;
	 a = (ppdcAttr *)d->attrs->next())
      if (a->text->value && a->text->value[0])
	quotef(fp, "  Attribute \"%s\" \"%s/%s\" \"%s\"\n",
               a->name->value, a->selector->value ? a->selector->value : "",
	       a->text->value, a->value->value ? a->value->value : "");
      else
	quotef(fp, "  Attribute \"%s\" \"%s\" \"%s\"\n",
               a->name->value, a->selector->value ? a->selector->value : "",
	       a->value->value ? a->value->value : "");

    // Output all of the constraints...
    for (co = (ppdcConstraint *)d->constraints->first();
         co;
	 co = (ppdcConstraint *)d->constraints->next())
    {
      if (co->option1->value[0] == '*')
	cupsFilePrintf(fp, "  UIConstraints \"%s %s", co->option1->value,
		       co->choice1->value ? co->choice1->value : "");
      else
	cupsFilePrintf(fp, "  UIConstraints \"*%s %s", co->option1->value,
		       co->choice1->value ? co->choice1->value : "");

      if (co->option2->value[0] == '*')
	cupsFilePrintf(fp, " %s %s\"\n", co->option2->value,
		       co->choice2->value ? co->choice2->value : "");
      else
	cupsFilePrintf(fp, " *%s %s\"\n", co->option2->value,
		       co->choice2->value ? co->choice2->value : "");
    }

    // Output all of the filters...
    for (fi = (ppdcFilter *)d->filters->first();
         fi;
	 fi = (ppdcFilter *)d->filters->next())
      cupsFilePrintf(fp, "  Filter \"%s %d %s\"\n",
                     fi->mime_type->value, fi->cost, fi->program->value);

    // Output all of the fonts...
    for (fo = (ppdcFont *)d->fonts->first();
         fo;
	 fo = (ppdcFont *)d->fonts->next())
      if (!strcmp(fo->name->value, "*"))
        cupsFilePuts(fp, "  Font *\n");
      else
	cupsFilePrintf(fp, "  Font \"%s\" \"%s\" \"%s\" \"%s\" %s\n",
        	       fo->name->value, fo->encoding->value,
		       fo->version->value, fo->charset->value,
		       fo->status == PPDC_FONT_ROM ? "ROM" : "Disk");

    // Output all options...
    for (g = (ppdcGroup *)d->groups->first();
         g;
	 g = (ppdcGroup *)d->groups->next())
    {
      if (g->options->count == 0)
        continue;

      if (g->text->value && g->text->value[0])
        quotef(fp, "  Group \"%s/%s\"\n", g->name->value, g->text->value);
      else
        cupsFilePrintf(fp, "  Group \"%s\"\n", g->name->value);

      for (o = (ppdcOption *)g->options->first();
           o;
	   o = (ppdcOption *)g->options->next())
      {
        if (o->choices->count == 0)
	  continue;

	if (o->text->value && o->text->value[0])
          quotef(fp, "    Option \"%s/%s\"", o->name->value, o->text->value);
	else
          cupsFilePrintf(fp, "    Option \"%s\"", o->name->value);

        cupsFilePrintf(fp, " %s %s %.1f\n",
		       o->type == PPDC_BOOLEAN ? "Boolean" :
			   o->type == PPDC_PICKONE ? "PickOne" : "PickMany",
		       o->section == PPDC_SECTION_ANY ? "AnySetup" :
			   o->section == PPDC_SECTION_DOCUMENT ? "DocumentSetup" :
			   o->section == PPDC_SECTION_EXIT ? "ExitServer" :
			   o->section == PPDC_SECTION_JCL ? "JCLSetup" :
			   o->section == PPDC_SECTION_PAGE ? "PageSetup" :
			   "Prolog",
		       o->order);

        for (ch = (ppdcChoice *)o->choices->first();
	     ch;
	     ch = (ppdcChoice *)o->choices->next())
	{
	  if (ch->text->value && ch->text->value[0])
            quotef(fp, "      %sChoice \"%s/%s\" \"%s\"\n",
	    	   o->defchoice == ch->name ? "*" : "",
                   ch->name->value, ch->text->value,
		   ch->code->value ? ch->code->value : "");
	  else
            quotef(fp, "      %sChoice \"%s\" \"%s\"\n",
	           o->defchoice == ch->name ? "*" : "",
		   ch->name->value,
		   ch->code->value ? ch->code->value : "");
	}
      }
    }

    // Output all of the color profiles...
    for (p = (ppdcProfile *)d->profiles->first();
         p;
	 p = (ppdcProfile *)d->profiles->next())
      cupsFilePrintf(fp, "  ColorProfile \"%s/%s\" %.3f %.3f "
                	 "%.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f\n",
        	     p->resolution->value, p->media_type->value,
		     p->density, p->gamma,
		     p->profile[0], p->profile[1], p->profile[2],
		     p->profile[3], p->profile[4], p->profile[5],
		     p->profile[6], p->profile[7], p->profile[8]);

    // Output all of the media sizes...
    left   = 0.0;
    bottom = 0.0;
    right  = 0.0;
    top    = 0.0;

    for (si = (ppdcMediaSize *)d->sizes->first();
         si;
	 si = (ppdcMediaSize *)d->sizes->next())
      if (si->size_code->value && si->region_code->value)
      {
        // Output a custom media size...
	quotef(fp, "  %sCustomMedia \"%s/%s\" %.2f %.2f %.2f %.2f %.2f %.2f \"%s\" \"%s\"\n",
	       si->name == d->default_size ? "*" : "", si->name->value,
	       si->text->value, si->width, si->length, si->left, si->bottom,
	       si->right, si->top, si->size_code->value,
	       si->region_code->value);
      }
      else
      {
        // Output a standard media size...
	if (fabs(left - si->left) > 0.1 ||
            fabs(bottom - si->bottom) > 0.1 ||
            fabs(right - si->right) > 0.1 ||
            fabs(top - si->top) > 0.1)
	{
          cupsFilePrintf(fp, "  HWMargins %.2f %.2f %.2f %.2f\n",
	        	 si->left, si->bottom, si->right, si->top);

          left   = si->left;
	  bottom = si->bottom;
	  right  = si->right;
	  top    = si->top;
	}

	cupsFilePrintf(fp, "  %sMediaSize %s\n",
	               si->name == d->default_size ? "*" : "",
        	       si->name->value);
      }

    if (d->variable_paper_size)
    {
      cupsFilePuts(fp, "  VariablePaperSize Yes\n");

      if (fabs(left - d->left_margin) > 0.1 ||
          fabs(bottom - d->bottom_margin) > 0.1 ||
          fabs(right - d->right_margin) > 0.1 ||
          fabs(top - d->top_margin) > 0.1)
      {
        cupsFilePrintf(fp, "  HWMargins %.2f %.2f %.2f %.2f\n",
	               d->left_margin, d->bottom_margin, d->right_margin,
		       d->top_margin);
      }

      cupsFilePrintf(fp, "  MinSize %.2f %.2f\n", d->min_width, d->min_length);
      cupsFilePrintf(fp, "  MaxSize %.2f %.2f\n", d->max_width, d->max_length);
    }

    // End the driver...
    cupsFilePuts(fp, "}\n");
  }

  // Close the file and return...
  cupsFileClose(fp);

  return (0);
}


//
// End of "$Id: ppdc-source.cxx 303 2007-02-14 21:53:07Z mike $".
//
