LCOV - code coverage report
Current view: directory - gfx/harfbuzz/src - hb-buffer-private.hh (source / functions) Found Hit Coverage
Test: app.info Lines: 10 0 0.0 %
Date: 2012-06-02 Functions: 5 0 0.0 %

       1                 : /*
       2                 :  * Copyright © 1998-2004  David Turner and Werner Lemberg
       3                 :  * Copyright © 2004,2007,2009,2010  Red Hat, Inc.
       4                 :  * Copyright © 2011  Google, Inc.
       5                 :  *
       6                 :  *  This is part of HarfBuzz, a text shaping library.
       7                 :  *
       8                 :  * Permission is hereby granted, without written agreement and without
       9                 :  * license or royalty fees, to use, copy, modify, and distribute this
      10                 :  * software and its documentation for any purpose, provided that the
      11                 :  * above copyright notice and the following two paragraphs appear in
      12                 :  * all copies of this software.
      13                 :  *
      14                 :  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
      15                 :  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
      16                 :  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
      17                 :  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
      18                 :  * DAMAGE.
      19                 :  *
      20                 :  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
      21                 :  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
      22                 :  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
      23                 :  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
      24                 :  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
      25                 :  *
      26                 :  * Red Hat Author(s): Owen Taylor, Behdad Esfahbod
      27                 :  * Google Author(s): Behdad Esfahbod
      28                 :  */
      29                 : 
      30                 : #ifndef HB_BUFFER_PRIVATE_HH
      31                 : #define HB_BUFFER_PRIVATE_HH
      32                 : 
      33                 : #include "hb-private.hh"
      34                 : #include "hb-buffer.h"
      35                 : #include "hb-object-private.hh"
      36                 : #include "hb-unicode-private.hh"
      37                 : 
      38                 : 
      39                 : 
      40                 : ASSERT_STATIC (sizeof (hb_glyph_info_t) == 20);
      41                 : ASSERT_STATIC (sizeof (hb_glyph_info_t) == sizeof (hb_glyph_position_t));
      42                 : 
      43                 : typedef struct _hb_segment_properties_t {
      44                 :     hb_direction_t      direction;
      45                 :     hb_script_t         script;
      46                 :     hb_language_t       language;
      47                 : } hb_segment_properties_t;
      48                 : 
      49                 : 
      50                 : struct _hb_buffer_t {
      51                 :   hb_object_header_t header;
      52                 : 
      53                 :   /* Information about how the text in the buffer should be treated */
      54                 : 
      55                 :   hb_unicode_funcs_t *unicode; /* Unicode functions */
      56                 :   hb_segment_properties_t props; /* Script, language, direction */
      57                 : 
      58                 :   /* Buffer contents */
      59                 : 
      60                 :   bool in_error; /* Allocation failed */
      61                 :   bool have_output; /* Whether we have an output buffer going on */
      62                 :   bool have_positions; /* Whether we have positions */
      63                 : 
      64                 :   unsigned int idx; /* Cursor into ->info and ->pos arrays */
      65                 :   unsigned int len; /* Length of ->info and ->pos arrays */
      66                 :   unsigned int out_len; /* Length of ->out array if have_output */
      67                 : 
      68                 :   unsigned int allocated; /* Length of allocated arrays */
      69                 :   hb_glyph_info_t     *info;
      70                 :   hb_glyph_info_t     *out_info;
      71                 :   hb_glyph_position_t *pos;
      72                 : 
      73                 :   unsigned int serial;
      74                 :   uint8_t allocated_var_bytes[8];
      75                 :   const char *allocated_var_owner[8];
      76                 : 
      77                 : 
      78                 :   /* Methods */
      79                 : 
      80                 :   HB_INTERNAL void reset (void);
      81                 : 
      82               0 :   inline unsigned int backtrack_len (void) const
      83               0 :   { return have_output? out_len : idx; }
      84               0 :   inline unsigned int next_serial (void) { return serial++; }
      85                 : 
      86                 :   HB_INTERNAL void allocate_var (unsigned int byte_i, unsigned int count, const char *owner);
      87                 :   HB_INTERNAL void deallocate_var (unsigned int byte_i, unsigned int count, const char *owner);
      88                 :   HB_INTERNAL void deallocate_var_all (void);
      89                 : 
      90                 :   HB_INTERNAL void add (hb_codepoint_t  codepoint,
      91                 :                         hb_mask_t       mask,
      92                 :                         unsigned int    cluster);
      93                 : 
      94                 :   HB_INTERNAL void reverse_range (unsigned int start, unsigned int end);
      95                 :   HB_INTERNAL void reverse (void);
      96                 :   HB_INTERNAL void reverse_clusters (void);
      97                 :   HB_INTERNAL void guess_properties (void);
      98                 : 
      99                 :   HB_INTERNAL void swap_buffers (void);
     100                 :   HB_INTERNAL void clear_output (void);
     101                 :   HB_INTERNAL void clear_positions (void);
     102                 :   HB_INTERNAL void replace_glyphs_be16 (unsigned int num_in,
     103                 :                                         unsigned int num_out,
     104                 :                                         const uint16_t *glyph_data_be);
     105                 :   HB_INTERNAL void replace_glyphs (unsigned int num_in,
     106                 :                                    unsigned int num_out,
     107                 :                                    const uint16_t *glyph_data);
     108                 :   HB_INTERNAL void replace_glyph (hb_codepoint_t glyph_index);
     109                 :   /* Makes a copy of the glyph at idx to output and replace glyph_index */
     110                 :   HB_INTERNAL void output_glyph (hb_codepoint_t glyph_index);
     111                 :   /* Copies glyph at idx to output but doesn't advance idx */
     112                 :   HB_INTERNAL void copy_glyph (void);
     113                 :   /* Copies glyph at idx to output and advance idx.
     114                 :    * If there's no output, just advance idx. */
     115                 :   HB_INTERNAL void next_glyph (void);
     116                 :   /* Advance idx without copying to output. */
     117               0 :   inline void skip_glyph (void) { idx++; }
     118                 : 
     119               0 :   inline void reset_masks (hb_mask_t mask)
     120                 :   {
     121               0 :     for (unsigned int j = 0; j < len; j++)
     122               0 :       info[j].mask = mask;
     123               0 :   }
     124                 :   inline void add_masks (hb_mask_t mask)
     125                 :   {
     126                 :     for (unsigned int j = 0; j < len; j++)
     127                 :       info[j].mask |= mask;
     128                 :   }
     129                 :   HB_INTERNAL void set_masks (hb_mask_t value,
     130                 :                               hb_mask_t mask,
     131                 :                               unsigned int cluster_start,
     132                 :                               unsigned int cluster_end);
     133                 : 
     134                 :   /* Internal methods */
     135                 :   HB_INTERNAL bool enlarge (unsigned int size);
     136                 : 
     137               0 :   inline bool ensure (unsigned int size)
     138               0 :   { return likely (size <= allocated) ? TRUE : enlarge (size); }
     139                 : 
     140                 :   HB_INTERNAL bool make_room_for (unsigned int num_in, unsigned int num_out);
     141                 : 
     142                 :   HB_INTERNAL void *get_scratch_buffer (unsigned int *size);
     143                 : };
     144                 : 
     145                 : 
     146                 : #define HB_BUFFER_XALLOCATE_VAR(b, func, var, owner) \
     147                 :   b->func (offsetof (hb_glyph_info_t, var) - offsetof(hb_glyph_info_t, var1), \
     148                 :            sizeof (b->info[0].var), owner)
     149                 : #define HB_BUFFER_ALLOCATE_VAR(b, var) \
     150                 :         HB_BUFFER_XALLOCATE_VAR (b, allocate_var, var (), #var)
     151                 : #define HB_BUFFER_DEALLOCATE_VAR(b, var) \
     152                 :         HB_BUFFER_XALLOCATE_VAR (b, deallocate_var, var (), #var)
     153                 : 
     154                 : 
     155                 : 
     156                 : #endif /* HB_BUFFER_PRIVATE_HH */

Generated by: LCOV version 1.7