/*----------------------------------------------------------------------------*/
/**
   @file    sysconf.c
   @author  Nicolas Devillard
   @date    February 2001
   @version	$Revision: 1.33 $
   @brief   configure-like in C.
*/
/*----------------------------------------------------------------------------*/

/*
	$Id: sysconf.c,v 1.33 2005/02/24 15:59:59 yjung Exp $
	$Author: yjung $
	$Date: 2005/02/24 15:59:59 $
	$Revision: 1.33 $
 */

/*---------------------------------------------------------------------------
   								Includes
 ---------------------------------------------------------------------------*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <ctype.h>
#include <sys/utsname.h>
#include <sys/types.h>
#include <sys/stat.h>

#define MAXSTRSZ    512

#define MACROS_FILE		"config.make"
#define HEADER_FILE 	"config.h"
#define PREFIX_DEFAULT	"/usr/local"

#define COMPILER_AUTO	0
#define COMPILER_CC		1
#define COMPILER_GCC	2

#define XMEMDEBUG       " -DXMEMORY_DEBUG=1"

/* Global variable */

struct
{
  /* List of supported OS's */
  enum
  {
    os_linux,
    os_cygwin,
    os_hp08,
    os_hp09,
    os_hp10,
    os_hp11,
    os_solaris,
    os_irix,
    os_aix,
    os_dec,
    os_bsd,
    os_darwin
  } local_os;
  char sysname[MAXSTRSZ];
  char release[MAXSTRSZ];
  char machine[MAXSTRSZ];

  /* Bits per byte on this machine */
  int bits_per_byte;
  /* Big endian machine? */
  int big_endian;

  /* x86 architecture? */
  int arch_x86;
  /* CPU type: 386, 486, 586, 686 */
  int cpu_x86;

  /* Compile with debug options on */
  int debug_compile;
  /* Compile with warnings on */
  int lint_compile;
  /* Compiler type: native cc or gcc */
  int compiler;
  /* Compile with threads */
  int with_threads;
  /* Number of detected CPUs */
  int ncpus;
  /* Compile static library */
  int lib_static;
  /* Compile dynamic library */
  int lib_dynamic;
  /* Prefix for installation */
  char *prefix;
  /* With or without xmemory handling */
  int xmemory_mode;
  /* Maximum number of pointers allowed */
  int max_ptrs;
} config;


/*
 * Check that all files present in the list of names are
 * somewhere present in the list of paths.
 */
int
config_findfiles (paths, names)
     char **paths;
     char **names;
{
  struct stat sta;
  char spath[MAXSTRSZ];
  int i, j;
  int nfound;

  /* Loop on all paths */
  i = 0;
  while (paths[i])
    {
      printf ("searching in %s...\n", paths[i]);
      /* Loop on all file names */
      j = 0;
      nfound = 0;
      while (names[j])
	{
	  sprintf (spath, "%s/%s", paths[i], names[j]);
	  if (stat (spath, &sta) == 0)
	    {
	      nfound++;
	    }
	  j++;
	}
      if (j == nfound)
	{
	  printf ("found in %s\n", paths[i]);
	  return i;
	}
      i++;
    }
  return -1;
}


