/* -*- Mode: c; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 8; -*- */

/* cairo - a vector graphics library with display and print output

 *

 * Copyright © 2002 University of Southern California

 * Copyright © 2005 Red Hat, Inc.

 * Copyright © 2007 Adrian Johnson

 *

 * This library is free software; you can redistribute it and/or

 * modify it either under the terms of the GNU Lesser General Public

 * License version 2.1 as published by the Free Software Foundation

 * (the "LGPL") or, at your option, under the terms of the Mozilla

 * Public License Version 1.1 (the "MPL"). If you do not alter this

 * notice, a recipient may use your version of this file under either

 * the MPL or the LGPL.

 *

 * You should have received a copy of the LGPL along with this library

 * in the file COPYING-LGPL-2.1; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA

 * You should have received a copy of the MPL along with this library

 * in the file COPYING-MPL-1.1

 *

 * The contents of this file are subject to the Mozilla Public License

 * Version 1.1 (the "License"); you may not use this file except in

 * compliance with the License. You may obtain a copy of the License at

 * http://www.mozilla.org/MPL/

 *

 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY

 * OF ANY KIND, either express or implied. See the LGPL or the MPL for

 * the specific language governing rights and limitations.

 *

 * The Original Code is the cairo graphics library.

 *

 * The Initial Developer of the Original Code is University of Southern

 * California.

 *

 * Contributor(s):

 *	Carl D. Worth <cworth@cworth.org>

 *      Adrian Johnson <ajohnson@redneon.com>

 */

#include "cairoint.h"

#include "cairo-error-private.h"

#include <stdio.h>

#include <stdlib.h>

#include <errno.h>

#include <locale.h>

#ifdef HAVE_XLOCALE_H

#include <xlocale.h>

#endif

#if HAVE_FCNTL_H

#include <fcntl.h>

#endif

COMPILE_TIME_ASSERT ((int)CAIRO_STATUS_LAST_STATUS < (int)CAIRO_INT_STATUS_UNSUPPORTED);

COMPILE_TIME_ASSERT (CAIRO_INT_STATUS_LAST_STATUS <= 127);

/**

 * SECTION:cairo-status

 * @Title: Error handling

 * @Short_Description: Decoding cairo's status

 * @See_Also: cairo_status(), cairo_surface_status(), cairo_pattern_status(),

 *            cairo_font_face_status(), cairo_scaled_font_status(),

 *            cairo_region_status()

 *

 * Cairo uses a single status type to represent all kinds of errors.  A status

 * value of %CAIRO_STATUS_SUCCESS represents no error and has an integer value

 * of zero.  All other status values represent an error.

 *

 * Cairo's error handling is designed to be easy to use and safe.  All major

 * cairo objects <firstterm>retain</firstterm> an error status internally which

 * can be queried anytime by the users using cairo*_status() calls.  In

 * the mean time, it is safe to call all cairo functions normally even if the

 * underlying object is in an error status.  This means that no error handling

 * code is required before or after each individual cairo function call.

 **/

/* Public stuff */

/**

 * cairo_status_to_string:

 * @status: a cairo status

 *

 * Provides a human-readable description of a #cairo_status_t.

 *

 * Returns: a string representation of the status

 *

 * Since: 1.0

 **/

const char *

{

    case CAIRO_STATUS_LAST_STATUS:

    }

}

/**

 * cairo_glyph_allocate:

 * @num_glyphs: number of glyphs to allocate

 *

 * Allocates an array of #cairo_glyph_t's.

 * This function is only useful in implementations of

 * #cairo_user_scaled_font_text_to_glyphs_func_t where the user

 * needs to allocate an array of glyphs that cairo will free.

 * For all other uses, user can use their own allocation method

 * for glyphs.

 *

 * This function returns %NULL if @num_glyphs is not positive,

 * or if out of memory.  That means, the %NULL return value

 * signals out-of-memory only if @num_glyphs was positive.

 *

 * Returns: the newly allocated array of glyphs that should be

 *          freed using cairo_glyph_free()

 *

 * Since: 1.8

 **/

cairo_glyph_t *

{

}

/**

 * cairo_glyph_free:

 * @glyphs: array of glyphs to free, or %NULL

 *

 * Frees an array of #cairo_glyph_t's allocated using cairo_glyph_allocate().

 * This function is only useful to free glyph array returned

 * by cairo_scaled_font_text_to_glyphs() where cairo returns

 * an array of glyphs that the user will free.

 * For all other uses, user can use their own allocation method

 * for glyphs.

 *

 * Since: 1.8

 **/

