LCOV - code coverage report
Current view: directory - gfx/harfbuzz/src - hb-shape.cc (source / functions) Found Hit Coverage
Test: app.info Lines: 41 9 22.0 %
Date: 2012-06-02 Functions: 7 3 42.9 %

       1                 : /*
       2                 :  * Copyright © 2009  Red Hat, Inc.
       3                 :  *
       4                 :  *  This is part of HarfBuzz, a text shaping library.
       5                 :  *
       6                 :  * Permission is hereby granted, without written agreement and without
       7                 :  * license or royalty fees, to use, copy, modify, and distribute this
       8                 :  * software and its documentation for any purpose, provided that the
       9                 :  * above copyright notice and the following two paragraphs appear in
      10                 :  * all copies of this software.
      11                 :  *
      12                 :  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
      13                 :  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
      14                 :  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
      15                 :  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
      16                 :  * DAMAGE.
      17                 :  *
      18                 :  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
      19                 :  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
      20                 :  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
      21                 :  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
      22                 :  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
      23                 :  *
      24                 :  * Red Hat Author(s): Behdad Esfahbod
      25                 :  */
      26                 : 
      27                 : #include "hb-private.hh"
      28                 : 
      29                 : #include "hb-shape.h"
      30                 : 
      31                 : #include "hb-buffer-private.hh"
      32                 : 
      33                 : #ifdef HAVE_GRAPHITE
      34                 : #include "hb-graphite2.h"
      35                 : #endif
      36                 : #ifdef HAVE_UNISCRIBE
      37                 : # include "hb-uniscribe.h"
      38                 : #endif
      39                 : #ifdef HAVE_OT
      40                 : # include "hb-ot-shape.h"
      41                 : #endif
      42                 : #include "hb-fallback-shape-private.hh"
      43                 : 
      44                 : typedef hb_bool_t (*hb_shape_func_t) (hb_font_t          *font,
      45                 :                                       hb_buffer_t        *buffer,
      46                 :                                       const hb_feature_t *features,
      47                 :                                       unsigned int        num_features,
      48                 :                                       const char * const *shaper_options);
      49                 : 
      50                 : #define HB_SHAPER_IMPLEMENT(name) {#name, hb_##name##_shape}
      51                 : static struct hb_shaper_pair_t {
      52                 :   char name[16];
      53                 :   hb_shape_func_t func;
      54                 : } shapers[] = {
      55                 :   /* v--- Add new shapers in the right place here */
      56                 : #ifdef HAVE_GRAPHITE
      57                 :   HB_SHAPER_IMPLEMENT (graphite),
      58                 : #endif
      59                 : #ifdef HAVE_UNISCRIBE
      60                 :   HB_SHAPER_IMPLEMENT (uniscribe),
      61                 : #endif
      62                 : #ifdef HAVE_OT
      63                 :   HB_SHAPER_IMPLEMENT (ot),
      64                 : #endif
      65                 :   HB_SHAPER_IMPLEMENT (fallback) /* should be last */
      66                 : };
      67                 : #undef HB_SHAPER_IMPLEMENT
      68                 : 
      69                 : static struct static_shaper_list_t
      70                 : {
      71            1464 :   static_shaper_list_t (void)
      72                 :   {
      73            1464 :     char *env = getenv ("HB_SHAPER_LIST");
      74            1464 :     if (env && *env)
      75                 :     {
      76                 :        /* Reorder shaper list to prefer requested shaper list. */
      77               0 :       unsigned int i = 0;
      78               0 :       char *end, *p = env;
      79               0 :       for (;;) {
      80               0 :         end = strchr (p, ',');
      81               0 :         if (!end)
      82               0 :           end = p + strlen (p);
      83                 : 
      84               0 :         for (unsigned int j = i; j < ARRAY_LENGTH (shapers); j++)
      85               0 :           if (end - p == (int) strlen (shapers[j].name) &&
      86               0 :               0 == strncmp (shapers[j].name, p, end - p))
      87                 :           {
      88                 :             /* Reorder this shaper to position i */
      89               0 :            struct hb_shaper_pair_t t = shapers[j];
      90               0 :            memmove (&shapers[i + 1], &shapers[i], sizeof (shapers[i]) * (j - i));
      91               0 :            shapers[i] = t;
      92               0 :            i++;
      93                 :           }
      94                 : 
      95               0 :         if (!*end)
      96                 :           break;
      97                 :         else
      98               0 :           p = end + 1;
      99                 :       }
     100                 :     }
     101                 : 
     102                 :     ASSERT_STATIC ((ARRAY_LENGTH (shapers) + 1) * sizeof (*shaper_list) <= sizeof (shaper_list));
     103                 :     unsigned int i;
     104            4392 :     for (i = 0; i < ARRAY_LENGTH (shapers); i++)
     105            2928 :       shaper_list[i] = shapers[i].name;
     106            1464 :     shaper_list[i] = NULL;
     107            1464 :   }
     108                 : 
     109                 :   const char *shaper_list[ARRAY_LENGTH (shapers) + 1];
     110            1464 : } static_shaper_list;
     111                 : 
     112                 : const char **
     113               0 : hb_shape_list_shapers (void)
     114                 : {
     115               0 :   return static_shaper_list.shaper_list;
     116                 : }
     117                 : 
     118                 : hb_bool_t
     119               0 : hb_shape_full (hb_font_t          *font,
     120                 :                hb_buffer_t        *buffer,
     121                 :                const hb_feature_t *features,
     122                 :                unsigned int        num_features,
     123                 :                const char * const *shaper_options,
     124                 :                const char * const *shaper_list)
     125                 : {
     126               0 :   if (likely (!shaper_list)) {
     127               0 :     for (unsigned int i = 0; i < ARRAY_LENGTH (shapers); i++)
     128               0 :       if (likely (shapers[i].func (font, buffer,
     129                 :                                    features, num_features,
     130                 :                                    shaper_options)))
     131               0 :         return TRUE;
     132                 :   } else {
     133               0 :     while (*shaper_list) {
     134               0 :       for (unsigned int i = 0; i < ARRAY_LENGTH (shapers); i++)
     135               0 :         if (0 == strcmp (*shaper_list, shapers[i].name)) {
     136               0 :           if (likely (shapers[i].func (font, buffer,
     137                 :                                        features, num_features,
     138                 :                                        shaper_options)))
     139               0 :             return TRUE;
     140               0 :           break;
     141                 :         }
     142               0 :       shaper_list++;
     143                 :     }
     144                 :   }
     145               0 :   return FALSE;
     146                 : }
     147                 : 
     148                 : void
     149               0 : hb_shape (hb_font_t           *font,
     150                 :           hb_buffer_t         *buffer,
     151                 :           const hb_feature_t  *features,
     152                 :           unsigned int         num_features)
     153                 : {
     154               0 :   hb_shape_full (font, buffer, features, num_features, NULL, NULL);
     155            4392 : }

Generated by: LCOV version 1.7