/* Guess local OS name and potentially release number */
void
detect_config ()
{
  struct utsname name;
  int i;
  unsigned char c;
  int x;

  if (config.sysname[0] == 0)
    {
      printf ("detecting local OS............. ");
      /* Get machine OS type and release number */
      if (uname (&name) == -1)
	{
	  printf ("error calling uname\n");
	  exit (-1);
	}
      printf ("%s %s", name.sysname, name.release);
      strcpy (config.sysname, name.sysname);
      strcpy (config.release, name.release);
      strcpy (config.machine, name.machine);
    }
  else
    {
      printf ("forcing config for OS.......... %s %s",
	      config.sysname, config.release);
    }

  /* Lowercase everything */
  i = 0;
  while (config.sysname[i] != 0)
    {
      config.sysname[i] = tolower (config.sysname[i]);
      i++;
    }
  i = 0;
  while (config.release[i] != 0)
    {
      config.release[i] = tolower (config.release[i]);
      i++;
    }

  /* Switch on OS type and release number */
  if (strstr (config.sysname, "linux") != NULL)
    {
      config.local_os = os_linux;
      printf (" - linux\n");
    }
  else if (strstr (config.sysname, "cygwin") != NULL)
    {
      config.local_os = os_cygwin;
      printf (" - cygwin\n");
    }
  else if (strstr (config.sysname, "hp") != NULL)
    {
      if (strstr (config.release, "8.") != NULL)
	{
	  config.local_os = os_hp08;
	  printf (" - hpux_08\n");
	}
      else if (strstr (config.release, "9.") != NULL)
	{
	  config.local_os = os_hp09;
	  printf (" - hpux_09\n");
	}
      else if (strstr (config.release, "10.") != NULL)
	{
	  config.local_os = os_hp10;
	  printf (" - hpux_10\n");
	}
      else if (strstr (config.release, "11.") != NULL)
	{
	  config.local_os = os_hp11;
	  printf (" - hpux_11\n");
	}
    }
  else if ((strstr (config.sysname, "sun") != NULL) ||
	   (strstr (config.sysname, "solaris") != NULL))
    {
      config.local_os = os_solaris;
      printf (" - solaris\n");
    }
  else if (strstr (config.sysname, "irix") != NULL)
    {
      config.local_os = os_irix;
      printf (" - irix\n");
    }
  else if (strstr (config.sysname, "aix") != NULL)
    {
      config.local_os = os_aix;
      printf (" - aix\n");
    }
  else if (strstr (config.sysname, "osf") != NULL)
    {
      config.local_os = os_dec;
      printf (" - osf/1\n");
    }
  else if (strstr (config.sysname, "bsd") != NULL)
    {
      config.local_os = os_bsd;
      printf (" - %s\n", config.sysname);
    }
  else if (strstr (config.sysname, "darwin") != NULL)
    {
      config.local_os = os_darwin;
      printf (" - %s\n", config.sysname);
    }
  else
    {
      printf ("cannot identify your OS\n");
      printf ("Use the option --os=NAME to force an OS type\n");
      exit (-1);
    }

  /* Find out about x86 architectures */
  if ((config.machine[0] == 'i') && (strstr (config.machine, "86") != NULL))
    {
      config.arch_x86 = 1;
      config.cpu_x86 = atoi (config.machine + 1);
      printf ("detected x86 architecture...... %d\n", config.cpu_x86);
    }
  else
    {
      config.arch_x86 = 0;
      printf ("detected x86 architecture...... no\n");
    }

  /* Compute number of bits in a byte on this machine */
  printf ("computing bits per byte........ ");
  c = 1;
  i = 0;
  while (c)
    {
      c <<= 1;
      i++;
    }
  config.bits_per_byte = i;
  printf ("%d\n", i);

  /* Detect endian-ness */
  printf ("detecting byte-order........... ");
  x = 1;
  x = (*(char *) &x);

  config.big_endian = !x;
  if (config.big_endian)
    {
      printf ("big endian (motorola)\n");
    }
  else
    {
      printf ("little endian (intel)\n");
    }

  return;
}

/* Locate a program in the user's PATH */
int
locate_program (pname)
     char *pname;
{
  int i, j, lg;
  char *path;
  char buf[MAXSTRSZ];

  path = getenv ("PATH");
  if (path != NULL)
    {
      for (i = 0; path[i];)
	{
	  for (j = i; (path[j]) && (path[j] != ':'); j++);
	  lg = j - i;
	  strncpy (buf, path + i, lg);
	  if (lg == 0)
	    buf[lg++] = '.';
	  buf[lg++] = '/';
	  strcpy (buf + lg, pname);
	  if (access (buf, X_OK) == 0)
	    {
	      printf ("using [%s]\n", buf);
	      return 1;
	    }
	  buf[0] = 0;
	  i = j;
	  if (path[i] == ':')
	    i++;
	}
    }
  else
    {
      /* No PATH variable: abort with an error */
      return -1;
    }
  /* If the buffer is still empty, the command was not found */
  if (buf[0] == 0)
    return 0;
  /* Otherwise Ok */
  return 1;
}