void

{

/**

 * cairo_text_cluster_allocate:

 * @num_clusters: number of text_clusters to allocate

 *

 * Allocates an array of #cairo_text_cluster_t's.

 * This function is only useful in implementations of

 * #cairo_user_scaled_font_text_to_glyphs_func_t where the user

 * needs to allocate an array of text clusters that cairo will free.

 * For all other uses, user can use their own allocation method

 * for text clusters.

 *

 * This function returns %NULL if @num_clusters is not positive,

 * or if out of memory.  That means, the %NULL return value

 * signals out-of-memory only if @num_clusters was positive.

 *

 * Returns: the newly allocated array of text clusters that should be

 *          freed using cairo_text_cluster_free()

 *

 * Since: 1.8

 **/

cairo_text_cluster_t *

{

}

/**

 * cairo_text_cluster_free:

 * @clusters: array of text clusters to free, or %NULL

 *

 * Frees an array of #cairo_text_cluster's allocated using cairo_text_cluster_allocate().

 * This function is only useful to free text cluster array returned

 * by cairo_scaled_font_text_to_glyphs() where cairo returns

 * an array of text clusters that the user will free.

 * For all other uses, user can use their own allocation method

 * for text clusters.

 *

 * Since: 1.8

 **/

void

{

/* Private stuff */

/**

 * _cairo_validate_text_clusters:

 * @utf8: UTF-8 text

 * @utf8_len: length of @utf8 in bytes

 * @glyphs: array of glyphs

 * @num_glyphs: number of glyphs

 * @clusters: array of cluster mapping information

 * @num_clusters: number of clusters in the mapping

 * @cluster_flags: cluster flags

 *

 * Check that clusters cover the entire glyphs and utf8 arrays,

 * and that cluster boundaries are UTF-8 boundaries.

 *

 * Return value: %CAIRO_STATUS_SUCCESS upon success, or

 *               %CAIRO_STATUS_INVALID_CLUSTERS on error.

 *               The error is either invalid UTF-8 input,

 *               or bad cluster mapping.

 **/

cairo_status_t

			       int			    utf8_len,

			       const cairo_glyph_t	   *glyphs,

			       int			    num_glyphs,

			       const cairo_text_cluster_t  *clusters,

			       int			    num_clusters,

			       cairo_text_cluster_flags_t   cluster_flags)

{

    cairo_status_t status;

    int i;

	/* A cluster should cover at least one character or glyph.

	 * I can't see any use for a 0,0 cluster.

	 * I can't see an immediate use for a zero-text cluster

	 * right now either, but they don't harm.

	 * Zero-glyph clusters on the other hand are useful for

	 * things like U+200C ZERO WIDTH NON-JOINER */

	/* Since n_bytes and n_glyphs are unsigned, but the rest of

	 * values involved are signed, we can detect overflow easily */

	/* Make sure we've got valid UTF-8 for the cluster */

    }

    }

}

/**

 * _cairo_operator_bounded_by_mask:

 * @op: a #cairo_operator_t

 *

 * A bounded operator is one where mask pixel

 * of zero results in no effect on the destination image.

 *

 * Unbounded operators often require special handling; if you, for

 * example, draw trapezoids with an unbounded operator, the effect

 * extends past the bounding box of the trapezoids.

 *

 * Return value: %TRUE if the operator is bounded by the mask operand

 **/

cairo_bool_t

