Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. /* -*- Mode: c; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 8; -*- */
  2. /* cairo - a vector graphics library with display and print output
  3.  *
  4.  * Copyright © 2002 University of Southern California
  5.  * Copyright © 2005 Red Hat, Inc.
  6.  * Copyright © 2007 Adrian Johnson
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it either under the terms of the GNU Lesser General Public
  10.  * License version 2.1 as published by the Free Software Foundation
  11.  * (the "LGPL") or, at your option, under the terms of the Mozilla
  12.  * Public License Version 1.1 (the "MPL"). If you do not alter this
  13.  * notice, a recipient may use your version of this file under either
  14.  * the MPL or the LGPL.
  15.  *
  16.  * You should have received a copy of the LGPL along with this library
  17.  * in the file COPYING-LGPL-2.1; if not, write to the Free Software
  18.  * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
  19.  * You should have received a copy of the MPL along with this library
  20.  * in the file COPYING-MPL-1.1
  21.  *
  22.  * The contents of this file are subject to the Mozilla Public License
  23.  * Version 1.1 (the "License"); you may not use this file except in
  24.  * compliance with the License. You may obtain a copy of the License at
  25.  * http://www.mozilla.org/MPL/
  26.  *
  27.  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
  28.  * OF ANY KIND, either express or implied. See the LGPL or the MPL for
  29.  * the specific language governing rights and limitations.
  30.  *
  31.  * The Original Code is the cairo graphics library.
  32.  *
  33.  * The Initial Developer of the Original Code is University of Southern
  34.  * California.
  35.  *
  36.  * Contributor(s):
  37.  *      Carl D. Worth <cworth@cworth.org>
  38.  *      Adrian Johnson <ajohnson@redneon.com>
  39.  */
  40.  
  41. #include "cairoint.h"
  42. #include "cairo-error-private.h"
  43.  
  44. COMPILE_TIME_ASSERT (CAIRO_STATUS_LAST_STATUS < CAIRO_INT_STATUS_UNSUPPORTED);
  45. COMPILE_TIME_ASSERT (CAIRO_INT_STATUS_LAST_STATUS <= 127);
  46.  
  47. /**
  48.  * SECTION:cairo-status
  49.  * @Title: Error handling
  50.  * @Short_Description: Decoding cairo's status
  51.  * @See_Also: cairo_status(), cairo_surface_status(), cairo_pattern_status(),
  52.  *            cairo_font_face_status(), cairo_scaled_font_status(),
  53.  *            cairo_region_status()
  54.  *
  55.  * Cairo uses a single status type to represent all kinds of errors.  A status
  56.  * value of %CAIRO_STATUS_SUCCESS represents no error and has an integer value
  57.  * of zero.  All other status values represent an error.
  58.  *
  59.  * Cairo's error handling is designed to be easy to use and safe.  All major
  60.  * cairo objects <firstterm>retain</firstterm> an error status internally which
  61.  * can be queried anytime by the users using cairo*_status() calls.  In
  62.  * the mean time, it is safe to call all cairo functions normally even if the
  63.  * underlying object is in an error status.  This means that no error handling
  64.  * code is required before or after each individual cairo function call.
  65.  */
  66.  
  67. /* Public stuff */
  68.  
  69. /**
  70.  * cairo_status_to_string:
  71.  * @status: a cairo status
  72.  *
  73.  * Provides a human-readable description of a #cairo_status_t.
  74.  *
  75.  * Returns: a string representation of the status
  76.  */
  77. const char *
  78. cairo_status_to_string (cairo_status_t status)
  79. {
  80.     switch (status) {
  81.     case CAIRO_STATUS_SUCCESS:
  82.         return "no error has occurred";
  83.     case CAIRO_STATUS_NO_MEMORY:
  84.         return "out of memory";
  85.     case CAIRO_STATUS_INVALID_RESTORE:
  86.         return "cairo_restore() without matching cairo_save()";
  87.     case CAIRO_STATUS_INVALID_POP_GROUP:
  88.         return "no saved group to pop, i.e. cairo_pop_group() without matching cairo_push_group()";
  89.     case CAIRO_STATUS_NO_CURRENT_POINT:
  90.         return "no current point defined";
  91.     case CAIRO_STATUS_INVALID_MATRIX:
  92.         return "invalid matrix (not invertible)";
  93.     case CAIRO_STATUS_INVALID_STATUS:
  94.         return "invalid value for an input cairo_status_t";
  95.     case CAIRO_STATUS_NULL_POINTER:
  96.         return "NULL pointer";
  97.     case CAIRO_STATUS_INVALID_STRING:
  98.         return "input string not valid UTF-8";
  99.     case CAIRO_STATUS_INVALID_PATH_DATA:
  100.         return "input path data not valid";
  101.     case CAIRO_STATUS_READ_ERROR:
  102.         return "error while reading from input stream";
  103.     case CAIRO_STATUS_WRITE_ERROR:
  104.         return "error while writing to output stream";
  105.     case CAIRO_STATUS_SURFACE_FINISHED:
  106.         return "the target surface has been finished";
  107.     case CAIRO_STATUS_SURFACE_TYPE_MISMATCH:
  108.         return "the surface type is not appropriate for the operation";
  109.     case CAIRO_STATUS_PATTERN_TYPE_MISMATCH:
  110.         return "the pattern type is not appropriate for the operation";
  111.     case CAIRO_STATUS_INVALID_CONTENT:
  112.         return "invalid value for an input cairo_content_t";
  113.     case CAIRO_STATUS_INVALID_FORMAT:
  114.         return "invalid value for an input cairo_format_t";
  115.     case CAIRO_STATUS_INVALID_VISUAL:
  116.         return "invalid value for an input Visual*";
  117.     case CAIRO_STATUS_FILE_NOT_FOUND:
  118.         return "file not found";
  119.     case CAIRO_STATUS_INVALID_DASH:
  120.         return "invalid value for a dash setting";
  121.     case CAIRO_STATUS_INVALID_DSC_COMMENT:
  122.         return "invalid value for a DSC comment";
  123.     case CAIRO_STATUS_INVALID_INDEX:
  124.         return "invalid index passed to getter";
  125.     case CAIRO_STATUS_CLIP_NOT_REPRESENTABLE:
  126.         return "clip region not representable in desired format";
  127.     case CAIRO_STATUS_TEMP_FILE_ERROR:
  128.         return "error creating or writing to a temporary file";
  129.     case CAIRO_STATUS_INVALID_STRIDE:
  130.         return "invalid value for stride";
  131.     case CAIRO_STATUS_FONT_TYPE_MISMATCH:
  132.         return "the font type is not appropriate for the operation";
  133.     case CAIRO_STATUS_USER_FONT_IMMUTABLE:
  134.         return "the user-font is immutable";
  135.     case CAIRO_STATUS_USER_FONT_ERROR:
  136.         return "error occurred in a user-font callback function";
  137.     case CAIRO_STATUS_NEGATIVE_COUNT:
  138.         return "negative number used where it is not allowed";
  139.     case CAIRO_STATUS_INVALID_CLUSTERS:
  140.         return "input clusters do not represent the accompanying text and glyph arrays";
  141.     case CAIRO_STATUS_INVALID_SLANT:
  142.         return "invalid value for an input cairo_font_slant_t";
  143.     case CAIRO_STATUS_INVALID_WEIGHT:
  144.         return "invalid value for an input cairo_font_weight_t";
  145.     case CAIRO_STATUS_INVALID_SIZE:
  146.         return "invalid value (typically too big) for the size of the input (surface, pattern, etc.)";
  147.     case CAIRO_STATUS_USER_FONT_NOT_IMPLEMENTED:
  148.         return "user-font method not implemented";
  149.     case CAIRO_STATUS_DEVICE_TYPE_MISMATCH:
  150.         return "the device type is not appropriate for the operation";
  151.     case CAIRO_STATUS_DEVICE_ERROR:
  152.         return "an operation to the device caused an unspecified error";
  153.     default:
  154.     case CAIRO_STATUS_LAST_STATUS:
  155.         return "<unknown error status>";
  156.     }
  157. }
  158.  
  159.  
  160. /**
  161.  * cairo_glyph_allocate:
  162.  * @num_glyphs: number of glyphs to allocate
  163.  *
  164.  * Allocates an array of #cairo_glyph_t's.
  165.  * This function is only useful in implementations of
  166.  * #cairo_user_scaled_font_text_to_glyphs_func_t where the user
  167.  * needs to allocate an array of glyphs that cairo will free.
  168.  * For all other uses, user can use their own allocation method
  169.  * for glyphs.
  170.  *
  171.  * This function returns %NULL if @num_glyphs is not positive,
  172.  * or if out of memory.  That means, the %NULL return value
  173.  * signals out-of-memory only if @num_glyphs was positive.
  174.  *
  175.  * Returns: the newly allocated array of glyphs that should be
  176.  *          freed using cairo_glyph_free()
  177.  *
  178.  * Since: 1.8
  179.  */
  180. cairo_glyph_t *
  181. cairo_glyph_allocate (int num_glyphs)
  182. {
  183.     if (num_glyphs <= 0)
  184.         return NULL;
  185.  
  186.     return _cairo_malloc_ab (num_glyphs, sizeof (cairo_glyph_t));
  187. }
  188. slim_hidden_def (cairo_glyph_allocate);
  189.  
  190. /**
  191.  * cairo_glyph_free:
  192.  * @glyphs: array of glyphs to free, or %NULL
  193.  *
  194.  * Frees an array of #cairo_glyph_t's allocated using cairo_glyph_allocate().
  195.  * This function is only useful to free glyph array returned
  196.  * by cairo_scaled_font_text_to_glyphs() where cairo returns
  197.  * an array of glyphs that the user will free.
  198.  * For all other uses, user can use their own allocation method
  199.  * for glyphs.
  200.  *
  201.  * Since: 1.8
  202.  */
  203. void
  204. cairo_glyph_free (cairo_glyph_t *glyphs)
  205. {
  206.     if (glyphs)
  207.         free (glyphs);
  208. }
  209. slim_hidden_def (cairo_glyph_free);
  210.  
  211. /**
  212.  * cairo_text_cluster_allocate:
  213.  * @num_clusters: number of text_clusters to allocate
  214.  *
  215.  * Allocates an array of #cairo_text_cluster_t's.
  216.  * This function is only useful in implementations of
  217.  * #cairo_user_scaled_font_text_to_glyphs_func_t where the user
  218.  * needs to allocate an array of text clusters that cairo will free.
  219.  * For all other uses, user can use their own allocation method
  220.  * for text clusters.
  221.  *
  222.  * This function returns %NULL if @num_clusters is not positive,
  223.  * or if out of memory.  That means, the %NULL return value
  224.  * signals out-of-memory only if @num_clusters was positive.
  225.  *
  226.  * Returns: the newly allocated array of text clusters that should be
  227.  *          freed using cairo_text_cluster_free()
  228.  *
  229.  * Since: 1.8
  230.  */
  231. cairo_text_cluster_t *
  232. cairo_text_cluster_allocate (int num_clusters)
  233. {
  234.     if (num_clusters <= 0)
  235.         return NULL;
  236.  
  237.     return _cairo_malloc_ab (num_clusters, sizeof (cairo_text_cluster_t));
  238. }
  239. slim_hidden_def (cairo_text_cluster_allocate);
  240.  
  241. /**
  242.  * cairo_text_cluster_free:
  243.  * @clusters: array of text clusters to free, or %NULL
  244.  *
  245.  * Frees an array of #cairo_text_cluster's allocated using cairo_text_cluster_allocate().
  246.  * This function is only useful to free text cluster array returned
  247.  * by cairo_scaled_font_text_to_glyphs() where cairo returns
  248.  * an array of text clusters that the user will free.
  249.  * For all other uses, user can use their own allocation method
  250.  * for text clusters.
  251.  *
  252.  * Since: 1.8
  253.  */
  254. void
  255. cairo_text_cluster_free (cairo_text_cluster_t *clusters)
  256. {
  257.     if (clusters)
  258.         free (clusters);
  259. }
  260. slim_hidden_def (cairo_text_cluster_free);
  261.  
  262.  
  263. /* Private stuff */
  264.  
  265. /**
  266.  * _cairo_validate_text_clusters:
  267.  * @utf8: UTF-8 text
  268.  * @utf8_len: length of @utf8 in bytes
  269.  * @glyphs: array of glyphs
  270.  * @num_glyphs: number of glyphs
  271.  * @clusters: array of cluster mapping information
  272.  * @num_clusters: number of clusters in the mapping
  273.  * @cluster_flags: cluster flags
  274.  *
  275.  * Check that clusters cover the entire glyphs and utf8 arrays,
  276.  * and that cluster boundaries are UTF-8 boundaries.
  277.  *
  278.  * Return value: %CAIRO_STATUS_SUCCESS upon success, or
  279.  *               %CAIRO_STATUS_INVALID_CLUSTERS on error.
  280.  *               The error is either invalid UTF-8 input,
  281.  *               or bad cluster mapping.
  282.  */
  283. cairo_status_t
  284. _cairo_validate_text_clusters (const char                  *utf8,
  285.                                int                          utf8_len,
  286.                                const cairo_glyph_t         *glyphs,
  287.                                int                          num_glyphs,
  288.                                const cairo_text_cluster_t  *clusters,
  289.                                int                          num_clusters,
  290.                                cairo_text_cluster_flags_t   cluster_flags)
  291. {
  292.     cairo_status_t status;
  293.     unsigned int n_bytes  = 0;
  294.     unsigned int n_glyphs = 0;
  295.     int i;
  296.  
  297.     for (i = 0; i < num_clusters; i++) {
  298.         int cluster_bytes  = clusters[i].num_bytes;
  299.         int cluster_glyphs = clusters[i].num_glyphs;
  300.  
  301.         if (cluster_bytes < 0 || cluster_glyphs < 0)
  302.             goto BAD;
  303.  
  304.         /* A cluster should cover at least one character or glyph.
  305.          * I can't see any use for a 0,0 cluster.
  306.          * I can't see an immediate use for a zero-text cluster
  307.          * right now either, but they don't harm.
  308.          * Zero-glyph clusters on the other hand are useful for
  309.          * things like U+200C ZERO WIDTH NON-JOINER */
  310.         if (cluster_bytes == 0 && cluster_glyphs == 0)
  311.             goto BAD;
  312.  
  313.         /* Since n_bytes and n_glyphs are unsigned, but the rest of
  314.          * values involved are signed, we can detect overflow easily */
  315.         if (n_bytes+cluster_bytes > (unsigned int)utf8_len || n_glyphs+cluster_glyphs > (unsigned int)num_glyphs)
  316.             goto BAD;
  317.  
  318.         /* Make sure we've got valid UTF-8 for the cluster */
  319.         status = _cairo_utf8_to_ucs4 (utf8+n_bytes, cluster_bytes, NULL, NULL);
  320.         if (unlikely (status))
  321.             return _cairo_error (CAIRO_STATUS_INVALID_CLUSTERS);
  322.  
  323.         n_bytes  += cluster_bytes ;
  324.         n_glyphs += cluster_glyphs;
  325.     }
  326.  
  327.     if (n_bytes != (unsigned int) utf8_len || n_glyphs != (unsigned int) num_glyphs) {
  328.       BAD:
  329.         return _cairo_error (CAIRO_STATUS_INVALID_CLUSTERS);
  330.     }
  331.  
  332.     return CAIRO_STATUS_SUCCESS;
  333. }
  334.  
  335. /**
  336.  * _cairo_operator_bounded_by_mask:
  337.  * @op: a #cairo_operator_t
  338.  *
  339.  * A bounded operator is one where mask pixel
  340.  * of zero results in no effect on the destination image.
  341.  *
  342.  * Unbounded operators often require special handling; if you, for
  343.  * example, draw trapezoids with an unbounded operator, the effect
  344.  * extends past the bounding box of the trapezoids.
  345.  *
  346.  * Return value: %TRUE if the operator is bounded by the mask operand
  347.  **/
  348. cairo_bool_t
  349. _cairo_operator_bounded_by_mask (cairo_operator_t op)
  350. {
  351.     switch (op) {
  352.     case CAIRO_OPERATOR_CLEAR:
  353.     case CAIRO_OPERATOR_SOURCE:
  354.     case CAIRO_OPERATOR_OVER:
  355.     case CAIRO_OPERATOR_ATOP:
  356.     case CAIRO_OPERATOR_DEST:
  357.     case CAIRO_OPERATOR_DEST_OVER:
  358.     case CAIRO_OPERATOR_DEST_OUT:
  359.     case CAIRO_OPERATOR_XOR:
  360.     case CAIRO_OPERATOR_ADD:
  361.     case CAIRO_OPERATOR_SATURATE:
  362.     case CAIRO_OPERATOR_MULTIPLY:
  363.     case CAIRO_OPERATOR_SCREEN:
  364.     case CAIRO_OPERATOR_OVERLAY:
  365.     case CAIRO_OPERATOR_DARKEN:
  366.     case CAIRO_OPERATOR_LIGHTEN:
  367.     case CAIRO_OPERATOR_COLOR_DODGE:
  368.     case CAIRO_OPERATOR_COLOR_BURN:
  369.     case CAIRO_OPERATOR_HARD_LIGHT:
  370.     case CAIRO_OPERATOR_SOFT_LIGHT:
  371.     case CAIRO_OPERATOR_DIFFERENCE:
  372.     case CAIRO_OPERATOR_EXCLUSION:
  373.     case CAIRO_OPERATOR_HSL_HUE:
  374.     case CAIRO_OPERATOR_HSL_SATURATION:
  375.     case CAIRO_OPERATOR_HSL_COLOR:
  376.     case CAIRO_OPERATOR_HSL_LUMINOSITY:
  377.         return TRUE;
  378.     case CAIRO_OPERATOR_OUT:
  379.     case CAIRO_OPERATOR_IN:
  380.     case CAIRO_OPERATOR_DEST_IN:
  381.     case CAIRO_OPERATOR_DEST_ATOP:
  382.         return FALSE;
  383.     }
  384.  
  385.     ASSERT_NOT_REACHED;
  386.     return FALSE;
  387. }
  388.  
  389. /**
  390.  * _cairo_operator_bounded_by_source:
  391.  * @op: a #cairo_operator_t
  392.  *
  393.  * A bounded operator is one where source pixels of zero
  394.  * (in all four components, r, g, b and a) effect no change
  395.  * in the resulting destination image.
  396.  *
  397.  * Unbounded operators often require special handling; if you, for
  398.  * example, copy a surface with the SOURCE operator, the effect
  399.  * extends past the bounding box of the source surface.
  400.  *
  401.  * Return value: %TRUE if the operator is bounded by the source operand
  402.  **/
  403. cairo_bool_t
  404. _cairo_operator_bounded_by_source (cairo_operator_t op)
  405. {
  406.     switch (op) {
  407.     case CAIRO_OPERATOR_OVER:
  408.     case CAIRO_OPERATOR_ATOP:
  409.     case CAIRO_OPERATOR_DEST:
  410.     case CAIRO_OPERATOR_DEST_OVER:
  411.     case CAIRO_OPERATOR_DEST_OUT:
  412.     case CAIRO_OPERATOR_XOR:
  413.     case CAIRO_OPERATOR_ADD:
  414.     case CAIRO_OPERATOR_SATURATE:
  415.     case CAIRO_OPERATOR_MULTIPLY:
  416.     case CAIRO_OPERATOR_SCREEN:
  417.     case CAIRO_OPERATOR_OVERLAY:
  418.     case CAIRO_OPERATOR_DARKEN:
  419.     case CAIRO_OPERATOR_LIGHTEN:
  420.     case CAIRO_OPERATOR_COLOR_DODGE:
  421.     case CAIRO_OPERATOR_COLOR_BURN:
  422.     case CAIRO_OPERATOR_HARD_LIGHT:
  423.     case CAIRO_OPERATOR_SOFT_LIGHT:
  424.     case CAIRO_OPERATOR_DIFFERENCE:
  425.     case CAIRO_OPERATOR_EXCLUSION:
  426.     case CAIRO_OPERATOR_HSL_HUE:
  427.     case CAIRO_OPERATOR_HSL_SATURATION:
  428.     case CAIRO_OPERATOR_HSL_COLOR:
  429.     case CAIRO_OPERATOR_HSL_LUMINOSITY:
  430.         return TRUE;
  431.     case CAIRO_OPERATOR_CLEAR:
  432.     case CAIRO_OPERATOR_SOURCE:
  433.     case CAIRO_OPERATOR_OUT:
  434.     case CAIRO_OPERATOR_IN:
  435.     case CAIRO_OPERATOR_DEST_IN:
  436.     case CAIRO_OPERATOR_DEST_ATOP:
  437.         return FALSE;
  438.     }
  439.  
  440.     ASSERT_NOT_REACHED;
  441.     return FALSE;
  442. }
  443.  
  444. uint32_t
  445. _cairo_operator_bounded_by_either (cairo_operator_t op)
  446. {
  447.     switch (op) {
  448.     default:
  449.         ASSERT_NOT_REACHED;
  450.     case CAIRO_OPERATOR_OVER:
  451.     case CAIRO_OPERATOR_ATOP:
  452.     case CAIRO_OPERATOR_DEST:
  453.     case CAIRO_OPERATOR_DEST_OVER:
  454.     case CAIRO_OPERATOR_DEST_OUT:
  455.     case CAIRO_OPERATOR_XOR:
  456.     case CAIRO_OPERATOR_ADD:
  457.     case CAIRO_OPERATOR_SATURATE:
  458.     case CAIRO_OPERATOR_MULTIPLY:
  459.     case CAIRO_OPERATOR_SCREEN:
  460.     case CAIRO_OPERATOR_OVERLAY:
  461.     case CAIRO_OPERATOR_DARKEN:
  462.     case CAIRO_OPERATOR_LIGHTEN:
  463.     case CAIRO_OPERATOR_COLOR_DODGE:
  464.     case CAIRO_OPERATOR_COLOR_BURN:
  465.     case CAIRO_OPERATOR_HARD_LIGHT:
  466.     case CAIRO_OPERATOR_SOFT_LIGHT:
  467.     case CAIRO_OPERATOR_DIFFERENCE:
  468.     case CAIRO_OPERATOR_EXCLUSION:
  469.     case CAIRO_OPERATOR_HSL_HUE:
  470.     case CAIRO_OPERATOR_HSL_SATURATION:
  471.     case CAIRO_OPERATOR_HSL_COLOR:
  472.     case CAIRO_OPERATOR_HSL_LUMINOSITY:
  473.         return CAIRO_OPERATOR_BOUND_BY_MASK | CAIRO_OPERATOR_BOUND_BY_SOURCE;
  474.     case CAIRO_OPERATOR_CLEAR:
  475.     case CAIRO_OPERATOR_SOURCE:
  476.         return CAIRO_OPERATOR_BOUND_BY_MASK;
  477.     case CAIRO_OPERATOR_OUT:
  478.     case CAIRO_OPERATOR_IN:
  479.     case CAIRO_OPERATOR_DEST_IN:
  480.     case CAIRO_OPERATOR_DEST_ATOP:
  481.         return 0;
  482.     }
  483.  
  484. }
  485.  
  486. #if DISABLE_SOME_FLOATING_POINT
  487. /* This function is identical to the C99 function lround(), except that it
  488.  * performs arithmetic rounding (floor(d + .5) instead of away-from-zero rounding) and
  489.  * has a valid input range of (INT_MIN, INT_MAX] instead of
  490.  * [INT_MIN, INT_MAX]. It is much faster on both x86 and FPU-less systems
  491.  * than other commonly used methods for rounding (lround, round, rint, lrint
  492.  * or float (d + 0.5)).
  493.  *
  494.  * The reason why this function is much faster on x86 than other
  495.  * methods is due to the fact that it avoids the fldcw instruction.
  496.  * This instruction incurs a large performance penalty on modern Intel
  497.  * processors due to how it prevents efficient instruction pipelining.
  498.  *
  499.  * The reason why this function is much faster on FPU-less systems is for
  500.  * an entirely different reason. All common rounding methods involve multiple
  501.  * floating-point operations. Each one of these operations has to be
  502.  * emulated in software, which adds up to be a large performance penalty.
  503.  * This function doesn't perform any floating-point calculations, and thus
  504.  * avoids this penalty.
  505.   */
  506. int
  507. _cairo_lround (double d)
  508. {
  509.     uint32_t top, shift_amount, output;
  510.     union {
  511.         double d;
  512.         uint64_t ui64;
  513.         uint32_t ui32[2];
  514.     } u;
  515.  
  516.     u.d = d;
  517.  
  518.     /* If the integer word order doesn't match the float word order, we swap
  519.      * the words of the input double. This is needed because we will be
  520.      * treating the whole double as a 64-bit unsigned integer. Notice that we
  521.      * use WORDS_BIGENDIAN to detect the integer word order, which isn't
  522.      * exactly correct because WORDS_BIGENDIAN refers to byte order, not word
  523.      * order. Thus, we are making the assumption that the byte order is the
  524.      * same as the integer word order which, on the modern machines that we
  525.      * care about, is OK.
  526.      */
  527. #if ( defined(FLOAT_WORDS_BIGENDIAN) && !defined(WORDS_BIGENDIAN)) || \
  528.     (!defined(FLOAT_WORDS_BIGENDIAN) &&  defined(WORDS_BIGENDIAN))
  529.     {
  530.         uint32_t temp = u.ui32[0];
  531.         u.ui32[0] = u.ui32[1];
  532.         u.ui32[1] = temp;
  533.     }
  534. #endif
  535.  
  536. #ifdef WORDS_BIGENDIAN
  537.     #define MSW (0) /* Most Significant Word */
  538.     #define LSW (1) /* Least Significant Word */
  539. #else
  540.     #define MSW (1)
  541.     #define LSW (0)
  542. #endif
  543.  
  544.     /* By shifting the most significant word of the input double to the
  545.      * right 20 places, we get the very "top" of the double where the exponent
  546.      * and sign bit lie.
  547.      */
  548.     top = u.ui32[MSW] >> 20;
  549.  
  550.     /* Here, we calculate how much we have to shift the mantissa to normalize
  551.      * it to an integer value. We extract the exponent "top" by masking out the
  552.      * sign bit, then we calculate the shift amount by subtracting the exponent
  553.      * from the bias. Notice that the correct bias for 64-bit doubles is
  554.      * actually 1075, but we use 1053 instead for two reasons:
  555.      *
  556.      *  1) To perform rounding later on, we will first need the target
  557.      *     value in a 31.1 fixed-point format. Thus, the bias needs to be one
  558.      *     less: (1075 - 1: 1074).
  559.      *
  560.      *  2) To avoid shifting the mantissa as a full 64-bit integer (which is
  561.      *     costly on certain architectures), we break the shift into two parts.
  562.      *     First, the upper and lower parts of the mantissa are shifted
  563.      *     individually by a constant amount that all valid inputs will require
  564.      *     at the very least. This amount is chosen to be 21, because this will
  565.      *     allow the two parts of the mantissa to later be combined into a
  566.      *     single 32-bit representation, on which the remainder of the shift
  567.      *     will be performed. Thus, we decrease the bias by an additional 21:
  568.      *     (1074 - 21: 1053).
  569.      */
  570.     shift_amount = 1053 - (top & 0x7FF);
  571.  
  572.     /* We are done with the exponent portion in "top", so here we shift it off
  573.      * the end.
  574.      */
  575.     top >>= 11;
  576.  
  577.     /* Before we perform any operations on the mantissa, we need to OR in
  578.      * the implicit 1 at the top (see the IEEE-754 spec). We needn't mask
  579.      * off the sign bit nor the exponent bits because these higher bits won't
  580.      * make a bit of difference in the rest of our calculations.
  581.      */
  582.     u.ui32[MSW] |= 0x100000;
  583.  
  584.     /* If the input double is negative, we have to decrease the mantissa
  585.      * by a hair. This is an important part of performing arithmetic rounding,
  586.      * as negative numbers must round towards positive infinity in the
  587.      * halfwase case of -x.5. Since "top" contains only the sign bit at this
  588.      * point, we can just decrease the mantissa by the value of "top".
  589.      */
  590.     u.ui64 -= top;
  591.  
  592.     /* By decrementing "top", we create a bitmask with a value of either
  593.      * 0x0 (if the input was negative) or 0xFFFFFFFF (if the input was positive
  594.      * and thus the unsigned subtraction underflowed) that we'll use later.
  595.      */
  596.     top--;
  597.  
  598.     /* Here, we shift the mantissa by the constant value as described above.
  599.      * We can emulate a 64-bit shift right by 21 through shifting the top 32
  600.      * bits left 11 places and ORing in the bottom 32 bits shifted 21 places
  601.      * to the right. Both parts of the mantissa are now packed into a single
  602.      * 32-bit integer. Although we severely truncate the lower part in the
  603.      * process, we still have enough significant bits to perform the conversion
  604.      * without error (for all valid inputs).
  605.      */
  606.     output = (u.ui32[MSW] << 11) | (u.ui32[LSW] >> 21);
  607.  
  608.     /* Next, we perform the shift that converts the X.Y fixed-point number
  609.      * currently found in "output" to the desired 31.1 fixed-point format
  610.      * needed for the following rounding step. It is important to consider
  611.      * all possible values for "shift_amount" at this point:
  612.      *
  613.      * - {shift_amount < 0} Since shift_amount is an unsigned integer, it
  614.      *   really can't have a value less than zero. But, if the shift_amount
  615.      *   calculation above caused underflow (which would happen with
  616.      *   input > INT_MAX or input <= INT_MIN) then shift_amount will now be
  617.      *   a very large number, and so this shift will result in complete
  618.      *   garbage. But that's OK, as the input was out of our range, so our
  619.      *   output is undefined.
  620.      *
  621.      * - {shift_amount > 31} If the magnitude of the input was very small
  622.      *   (i.e. |input| << 1.0), shift_amount will have a value greater than
  623.      *   31. Thus, this shift will also result in garbage. After performing
  624.      *   the shift, we will zero-out "output" if this is the case.
  625.      *
  626.      * - {0 <= shift_amount < 32} In this case, the shift will properly convert
  627.      *   the mantissa into a 31.1 fixed-point number.
  628.      */
  629.     output >>= shift_amount;
  630.  
  631.     /* This is where we perform rounding with the 31.1 fixed-point number.
  632.      * Since what we're after is arithmetic rounding, we simply add the single
  633.      * fractional bit into the integer part of "output", and just keep the
  634.      * integer part.
  635.      */
  636.     output = (output >> 1) + (output & 1);
  637.  
  638.     /* Here, we zero-out the result if the magnitude if the input was very small
  639.      * (as explained in the section above). Notice that all input out of the
  640.      * valid range is also caught by this condition, which means we produce 0
  641.      * for all invalid input, which is a nice side effect.
  642.      *
  643.      * The most straightforward way to do this would be:
  644.      *
  645.      *      if (shift_amount > 31)
  646.      *          output = 0;
  647.      *
  648.      * But we can use a little trick to avoid the potential branch. The
  649.      * expression (shift_amount > 31) will be either 1 or 0, which when
  650.      * decremented will be either 0x0 or 0xFFFFFFFF (unsigned underflow),
  651.      * which can be used to conditionally mask away all the bits in "output"
  652.      * (in the 0x0 case), effectively zeroing it out. Certain, compilers would
  653.      * have done this for us automatically.
  654.      */
  655.     output &= ((shift_amount > 31) - 1);
  656.  
  657.     /* If the input double was a negative number, then we have to negate our
  658.      * output. The most straightforward way to do this would be:
  659.      *
  660.      *      if (!top)
  661.      *          output = -output;
  662.      *
  663.      * as "top" at this point is either 0x0 (if the input was negative) or
  664.      * 0xFFFFFFFF (if the input was positive). But, we can use a trick to
  665.      * avoid the branch. Observe that the following snippet of code has the
  666.      * same effect as the reference snippet above:
  667.      *
  668.      *      if (!top)
  669.      *          output = 0 - output;
  670.      *      else
  671.      *          output = output - 0;
  672.      *
  673.      * Armed with the bitmask found in "top", we can condense the two statements
  674.      * into the following:
  675.      *
  676.      *      output = (output & top) - (output & ~top);
  677.      *
  678.      * where, in the case that the input double was negative, "top" will be 0,
  679.      * and the statement will be equivalent to:
  680.      *
  681.      *      output = (0) - (output);
  682.      *
  683.      * and if the input double was positive, "top" will be 0xFFFFFFFF, and the
  684.      * statement will be equivalent to:
  685.      *
  686.      *      output = (output) - (0);
  687.      *
  688.      * Which, as pointed out earlier, is equivalent to the original reference
  689.      * snippet.
  690.      */
  691.     output = (output & top) - (output & ~top);
  692.  
  693.     return output;
  694. #undef MSW
  695. #undef LSW
  696. }
  697. #endif
  698.  
  699. /* Convert a 32-bit IEEE single precision floating point number to a
  700.  * 'half' representation (s10.5)
  701.  */
  702. uint16_t
  703. _cairo_half_from_float (float f)
  704. {
  705.     union {
  706.         uint32_t ui;
  707.         float f;
  708.     } u;
  709.     int s, e, m;
  710.  
  711.     u.f = f;
  712.     s =  (u.ui >> 16) & 0x00008000;
  713.     e = ((u.ui >> 23) & 0x000000ff) - (127 - 15);
  714.     m =   u.ui        & 0x007fffff;
  715.     if (e <= 0) {
  716.         if (e < -10) {
  717.             /* underflow */
  718.             return 0;
  719.         }
  720.  
  721.         m = (m | 0x00800000) >> (1 - e);
  722.  
  723.         /* round to nearest, round 0.5 up. */
  724.         if (m &  0x00001000)
  725.             m += 0x00002000;
  726.         return s | (m >> 13);
  727.     } else if (e == 0xff - (127 - 15)) {
  728.         if (m == 0) {
  729.             /* infinity */
  730.             return s | 0x7c00;
  731.         } else {
  732.             /* nan */
  733.             m >>= 13;
  734.             return s | 0x7c00 | m | (m == 0);
  735.         }
  736.     } else {
  737.         /* round to nearest, round 0.5 up. */
  738.         if (m &  0x00001000) {
  739.             m += 0x00002000;
  740.  
  741.             if (m & 0x00800000) {
  742.                 m =  0;
  743.                 e += 1;
  744.             }
  745.         }
  746.  
  747.         if (e > 30) {
  748.             /* overflow -> infinity */
  749.             return s | 0x7c00;
  750.         }
  751.  
  752.         return s | (e << 10) | (m >> 13);
  753.     }
  754. }
  755.  
  756.  
  757. #ifdef _WIN32
  758.  
  759. #define WIN32_LEAN_AND_MEAN
  760. /* We require Windows 2000 features such as ETO_PDY */
  761. #if !defined(WINVER) || (WINVER < 0x0500)
  762. # define WINVER 0x0500
  763. #endif
  764. #if !defined(_WIN32_WINNT) || (_WIN32_WINNT < 0x0500)
  765. # define _WIN32_WINNT 0x0500
  766. #endif
  767.  
  768. #include <windows.h>
  769. #include <io.h>
  770.  
  771. #if !_WIN32_WCE
  772. /* tmpfile() replacement for Windows.
  773.  *
  774.  * On Windows tmpfile() creates the file in the root directory. This
  775.  * may fail due to unsufficient privileges. However, this isn't a
  776.  * problem on Windows CE so we don't use it there.
  777.  */
  778. FILE *
  779. _cairo_win32_tmpfile (void)
  780. {
  781.     DWORD path_len;
  782.     WCHAR path_name[MAX_PATH + 1];
  783.     WCHAR file_name[MAX_PATH + 1];
  784.     HANDLE handle;
  785.     int fd;
  786.     FILE *fp;
  787.  
  788.     path_len = GetTempPathW (MAX_PATH, path_name);
  789.     if (path_len <= 0 || path_len >= MAX_PATH)
  790.         return NULL;
  791.  
  792.     if (GetTempFileNameW (path_name, L"ps_", 0, file_name) == 0)
  793.         return NULL;
  794.  
  795.     handle = CreateFileW (file_name,
  796.                          GENERIC_READ | GENERIC_WRITE,
  797.                          0,
  798.                          NULL,
  799.                          CREATE_ALWAYS,
  800.                          FILE_ATTRIBUTE_NORMAL | FILE_FLAG_DELETE_ON_CLOSE,
  801.                          NULL);
  802.     if (handle == INVALID_HANDLE_VALUE) {
  803.         DeleteFileW (file_name);
  804.         return NULL;
  805.     }
  806.  
  807.     fd = _open_osfhandle((intptr_t) handle, 0);
  808.     if (fd < 0) {
  809.         CloseHandle (handle);
  810.         return NULL;
  811.     }
  812.  
  813.     fp = fdopen(fd, "w+b");
  814.     if (fp == NULL) {
  815.         _close(fd);
  816.         return NULL;
  817.     }
  818.  
  819.     return fp;
  820. }
  821. #endif /* !_WIN32_WCE */
  822.  
  823. #endif /* _WIN32 */
  824.  
  825. typedef struct _cairo_intern_string {
  826.     cairo_hash_entry_t hash_entry;
  827.     int len;
  828.     char *string;
  829. } cairo_intern_string_t;
  830.  
  831. static cairo_hash_table_t *_cairo_intern_string_ht;
  832.  
  833. static unsigned long
  834. _intern_string_hash (const char *str, int len)
  835. {
  836.     const signed char *p = (const signed char *) str;
  837.     unsigned int h = *p;
  838.  
  839.     for (p += 1; --len; p++)
  840.         h = (h << 5) - h + *p;
  841.  
  842.     return h;
  843. }
  844.  
  845. static cairo_bool_t
  846. _intern_string_equal (const void *_a, const void *_b)
  847. {
  848.     const cairo_intern_string_t *a = _a;
  849.     const cairo_intern_string_t *b = _b;
  850.  
  851.     if (a->len != b->len)
  852.         return FALSE;
  853.  
  854.     return memcmp (a->string, b->string, a->len) == 0;
  855. }
  856.  
  857. cairo_status_t
  858. _cairo_intern_string (const char **str_inout, int len)
  859. {
  860.     char *str = (char *) *str_inout;
  861.     cairo_intern_string_t tmpl, *istring;
  862.     cairo_status_t status = CAIRO_STATUS_SUCCESS;
  863.  
  864.     if (CAIRO_INJECT_FAULT ())
  865.         return _cairo_error (CAIRO_STATUS_NO_MEMORY);
  866.  
  867.     if (len < 0)
  868.         len = strlen (str);
  869.     tmpl.hash_entry.hash = _intern_string_hash (str, len);
  870.     tmpl.len = len;
  871.     tmpl.string = (char *) str;
  872.  
  873.     CAIRO_MUTEX_LOCK (_cairo_intern_string_mutex);
  874.     if (_cairo_intern_string_ht == NULL) {
  875.         _cairo_intern_string_ht = _cairo_hash_table_create (_intern_string_equal);
  876.         if (unlikely (_cairo_intern_string_ht == NULL)) {
  877.             status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
  878.             goto BAIL;
  879.         }
  880.     }
  881.  
  882.     istring = _cairo_hash_table_lookup (_cairo_intern_string_ht,
  883.                                         &tmpl.hash_entry);
  884.     if (istring == NULL) {
  885.         istring = malloc (sizeof (cairo_intern_string_t) + len + 1);
  886.         if (likely (istring != NULL)) {
  887.             istring->hash_entry.hash = tmpl.hash_entry.hash;
  888.             istring->len = tmpl.len;
  889.             istring->string = (char *) (istring + 1);
  890.             memcpy (istring->string, str, len);
  891.             istring->string[len] = '\0';
  892.  
  893.             status = _cairo_hash_table_insert (_cairo_intern_string_ht,
  894.                                                &istring->hash_entry);
  895.             if (unlikely (status)) {
  896.                 free (istring);
  897.                 goto BAIL;
  898.             }
  899.         } else {
  900.             status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
  901.             goto BAIL;
  902.         }
  903.     }
  904.  
  905.     *str_inout = istring->string;
  906.  
  907.   BAIL:
  908.     CAIRO_MUTEX_UNLOCK (_cairo_intern_string_mutex);
  909.     return status;
  910. }
  911.  
  912. static void
  913. _intern_string_pluck (void *entry, void *closure)
  914. {
  915.     _cairo_hash_table_remove (closure, entry);
  916.     free (entry);
  917. }
  918.  
  919. void
  920. _cairo_intern_string_reset_static_data (void)
  921. {
  922.     CAIRO_MUTEX_LOCK (_cairo_intern_string_mutex);
  923.     if (_cairo_intern_string_ht != NULL) {
  924.         _cairo_hash_table_foreach (_cairo_intern_string_ht,
  925.                                    _intern_string_pluck,
  926.                                    _cairo_intern_string_ht);
  927.         _cairo_hash_table_destroy(_cairo_intern_string_ht);
  928.         _cairo_intern_string_ht = NULL;
  929.     }
  930.     CAIRO_MUTEX_UNLOCK (_cairo_intern_string_mutex);
  931. }
  932.