void
make_config_make ()
{
  FILE *sysc;

  /* Set compiler name */
  printf ("looking for a C compiler....... ");
  if (getenv ("PATH") == NULL)
    {
      printf ("error: undefined PATH variable, cannot locate a compiler\n");
      exit (-1);
    }

  /* Open output sysconf */
  if ((sysc = fopen (MACROS_FILE, "w")) == NULL)
    {
      printf ("cannot create %s: aborting compilation", MACROS_FILE);
      exit (-1);
    }

  /* In automatic mode, find out which compiler to use */
  if (config.compiler == COMPILER_AUTO)
    {
      switch (config.local_os)
	{

	  /* Use gcc under Linux, BSD, Cygwin & IRIX */
	case os_linux:
	case os_cygwin:
	case os_bsd:
	case os_irix:
	  config.compiler = COMPILER_GCC;
	  break;

	  /* All others use 'cc' (default) */
	default:
	  config.compiler = COMPILER_CC;
	  break;
	}
    }


  /* Make sure the compiler can be found */
  if (config.compiler == COMPILER_CC)
    {
      if (locate_program ("cc") != 1)
	{
	  printf ("cannot locate cc\n");
	  /* Try out with gcc */
	  config.compiler = COMPILER_GCC;
	}
    }
  if (config.compiler == COMPILER_GCC)
    {
      if (locate_program ("gcc") != 1)
	{
	  printf ("cannot locate gcc\n");
	  exit (-1);
	}
    }


  /* Set compiler name and cflags */
  switch (config.compiler)
    {

    case COMPILER_CC:
      fprintf (sysc, "CC      = cc\n");
      fprintf (sysc, "CFLAGS  = ");
      if (config.xmemory_mode == 0)
	{
	  fprintf (sysc, "-DXMEMORY_MODE=%d ", config.xmemory_mode);
	  fprintf (sysc, "-DXMEMORY_MAXPTRS=1 ");
	}
      else if (config.xmemory_mode == 1)
	{
	  fprintf (sysc, "-DXMEMORY_MODE=%d ", config.xmemory_mode);
	  fprintf (sysc, "-DXMEMORY_MAXPTRS=1 ");
	}
      else if (config.xmemory_mode == 2)
	{
	  fprintf (sysc, "-DXMEMORY_MODE=%d ", config.xmemory_mode);
	  if (config.max_ptrs > 0)
	    {
	      fprintf (sysc, "-DXMEMORY_MAXPTRS=%d ", config.max_ptrs);
	    }
	}
      else if (config.xmemory_mode < 0)
	{
	  if (config.max_ptrs > 0)
	    {
	      fprintf (sysc, "-DXMEMORY_MAXPTRS=%d ", config.max_ptrs);
	    }
	}
      switch (config.local_os)
	{
	case os_hp08:
	case os_hp09:
	case os_hp10:
	  if (config.with_threads)
	    {
	      printf ("threads not supported on this platform\n");
	    }
	  if (config.debug_compile)
	    {
	      fprintf (sysc, "-Ae -g%s\n", XMEMDEBUG);
	    }
	  else
	    {
	      fprintf (sysc, "-Ae -O\n");
	    }
	  fprintf (sysc, "RELOC   = +z\n");
	  fprintf (sysc, "SHARED  = -b\n");
	  break;

	case os_hp11:
	  if (config.with_threads)
	    {
	      fprintf (sysc, "-lpthread ");
	    }
	  if (config.debug_compile)
	    {
	      fprintf (sysc, "-g%s\n", XMEMDEBUG);
	    }
	  else
	    {
	      fprintf (sysc, "-O\n");
	    }
	  fprintf (sysc, "RELOC   = +z\n");
	  fprintf (sysc, "SHARED  = -b\n");
	  break;

	case os_solaris:
	  if (config.with_threads)
	    {
	      fprintf (sysc, "-mt -lpthread ");
	    }
	  if (config.debug_compile)
	    {
	      fprintf (sysc, "-g%s\n", XMEMDEBUG);
	    }
	  else
	    {
	      fprintf (sysc, "-xO5\n");
	    }
	  fprintf (sysc, "RELOC   = -G\n");
	  fprintf (sysc, "SHARED  = -G\n");
	  break;

	case os_dec:
	  if (config.with_threads)
	    {
	      printf ("threads not supported on this platform\n");
	    }
	  if (config.debug_compile)
	    {
	      fprintf (sysc, "-g%s\n", XMEMDEBUG);
	    }
	  else
	    {
	      fprintf (sysc, "-O\n");
	    }
	  fprintf (sysc, "RELOC   =\n");
	  fprintf (sysc, "SHARED  = -shared -expect_unresolved \"*\"\n");
	  break;

	case os_irix:
	case os_aix:
	case os_bsd:
	  if (config.with_threads)
	    {
	      printf ("threads not supported on this platform\n");
	    }
	  if (config.debug_compile)
	    {
	      fprintf (sysc, "-g%s\n", XMEMDEBUG);
	    }
	  else
	    {
	      fprintf (sysc, "-O\n");
	    }
	  fprintf (sysc, "RELOC   =\n");
	  fprintf (sysc, "SHARED  =\n");
	  break;

	case os_cygwin:
	case os_linux:
	  /* cc with Linux? Why not! */
	  if (config.with_threads)
	    {
	      fprintf (sysc, "-pthread ");
	    }
	  if (config.debug_compile)
	    {
	      fprintf (sysc, "-g%s\n", XMEMDEBUG);
	    }
	  else
	    {
	      fprintf (sysc, "-O3\n");
	    }
	  fprintf (sysc, "RELOC   = -fpic\n");
	  fprintf (sysc, "SHARED  = -shared\n");
	  break;

	case os_darwin:
	  /* Darwin uses gcc but calls it 'cc' */
	  if (config.with_threads)
	    {
	      fprintf (sysc, "-pthread ");
	    }
	  if (config.debug_compile)
	    {
	      fprintf (sysc, "-g%s\n", XMEMDEBUG);
	    }
	  else
	    {
	      fprintf (sysc, "-O3\n");
	    }
	  fprintf (sysc, "RELOC   = -fPIC\n");
	  fprintf (sysc, "SHARED  = -shared\n");
	  break;


	default:
	  printf ("error: unsupported OS\n");
	  exit (-1);
	}
      break;

    case COMPILER_GCC:
      fprintf (sysc, "CC      = gcc\n");
      fprintf (sysc, "CFLAGS  = ");

      if (config.xmemory_mode == 0)
	{
	  fprintf (sysc, "-DXMEMORY_MODE=%d ", config.xmemory_mode);
	  fprintf (sysc, "-DXMEMORY_MAXPTRS=1 ");
	}
      else if (config.xmemory_mode == 1)
	{
	  fprintf (sysc, "-DXMEMORY_MODE=%d ", config.xmemory_mode);
	  fprintf (sysc, "-DXMEMORY_MAXPTRS=1 ");
	}
      else if (config.xmemory_mode == 2)
	{
	  fprintf (sysc, "-DXMEMORY_MODE=%d ", config.xmemory_mode);
	  if (config.max_ptrs > 0)
	    {
	      fprintf (sysc, "-DXMEMORY_MAXPTRS=%d ", config.max_ptrs);
	    }
	}
      else if (config.xmemory_mode < 0)
	{
	  if (config.max_ptrs > 0)
	    {
	      fprintf (sysc, "-DXMEMORY_MAXPTRS=%d ", config.max_ptrs);
	    }
	}
      if (config.with_threads)
	{
	  fprintf (sysc, "-pthread ");
	}
      if (config.lint_compile)
	{
	  fprintf (sysc, " -Wall -pedantic ");
	}
      if (config.debug_compile)
	{
	  fprintf (sysc, "-g%s\n", XMEMDEBUG);
	}
      else
	{
	  fprintf (sysc, "-O3\n");
	}
      if (config.local_os != os_cygwin)
	fprintf (sysc, "RELOC   = -fPIC -DPIC\n");
      fprintf (sysc, "SHARED  = -shared\n");
      break;

    default:
      printf ("error in compiler option switch: aborting\n");
      exit (-1);
      break;
    }

  if (config.debug_compile)
    {
      printf ("                                in debug mode\n");
    }
  else
    {
      printf ("                                all optimizations on\n");
    }
  if (config.lint_compile)
    {
      printf ("                                with all warnings\n");
    }

  /* LFLAGS */
  fprintf (sysc, "LFLAGS  = ");
  switch (config.local_os)
    {

    case os_hp10:
    case os_hp11:
      fprintf (sysc, "-Wl,+vnocompatwarnings ");
      break;

    default:
      break;
    }
  fprintf (sysc, "\n");

  /* DYNSUF */
  switch (config.local_os)
    {
    case os_hp08:
    case os_hp09:
    case os_hp10:
    case os_hp11:
      fprintf (sysc, "DYNSUF  = sl\n");
      break;

    case os_darwin:
      fprintf (sysc, "DYNSUF  = so\n");
      break;


    default:
      fprintf (sysc, "DYNSUF  = so\n");
      break;
    }

  /* STRIP */
  if (config.debug_compile)
    {
      fprintf (sysc, "STRIP   = true\n");
    }
  else
    {
      fprintf (sysc, "STRIP   = strip\n");
    }

  /* TARGETS */
  fprintf (sysc, "TARGETS =");
  printf ("static library................. %s\n",
	  config.lib_static ? "yes" : "no");
  if (config.lib_static)
    {
      fprintf (sysc, " static");
    }
  printf ("shared library................. %s\n",
	  config.lib_dynamic ? "yes" : "no");
  if (config.lib_dynamic)
    {
      fprintf (sysc, " dynamic");
    }
  fprintf (sysc, "\n");

  /* PREFIX */
  fprintf (sysc, "prefix  = %s\n",
	   config.prefix ? config.prefix : PREFIX_DEFAULT);
  printf ("setting installation prefix as: [%s]\n",
	  config.prefix ? config.prefix : PREFIX_DEFAULT);

  fclose (sysc);
}