{

    case CAIRO_OPERATOR_SOURCE:

    case CAIRO_OPERATOR_OVER:

    case CAIRO_OPERATOR_ATOP:

    case CAIRO_OPERATOR_DEST:

    case CAIRO_OPERATOR_DEST_OVER:

    case CAIRO_OPERATOR_DEST_OUT:

    case CAIRO_OPERATOR_XOR:

    case CAIRO_OPERATOR_ADD:

    case CAIRO_OPERATOR_SATURATE:

    case CAIRO_OPERATOR_MULTIPLY:

    case CAIRO_OPERATOR_SCREEN:

    case CAIRO_OPERATOR_OVERLAY:

    case CAIRO_OPERATOR_DARKEN:

    case CAIRO_OPERATOR_LIGHTEN:

    case CAIRO_OPERATOR_COLOR_DODGE:

    case CAIRO_OPERATOR_COLOR_BURN:

    case CAIRO_OPERATOR_HARD_LIGHT:

    case CAIRO_OPERATOR_SOFT_LIGHT:

    case CAIRO_OPERATOR_DIFFERENCE:

    case CAIRO_OPERATOR_EXCLUSION:

    case CAIRO_OPERATOR_HSL_HUE:

    case CAIRO_OPERATOR_HSL_SATURATION:

    case CAIRO_OPERATOR_HSL_COLOR:

    case CAIRO_OPERATOR_HSL_LUMINOSITY:

    case CAIRO_OPERATOR_IN:

    case CAIRO_OPERATOR_DEST_IN:

    case CAIRO_OPERATOR_DEST_ATOP:

	return FALSE; /* squelch warning */

    }

}

/**

 * _cairo_operator_bounded_by_source:

 * @op: a #cairo_operator_t

 *

 * A bounded operator is one where source pixels of zero

 * (in all four components, r, g, b and a) effect no change

 * in the resulting destination image.

 *

 * Unbounded operators often require special handling; if you, for

 * example, copy a surface with the SOURCE operator, the effect

 * extends past the bounding box of the source surface.

 *

 * Return value: %TRUE if the operator is bounded by the source operand

 **/

cairo_bool_t

{

    case CAIRO_OPERATOR_ATOP:

    case CAIRO_OPERATOR_DEST:

    case CAIRO_OPERATOR_DEST_OVER:

    case CAIRO_OPERATOR_DEST_OUT:

    case CAIRO_OPERATOR_XOR:

    case CAIRO_OPERATOR_ADD:

    case CAIRO_OPERATOR_SATURATE:

    case CAIRO_OPERATOR_MULTIPLY:

    case CAIRO_OPERATOR_SCREEN:

    case CAIRO_OPERATOR_OVERLAY:

    case CAIRO_OPERATOR_DARKEN:

    case CAIRO_OPERATOR_LIGHTEN:

    case CAIRO_OPERATOR_COLOR_DODGE:

    case CAIRO_OPERATOR_COLOR_BURN:

    case CAIRO_OPERATOR_HARD_LIGHT:

    case CAIRO_OPERATOR_SOFT_LIGHT:

    case CAIRO_OPERATOR_DIFFERENCE:

    case CAIRO_OPERATOR_EXCLUSION:

    case CAIRO_OPERATOR_HSL_HUE:

    case CAIRO_OPERATOR_HSL_SATURATION:

    case CAIRO_OPERATOR_HSL_COLOR:

    case CAIRO_OPERATOR_HSL_LUMINOSITY:

    case CAIRO_OPERATOR_SOURCE:

    case CAIRO_OPERATOR_OUT:

    case CAIRO_OPERATOR_IN:

    case CAIRO_OPERATOR_DEST_IN:

    case CAIRO_OPERATOR_DEST_ATOP:

	return FALSE; /* squelch warning */

    }

}

uint32_t

{

    case CAIRO_OPERATOR_ATOP:

    case CAIRO_OPERATOR_DEST:

    case CAIRO_OPERATOR_DEST_OVER:

    case CAIRO_OPERATOR_DEST_OUT:

    case CAIRO_OPERATOR_XOR:

    case CAIRO_OPERATOR_ADD:

    case CAIRO_OPERATOR_SATURATE:

    case CAIRO_OPERATOR_MULTIPLY:

    case CAIRO_OPERATOR_SCREEN:

    case CAIRO_OPERATOR_OVERLAY:

    case CAIRO_OPERATOR_DARKEN:

    case CAIRO_OPERATOR_LIGHTEN:

    case CAIRO_OPERATOR_COLOR_DODGE:

    case CAIRO_OPERATOR_COLOR_BURN:

    case CAIRO_OPERATOR_HARD_LIGHT:

    case CAIRO_OPERATOR_SOFT_LIGHT:

    case CAIRO_OPERATOR_DIFFERENCE:

    case CAIRO_OPERATOR_EXCLUSION:

    case CAIRO_OPERATOR_HSL_HUE:

    case CAIRO_OPERATOR_HSL_SATURATION:

    case CAIRO_OPERATOR_HSL_COLOR:

    case CAIRO_OPERATOR_HSL_LUMINOSITY:

    case CAIRO_OPERATOR_SOURCE:

    case CAIRO_OPERATOR_IN:

    case CAIRO_OPERATOR_DEST_IN:

    case CAIRO_OPERATOR_DEST_ATOP:

	return FALSE; /* squelch warning */

    }

}

