/* Return the value of darwin_macosx_version_min suitable for the

/*  Given a version string, return the version as a statically-allocated

   __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ macro,

    array of three non-negative integers.  If the version string is

   so '10.4.2' becomes 1040.  The lowest digit is always zero.

    invalid, return null.

   Print a warning if the version number can't be understood.  */

    Version strings must consist of one, two, or three tokens, each

    separated by a single period.  Each token must contain only the

    characters '0' through '9' and is converted to an equivalent

    integer.  Omitted tokens are treated as zeros.  For example:

        "10"              becomes   {10,0,0}

        "10.10"           becomes   {10,10,0}

        "10.10.1"         becomes   {10,10,1}

        "10.000010.1"     becomes   {10,10,1}

        "10.010.001"      becomes   {10,10,1}

        "000010.10.00001" becomes   {10,10,1}  */

enum version_components { MAJOR, MINOR, TINY };

static const unsigned long *

parse_version (const char *version_str)

{

  size_t version_len;

  char *end;

  static unsigned long version_array[3];

  if (! version_str)

    return NULL;

  version_len = strlen (version_str);

  if (version_len < 1)

    return NULL;

  /* Version string must consist of digits and periods only.  */

  if (strspn (version_str, "0123456789.") != version_len)

    return NULL;

  if (! ISDIGIT (version_str[0]) || ! ISDIGIT (version_str[version_len - 1]))

    return NULL;

  version_array[MAJOR] = strtoul (version_str, &end, 10);

  version_str = end + ((*end == '.') ? 1 : 0);

  /* Version string must not contain adjacent periods.  */

  if (*version_str == '.')

    return NULL;

  version_array[MINOR] = strtoul (version_str, &end, 10);

  version_str = end + ((*end == '.') ? 1 : 0);

  version_array[TINY] = strtoul (version_str, &end, 10);

  /* Version string must contain no more than three tokens.  */

  if (*end != '\0')

    return NULL;

  return version_array;

}

/*  Given a three-component version represented as an array of

    non-negative integers, return a statically-allocated string suitable

    for the legacy __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ macro.

    If the version is invalid and cannot be coerced into a valid form,

    return null.

    The legacy format is a four-character string -- two chars for the

    major number and one each for the minor and tiny numbers.  Major

    numbers are zero-padded if necessary.  Minor and tiny numbers from

    10 through 99 are permitted but are clamped to 9 (for example,

    {10,9,10} produces "1099").  Versions containing numbers greater

    than 99 are rejected.  */

static const char *

version_as_legacy_macro (const unsigned long *version)

{

  unsigned long major = version[MAJOR];

  unsigned long minor = version[MINOR];

  unsigned long tiny = version[TINY];

  static char result[sizeof "9999"];

  if (major > 99 || minor > 99 || tiny > 99)

    return NULL;

  minor = ((minor > 9) ? 9 : minor);

  tiny = ((tiny > 9) ? 9 : tiny);

  if (sprintf (result, "%02lu%lu%lu", major, minor, tiny)

      != sizeof "9999" - 1)

    return NULL;

  return result;

}

/*  Given a three-component version represented as an array of

    non-negative integers, return a statically-allocated string suitable

    for the modern __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ macro

    or the __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ macro.  If the

    version is invalid, return null.

    The modern format is a five- or six-character string -- one or two

    chars for the major number and two each for the minor and tiny

    numbers, which are zero-padded if necessary (for example, {8,1,0}

    produces "80100", and {10,10,1} produces "101001").  Versions

    containing numbers greater than 99 are rejected.  */

static const char *

version_as_modern_macro (const unsigned long *version)

{

  unsigned long major = version[MAJOR];

  unsigned long minor = version[MINOR];

  unsigned long tiny = version[TINY];

  static char result[sizeof "999999"];

  if (major > 99 || minor > 99 || tiny > 99)

    return NULL;

  /* NOTE: 'sizeof "foo"' returns size of char array, but

     'sizeof ((x > y) ? "foo" : "bar")' returns size of char pointer.  */

  if (sprintf (result, "%lu%02lu%02lu", major, minor, tiny)

      != ((major > 9) ? sizeof "999999" : sizeof "99999") - 1)

    return NULL;

  return result;

}

/*  Return the value of darwin_macosx_version_min, suitably formatted

    for the __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ macro.  (For

    example, "10.9" produces "1090", and "10.10.1" produces "101001".)

    If its value is invalid and cannot be coerced into a valid form,

    print a warning and return "1000".  */

version_as_macro (void)

macosx_version_as_macro (void)

  static char result[] = "1000";

  const unsigned long *version_array;

  const char *version_macro;

  if (strncmp (darwin_macosx_version_min, "10.", 3) != 0)

  version_array = parse_version (darwin_macosx_version_min);

  if (! version_array)

  if (! ISDIGIT (darwin_macosx_version_min[3]))

  /* Do not assume that the major number will always be exactly 10.  */

  if (version_array[MAJOR] < 10 || version_array[MAJOR] > 10)

  result[2] = darwin_macosx_version_min[3];

  if (darwin_macosx_version_min[4] != '\0'

  if (version_array[MAJOR] == 10 && version_array[MINOR] < 10)

      && darwin_macosx_version_min[4] != '.')

    version_macro = version_as_legacy_macro (version_array);

  else

    version_macro = version_as_modern_macro (version_array);

  if (! version_macro)

  return result;

  return version_macro;

	 darwin_macosx_version_min);

         darwin_macosx_version_min);

			     version_as_macro(), false);

			     macosx_version_as_macro(), false);

static bool

static char *

darwin_find_version_from_kernel (char *new_flag)

darwin_find_version_from_kernel (void)

      return false;

      return NULL;

    sprintf (new_flag, "10.%d", major_vers - 4);

    asprintf (&new_flag, "10.%d", major_vers - 4);

    sprintf (new_flag, "10.%d.%s", major_vers - 4,

    asprintf (&new_flag, "10.%d.%s", major_vers - 4, minor_vers);

	     minor_vers);

  return true;

  return new_flag;

  return false;

  return NULL;

  static char new_flag[sizeof ("10.0.0") + 6];

  const char *new_flag;

 /* Try to find the version from the kernel, if we fail - we print a message 

  /* Try to find the version from the kernel, if we fail - we print a message

    and give up.  */

     and give up.  */

 if (!darwin_find_version_from_kernel (new_flag))

  new_flag = darwin_find_version_from_kernel ();

   return;

  if (!new_flag)

    return;

 /* For cross-compilers, default to the target OS version. */

  /* For cross-compilers, default to the target OS version. */

  new_flag = DEF_MIN_OSX_VERSION;

 strncpy (new_flag, DEF_MIN_OSX_VERSION, sizeof (new_flag));

int main(void)

int

main ()

int main(void)

int

main ()

/* Test that most-minor versions greater than 9 work.  */

/* Test that most minor versions < 10 work.  */

/* { dg-options "-mmacosx-version-min=10.4.10" } */

/* { dg-options "-mmacosx-version-min=10.4.1" } */

int main(void)

int

main ()

#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ != 1040

#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ != 1041