void
make_config_h ()
{
  FILE *out;

  out = fopen (HEADER_FILE, "w");
  if (out == NULL)
    {
      printf ("cannot create header file %s: aborting", HEADER_FILE);
      return;
    }

  fprintf (out,
	   "/* This file automatically generated */\n"
	   "#ifndef _CONFIG_H_\n"
	   "#define _CONFIG_H_\n"
	   "\n"
	   "%s", config.big_endian ? "#define WORDS_BIGENDIAN 1\n" : "\n");

  /* Generate SIZEOF macros for basic types */
  printf ("detecting basic size types\n");
  fprintf (out,
	   "#define SIZEOF_CHAR     %d\n"
	   "#define SIZEOF_SHORT    %d\n"
	   "#define SIZEOF_INT      %d\n"
	   "#define SIZEOF_LONG     %d\n"
	   "#define SIZEOF_FLOAT    %d\n"
	   "#define SIZEOF_DOUBLE   %d\n",
	   sizeof (char),
	   sizeof (short),
	   sizeof (int), sizeof (long), sizeof (float), sizeof (double));
  printf ("sizeof(char)................... %d\n"
	  "sizeof(short).................. %d\n"
	  "sizeof(int).................... %d\n"
	  "sizeof(long)................... %d\n"
	  "sizeof(float).................. %d\n"
	  "sizeof(double)................. %d\n",
	  sizeof (char),
	  sizeof (short),
	  sizeof (int), sizeof (long), sizeof (float), sizeof (double));

  /* Do not output CHAR_BIT on AIX */
  if (config.local_os != os_aix)
    {
      fprintf (out,
	       "\n"
	       "#ifndef CHAR_BIT\n"
	       "#define CHAR_BIT\t%d\n"
	       "#endif\n" "\n\n", config.bits_per_byte);
    }

  if (config.arch_x86)
    {
      fprintf (out, "#define CPU_X86         %d\n", config.cpu_x86);
    }

  if (config.with_threads)
    {
      fprintf (out, "#define HAS_PTHREADS    1\n");
    }
  fprintf (out, "\n");
  switch (config.local_os)
    {
    case os_hp08:
    case os_hp09:
    case os_hp10:
    case os_hp11:
      fprintf (out, "#define OS_HPUX         1\n");
      break;

    case os_linux:
      fprintf (out, "#define OS_LINUX        1\n");
      break;

    case os_cygwin:
      fprintf (out, "#define OS_CYGWIN        1\n");
      break;

    case os_irix:
      fprintf (out, "#define OS_IRIX          1\n");
      break;

    case os_aix:
      fprintf (out, "#define OS_AIX          1\n");
      break;

    case os_dec:
      fprintf (out, "#define OS_DEC          1\n");
      break;

    case os_solaris:
      fprintf (out, "#define OS_SOLARIS      1\n");
      break;

    case os_bsd:
      fprintf (out, "#define OS_BSD          1\n");
      break;

    case os_darwin:
      fprintf (out, "#define OS_DARWIN       1\n");
      break;

    default:
      fprintf (out, "#define OS_UNKNOWN      1\n");
      break;
    }
  fprintf (out, "#endif\n");
  fclose (out);
  printf ("done\n");
  return;

}