#if DISABLE_SOME_FLOATING_POINT

/* This function is identical to the C99 function lround(), except that it

 * performs arithmetic rounding (floor(d + .5) instead of away-from-zero rounding) and

 * has a valid input range of (INT_MIN, INT_MAX] instead of

 * [INT_MIN, INT_MAX]. It is much faster on both x86 and FPU-less systems

 * than other commonly used methods for rounding (lround, round, rint, lrint

 * or float (d + 0.5)).

 *

 * The reason why this function is much faster on x86 than other

 * methods is due to the fact that it avoids the fldcw instruction.

 * This instruction incurs a large performance penalty on modern Intel

 * processors due to how it prevents efficient instruction pipelining.

 *

 * The reason why this function is much faster on FPU-less systems is for

 * an entirely different reason. All common rounding methods involve multiple

 * floating-point operations. Each one of these operations has to be

 * emulated in software, which adds up to be a large performance penalty.

 * This function doesn't perform any floating-point calculations, and thus

 * avoids this penalty.

  */

int

_cairo_lround (double d)

{

    uint32_t top, shift_amount, output;

    union {

        double d;

        uint64_t ui64;

        uint32_t ui32[2];

    } u;

    u.d = d;

    /* If the integer word order doesn't match the float word order, we swap

     * the words of the input double. This is needed because we will be

     * treating the whole double as a 64-bit unsigned integer. Notice that we

     * use WORDS_BIGENDIAN to detect the integer word order, which isn't

     * exactly correct because WORDS_BIGENDIAN refers to byte order, not word

     * order. Thus, we are making the assumption that the byte order is the

     * same as the integer word order which, on the modern machines that we

     * care about, is OK.

     */

#if ( defined(FLOAT_WORDS_BIGENDIAN) && !defined(WORDS_BIGENDIAN)) || \

    (!defined(FLOAT_WORDS_BIGENDIAN) &&  defined(WORDS_BIGENDIAN))

    {

        uint32_t temp = u.ui32[0];

        u.ui32[0] = u.ui32[1];

        u.ui32[1] = temp;

    }

#endif

#ifdef WORDS_BIGENDIAN

    #define MSW (0) /* Most Significant Word */

    #define LSW (1) /* Least Significant Word */

#else

    #define MSW (1)

    #define LSW (0)

#endif

    /* By shifting the most significant word of the input double to the

     * right 20 places, we get the very "top" of the double where the exponent

     * and sign bit lie.

     */

    top = u.ui32[MSW] >> 20;

    /* Here, we calculate how much we have to shift the mantissa to normalize

     * it to an integer value. We extract the exponent "top" by masking out the

     * sign bit, then we calculate the shift amount by subtracting the exponent

     * from the bias. Notice that the correct bias for 64-bit doubles is

     * actually 1075, but we use 1053 instead for two reasons:

     *

     *  1) To perform rounding later on, we will first need the target

     *     value in a 31.1 fixed-point format. Thus, the bias needs to be one

     *     less: (1075 - 1: 1074).

     *

     *  2) To avoid shifting the mantissa as a full 64-bit integer (which is

     *     costly on certain architectures), we break the shift into two parts.

     *     First, the upper and lower parts of the mantissa are shifted

     *     individually by a constant amount that all valid inputs will require

     *     at the very least. This amount is chosen to be 21, because this will

     *     allow the two parts of the mantissa to later be combined into a

     *     single 32-bit representation, on which the remainder of the shift

     *     will be performed. Thus, we decrease the bias by an additional 21:

     *     (1074 - 21: 1053).

     */

    shift_amount = 1053 - (top & 0x7FF);

    /* We are done with the exponent portion in "top", so here we shift it off

     * the end.

     */

    top >>= 11;

    /* Before we perform any operations on the mantissa, we need to OR in

     * the implicit 1 at the top (see the IEEE-754 spec). We needn't mask

     * off the sign bit nor the exponent bits because these higher bits won't

     * make a bit of difference in the rest of our calculations.

     */

    u.ui32[MSW] |= 0x100000;

    /* If the input double is negative, we have to decrease the mantissa

     * by a hair. This is an important part of performing arithmetic rounding,

     * as negative numbers must round towards positive infinity in the

     * halfwase case of -x.5. Since "top" contains only the sign bit at this

     * point, we can just decrease the mantissa by the value of "top".

     */

    u.ui64 -= top;

    /* By decrementing "top", we create a bitmask with a value of either

     * 0x0 (if the input was negative) or 0xFFFFFFFF (if the input was positive

     * and thus the unsigned subtraction underflowed) that we'll use later.

     */

    top--;

    /* Here, we shift the mantissa by the constant value as described above.

     * We can emulate a 64-bit shift right by 21 through shifting the top 32

     * bits left 11 places and ORing in the bottom 32 bits shifted 21 places

     * to the right. Both parts of the mantissa are now packed into a single

     * 32-bit integer. Although we severely truncate the lower part in the

     * process, we still have enough significant bits to perform the conversion

     * without error (for all valid inputs).

     */

    output = (u.ui32[MSW] << 11) | (u.ui32[LSW] >> 21);

    /* Next, we perform the shift that converts the X.Y fixed-point number

     * currently found in "output" to the desired 31.1 fixed-point format

     * needed for the following rounding step. It is important to consider

     * all possible values for "shift_amount" at this point:

     *

     * - {shift_amount < 0} Since shift_amount is an unsigned integer, it

     *   really can't have a value less than zero. But, if the shift_amount

     *   calculation above caused underflow (which would happen with

     *   input > INT_MAX or input <= INT_MIN) then shift_amount will now be

     *   a very large number, and so this shift will result in complete

     *   garbage. But that's OK, as the input was out of our range, so our

     *   output is undefined.

     *

     * - {shift_amount > 31} If the magnitude of the input was very small

     *   (i.e. |input| << 1.0), shift_amount will have a value greater than

     *   31. Thus, this shift will also result in garbage. After performing

     *   the shift, we will zero-out "output" if this is the case.

     *

     * - {0 <= shift_amount < 32} In this case, the shift will properly convert

     *   the mantissa into a 31.1 fixed-point number.

     */

    output >>= shift_amount;

    /* This is where we perform rounding with the 31.1 fixed-point number.

     * Since what we're after is arithmetic rounding, we simply add the single

     * fractional bit into the integer part of "output", and just keep the

     * integer part.

     */

    output = (output >> 1) + (output & 1);

    /* Here, we zero-out the result if the magnitude if the input was very small

     * (as explained in the section above). Notice that all input out of the

     * valid range is also caught by this condition, which means we produce 0

     * for all invalid input, which is a nice side effect.

     *

     * The most straightforward way to do this would be:

     *

     *      if (shift_amount > 31)

     *          output = 0;

     *

     * But we can use a little trick to avoid the potential branch. The

     * expression (shift_amount > 31) will be either 1 or 0, which when

     * decremented will be either 0x0 or 0xFFFFFFFF (unsigned underflow),

     * which can be used to conditionally mask away all the bits in "output"

     * (in the 0x0 case), effectively zeroing it out. Certain, compilers would

     * have done this for us automatically.

     */

    output &= ((shift_amount > 31) - 1);

    /* If the input double was a negative number, then we have to negate our

     * output. The most straightforward way to do this would be:

     *

     *      if (!top)

     *          output = -output;

     *

     * as "top" at this point is either 0x0 (if the input was negative) or

     * 0xFFFFFFFF (if the input was positive). But, we can use a trick to

     * avoid the branch. Observe that the following snippet of code has the

     * same effect as the reference snippet above:

     *

     *      if (!top)

     *          output = 0 - output;

     *      else

     *          output = output - 0;

     *

     * Armed with the bitmask found in "top", we can condense the two statements

     * into the following:

     *

     *      output = (output & top) - (output & ~top);

     *

     * where, in the case that the input double was negative, "top" will be 0,

     * and the statement will be equivalent to:

     *

     *      output = (0) - (output);

     *

     * and if the input double was positive, "top" will be 0xFFFFFFFF, and the

     * statement will be equivalent to:

     *

     *      output = (output) - (0);

     *

     * Which, as pointed out earlier, is equivalent to the original reference

     * snippet.

     */

    output = (output & top) - (output & ~top);

    return output;

#undef MSW

#undef LSW

}