void
help ()
{
  printf ("\n\n"
	  "***** qfits configure help\n"
	  "Use: configure [options]\n"
	  "\n"
	  "options are:\n"
	  "\t--debug            Compile modules in debug mode\n"
	  "\t--help             Get this help\n"
	  "\n"
	  "\t--with-cc          Force compilation with local cc\n"
	  "\t--with-gcc         Force compilation with gcc\n"
	  "\n"
	  "\t--enable-static    Compile static library (default)\n"
	  "\t--enable-shared    Compile shared library\n"
	  "\t--disable-shared   Do not compile shared library (default)\n"
	  "\t--disable-static   Do not compile static library\n"
	  "\n"
	  "\t--xmemory-mode=M   M=0 switches off the internal xmemory\n"
	  "\t                   handling, M=1 exits the program\n"
	  "\t                   whenever a memory allocation fails,\n"
	  "\t                   M=2 switches on the internal xmemory\n"
	  "\t                   handling.\n"
	  "\n"
	  "\t--max-ptrs=MAXPTRS Set MAXPTRS as the maximum number of\n"
	  "\t                   pointers allowed\n"
	  "\n"
	  "\t--prefix=PATH      Install in PATH (must be absolute)\n"
	  "\t--mt               Compile with multithreading support\n"
	  "\n"
	  "options specific to compilation with gcc (for developers):\n"
	  "\t--lint             Compile with -Wall\n"
	  "\n"
	  "If your platform is not or incorrectly recognized, you\n"
	  "can force a given configuration with this option:\n"
	  "\n"
	  "\t--os=NAME        Where NAME is one of the following:\n"
	  "\n"
	  "\tlinux      - Linux systems (any processor type)\n"
	  "\tcygwin     - Cygwin (UNIX environment for Windows)\n"
	  "\thp08       - HPUX version 8.x\n"
	  "\thp09       - HPUX version 9.x\n"
	  "\thp10       - HPUX version 10.x\n"
	  "\thp11       - HPUX version 11.x\n"
	  "\tirix       - SGI IRIX64\n"
	  "\taix        - IBM AIX (any version)\n"
	  "\tdec        - Dec OSF/1 or Tru64 Unix\n"
	  "\tsolaris    - Sun Solaris >=2.5\n"
	  "\tbsd        - BSD compatible Unix\n"
	  "\tdarwin     - Darwin (BSD compatible on Mac)\n" "\n");
}

int
main (argc, argv)
     int argc;
     char *argv[];
{
  char sysname[MAXSTRSZ];
  char *sval;
  int i;

  config.debug_compile = 0;
  config.lint_compile = 0;
  config.compiler = COMPILER_AUTO;
  config.with_threads = 0;
  config.lib_static = 1;
  config.lib_dynamic = 0;
  config.prefix = NULL;
  config.max_ptrs = -1;
  config.xmemory_mode = -1;

  memset (config.sysname, 0, MAXSTRSZ);
  memset (config.release, 0, MAXSTRSZ);
  memset (config.machine, 0, MAXSTRSZ);

  for (i = 0; i < argc; i++)
    {
      if (!strcmp (argv[i], "--help"))
	{
	  help ();
	  return 1;
	}
      else if (!strcmp (argv[i], "--debug"))
	{
	  config.debug_compile = 1;
	}
      else if (!strcmp (argv[i], "--with-cc"))
	{
	  config.compiler = COMPILER_CC;
	}
      else if (!strcmp (argv[i], "--with-gcc"))
	{
	  config.compiler = COMPILER_GCC;
	}
      else if (!strcmp (argv[i], "--lint"))
	{
	  config.lint_compile = 1;
	}
      else if (!strcmp (argv[i], "--mt"))
	{
	  config.with_threads = 1;
	}
      else if (!strcmp (argv[i], "--enable-shared"))
	{
	  config.lib_dynamic = 1;
	}
      else if (!strcmp (argv[i], "--disable-shared"))
	{
	  config.lib_dynamic = 0;
	}
      else if (!strcmp (argv[i], "--enable-static"))
	{
	  config.lib_static = 1;
	}
      else if (!strcmp (argv[i], "--disable-static"))
	{
	  config.lib_static = 0;
	}
      else if (!strncmp (argv[i], "--prefix=", 9))
	{
	  config.prefix = strchr (argv[i], '=') + 1;
	}
      else if (!strncmp (argv[i], "--max-ptrs=", 11))
	{
	  sval = strchr (argv[i], '=') + 1;
	  config.max_ptrs = (int) atoi (sval);
	}
      else if (!strncmp (argv[i], "--xmemory-mode=", 15))
	{
	  sval = strchr (argv[i], '=') + 1;
	  config.xmemory_mode = (int) atoi (sval);
	}
      else if (!strncmp (argv[i], "--os=", 5))
	{
	  strcpy (sysname, argv[i] + 5);
	  if (!strcmp (sysname, "linux"))
	    {
	      strcpy (config.sysname, "Linux");
	    }
	  else if (!strcmp (sysname, "cygwin"))
	    {
	      strcpy (config.sysname, "CYGWIN");
	    }
	  else if (!strcmp (sysname, "hp08"))
	    {
	      strcpy (config.sysname, "HPUX");
	      strcpy (config.release, "8.x");
	    }
	  else if (!strcmp (sysname, "hp09"))
	    {
	      strcpy (config.sysname, "HPUX");
	      strcpy (config.release, "9.x");
	    }
	  else if (!strcmp (sysname, "hp10"))
	    {
	      strcpy (config.sysname, "HPUX");
	      strcpy (config.release, "10.x");
	    }
	  else if (!strcmp (sysname, "hp11"))
	    {
	      strcpy (config.sysname, "HPUX");
	      strcpy (config.release, "11.x");
	    }
	  else if (!strcmp (sysname, "irix"))
	    {
	      strcpy (config.sysname, "IRIX64");
	    }
	  else if (!strcmp (sysname, "aix"))
	    {
	      strcpy (config.sysname, "AIX");
	    }
	  else if (!strcmp (sysname, "dec"))
	    {
	      strcpy (config.sysname, "Dec OSF/1 or Tru64");
	    }
	  else if (!strcmp (sysname, "solaris"))
	    {
	      strcpy (config.sysname, "Solaris");
	      strcpy (config.release, ">= 2.5");
	    }
	  else if (!strcmp (sysname, "bsd"))
	    {
	      strcpy (config.sysname, "BSD compatible");
	    }
	  else if (!strcmp (sysname, "darwin"))
	    {
	      strcpy (config.sysname, "Darwin");
	    }
	  else
	    {
	      printf ("unsupported OS: %s\n", sysname);
	      return -1;
	    }
	}
    }

  detect_config ();
  make_config_make ();
  make_config_h ();
  return 0;
}