#endif

/* Convert a 32-bit IEEE single precision floating point number to a

 * 'half' representation (s10.5)

 */

uint16_t

{

    union {

	uint32_t ui;

	float f;

    } u;

    int s, e, m;

	    /* underflow */

	}

	/* round to nearest, round 0.5 up. */

	    /* infinity */

	} else {

	    /* nan */

	}

    } else {

	/* round to nearest, round 0.5 up. */

	    }

	}

	    /* overflow -> infinity */

	}

    }

}

#ifndef __BIONIC__

# include <locale.h>

const char *

{

}

#else

/* Android's Bionic libc doesn't provide decimal_point */

const char *

_cairo_get_locale_decimal_point (void)

{

    return ".";

}

#endif

#if defined (HAVE_NEWLOCALE) && defined (HAVE_STRTOD_L)

static locale_t C_locale;

static locale_t

{

    locale_t C;

        }

    }

}

double

{

}

#else

/* strtod replacement that ignores locale and only accepts decimal points */

double

_cairo_strtod (const char *nptr, char **endptr)

{

    const char *decimal_point;

    int decimal_point_len;

    const char *p;

    char buf[100];

    char *bufptr;

    char *bufend = buf + sizeof(buf) - 1;

    double value;

    char *end;

    int delta;

    cairo_bool_t have_dp;

    decimal_point = _cairo_get_locale_decimal_point ();

    decimal_point_len = strlen (decimal_point);

    assert (decimal_point_len != 0);

    p = nptr;

    bufptr = buf;

    delta = 0;

    have_dp = FALSE;

    while (*p && _cairo_isspace (*p)) {

	p++;

	delta++;

    }

    while (*p && (bufptr + decimal_point_len < bufend)) {

	if (_cairo_isdigit (*p)) {

	    *bufptr++ = *p;

	} else if (*p == '.') {

	    if (have_dp)

		break;

	    strncpy (bufptr, decimal_point, decimal_point_len);

	    bufptr += decimal_point_len;

	    delta -= decimal_point_len - 1;

	    have_dp = TRUE;

	} else if (bufptr == buf && (*p == '-' || *p == '+')) {

	    *bufptr++ = *p;

	} else {

	    break;

	}

	p++;

    }

    *bufptr = 0;

    value = strtod (buf, &end);

    if (endptr) {

	if (end == buf)

	    *endptr = (char*)(nptr);

	else

	    *endptr = (char*)(nptr + (end - buf) + delta);

    }

    return value;

}

#endif

#ifndef HAVE_STRNDUP

char *

_cairo_strndup (const char *s, size_t n)

{

    const char *end;

    size_t len;

    char *sdup;

    if (s == NULL)

	return NULL;

    end = memchr (s, 0, n);

    if (end)

	len = end - s;

    else

	len = n;

    sdup = (char *) _cairo_malloc (len + 1);

    if (sdup != NULL) {

	memcpy (sdup, s, len);

	sdup[len] = '\0';

    }

    return sdup;

}

#endif

/**

 * _cairo_fopen:

 * @filename: filename to open

 * @mode: mode string with which to open the file

 * @file_out: reference to file handle

 *

 * Exactly like the C library function, but possibly doing encoding

 * conversion on the filename. On all platforms, the filename is

 * passed directly to the system, but on Windows, the filename is

 * interpreted as UTF-8, rather than in a codepage that would depend

 * on system settings.

 *

 * Return value: CAIRO_STATUS_SUCCESS when the filename was converted

 * successfully to the native encoding, or the error reported by

 * _cairo_utf8_to_utf16 otherwise. To check if the file handle could

 * be obtained, dereference file_out and compare its value against

 * NULL

 **/

cairo_status_t

{

    FILE *result;

#ifdef _WIN32 /* also defined on x86_64 */

    uint16_t *filename_w;

    uint16_t *mode_w;

    cairo_status_t status;

    *file_out = NULL;

    if (filename == NULL || mode == NULL) {

	errno = EINVAL;

	return CAIRO_STATUS_SUCCESS;

    }

    if ((status = _cairo_utf8_to_utf16 (filename, -1, &filename_w, NULL)) != CAIRO_STATUS_SUCCESS) {

	errno = EINVAL;

	return status;

    }

    if ((status = _cairo_utf8_to_utf16 (mode, -1, &mode_w, NULL)) != CAIRO_STATUS_SUCCESS) {

	free (filename_w);

	errno = EINVAL;

	return status;

    }

    result = _wfopen (filename_w, mode_w);

    free (filename_w);

    free (mode_w);

#else /* Use fopen directly */

#if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7)

    /* Glibc 2.7 supports the "e" mode flag that opens the file with O_CLOEXEC.

     * this avoid the race condition in the fcntl fallback below. */

    char new_mode[20];

#else /* fopen "e" not available */

    result = fopen (filename, mode);

#if defined(HAVE_FCNTL_H) && defined(FD_CLOEXEC)

    /* Manually set CLOEXEC */

    if (result != NULL) {

	int fd = fileno (result);

	if (fd != -1) {

	    int flags = fcntl (fd, F_GETFD);

	    if (flags >= 0)

		flags = fcntl (fd, F_SETFD, flags | FD_CLOEXEC);

	}

    }

#endif /* defined(HAVE_FCNTL_H) && defined(FD_CLOEXEC) */

#endif /* fopen "e" not available */

#endif /* !_WIN32 */

}

#ifdef _WIN32

#include <windows.h>

#include <io.h>

/* tmpfile() replacement for Windows.

 *

 * On Windows tmpfile() creates the file in the root directory. This

 * may fail due to insufficient privileges.

 */

static FILE *

_cairo_win32_tmpfile (void)

{

    DWORD path_len;

    WCHAR path_name[MAX_PATH + 1];

    WCHAR file_name[MAX_PATH + 1];

    HANDLE handle;

    int fd;

    FILE *fp;

    path_len = GetTempPathW (MAX_PATH, path_name);

    if (path_len <= 0 || path_len >= MAX_PATH)

	return NULL;

    if (GetTempFileNameW (path_name, L"cairo_", 0, file_name) == 0)

	return NULL;

    handle = CreateFileW (file_name,

			 GENERIC_READ | GENERIC_WRITE,

			 0,

			 NULL,

			 CREATE_ALWAYS,

			 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_DELETE_ON_CLOSE,

			 NULL);

    if (handle == INVALID_HANDLE_VALUE) {

	DeleteFileW (file_name);

	return NULL;

    }

    fd = _open_osfhandle((intptr_t) handle, 0);

    if (fd < 0) {

	CloseHandle (handle);

	return NULL;

    }

    fp = fdopen(fd, "w+b");

    if (fp == NULL) {

	_close(fd);

	return NULL;

    }

    return fp;

}

#endif /* _WIN32 */

/**

 * _cairo_tmpfile:

 *

 * Exactly like the C library function. On platforms that support

 * O_CLOEXEC, the file will be opened with this flag. On Windows, the

 * file is opened in the temp directory instead of the root directory.

 *

 * Return value: a file handle or NULL on error.

 **/

FILE *

{

#ifdef _WIN32

    return _cairo_win32_tmpfile ();

#else /* !_WIN32 */

    int fd;

    FILE *file;

    int flags;

#ifdef O_TMPFILE

	      O_TMPFILE | O_EXCL | O_RDWR | O_NOATIME | O_CLOEXEC,

	      0600);

		  O_TMPFILE | O_EXCL | O_RDWR | O_NOATIME | O_CLOEXEC,

		  0600);

    }

    /* Fallback */

#endif /* O_TMPFILE */

#if defined(HAVE_FCNTL_H) && defined(FD_CLOEXEC)

    /* Manually set CLOEXEC */

	}

    }

#endif /* defined(HAVE_FCNTL_H) && defined(FD_CLOEXEC) */

#endif /* !_WIN32 */

}

typedef struct _cairo_intern_string {

    cairo_hash_entry_t hash_entry;

    int len;

    char *string;

} cairo_intern_string_t;

static cairo_hash_table_t *_cairo_intern_string_ht;

unsigned long

{

}

static cairo_bool_t

{

}

cairo_status_t

{

    cairo_intern_string_t tmpl, *istring;

    if (CAIRO_INJECT_FAULT ())

	return _cairo_error (CAIRO_STATUS_NO_MEMORY);

	}

    }

					&tmpl.hash_entry);

					       &istring->hash_entry);

	    }

	} else {

	}

    }

}

static void

{

void

{

				   _intern_string_pluck,

				   _cairo_intern_string_ht);

    }