laag-freetype2 2.9.1.1

data/vendor/git.savannah.nongnu.org/r/freetype/freetype2/src/psaux/psblues.h

@@ -0,0 +1,185 @@
+/***************************************************************************/
+/*                                                                         */
+/*  psblues.h                                                              */
+/*                                                                         */
+/*    Adobe's code for handling Blue Zones (specification).                */
+/*                                                                         */
+/*  Copyright 2009-2013 Adobe Systems Incorporated.                        */
+/*                                                                         */
+/*  This software, and all works of authorship, whether in source or       */
+/*  object code form as indicated by the copyright notice(s) included      */
+/*  herein (collectively, the "Work") is made available, and may only be   */
+/*  used, modified, and distributed under the FreeType Project License,    */
+/*  LICENSE.TXT.  Additionally, subject to the terms and conditions of the */
+/*  FreeType Project License, each contributor to the Work hereby grants   */
+/*  to any individual or legal entity exercising permissions granted by    */
+/*  the FreeType Project License and this section (hereafter, "You" or     */
+/*  "Your") a perpetual, worldwide, non-exclusive, no-charge,              */
+/*  royalty-free, irrevocable (except as stated in this section) patent    */
+/*  license to make, have made, use, offer to sell, sell, import, and      */
+/*  otherwise transfer the Work, where such license applies only to those  */
+/*  patent claims licensable by such contributor that are necessarily      */
+/*  infringed by their contribution(s) alone or by combination of their    */
+/*  contribution(s) with the Work to which such contribution(s) was        */
+/*  submitted.  If You institute patent litigation against any entity      */
+/*  (including a cross-claim or counterclaim in a lawsuit) alleging that   */
+/*  the Work or a contribution incorporated within the Work constitutes    */
+/*  direct or contributory patent infringement, then any patent licenses   */
+/*  granted to You under this License for that Work shall terminate as of  */
+/*  the date such litigation is filed.                                     */
+/*                                                                         */
+/*  By using, modifying, or distributing the Work you indicate that you    */
+/*  have read and understood the terms and conditions of the               */
+/*  FreeType Project License as well as those provided in this section,    */
+/*  and you accept them fully.                                             */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*
+   * A `CF2_Blues' object stores the blue zones (horizontal alignment
+   * zones) of a font.  These are specified in the CFF private dictionary
+   * by `BlueValues', `OtherBlues', `FamilyBlues', and `FamilyOtherBlues'.
+   * Each zone is defined by a top and bottom edge in character space.
+   * Further, each zone is either a top zone or a bottom zone, as recorded
+   * by `bottomZone'.
+   *
+   * The maximum number of `BlueValues' and `FamilyBlues' is 7 each.
+   * However, these are combined to produce a total of 7 zones.
+   * Similarly, the maximum number of `OtherBlues' and `FamilyOtherBlues'
+   * is 5 and these are combined to produce an additional 5 zones.
+   *
+   * Blue zones are used to `capture' hints and force them to a common
+   * alignment point.  This alignment is recorded in device space in
+   * `dsFlatEdge'.  Except for this value, a `CF2_Blues' object could be
+   * constructed independently of scaling.  Construction may occur once
+   * the matrix is known.  Other features implemented in the Capture
+   * method are overshoot suppression, overshoot enforcement, and Blue
+   * Boost.
+   *
+   * Capture is determined by `BlueValues' and `OtherBlues', but the
+   * alignment point may be adjusted to the scaled flat edge of
+   * `FamilyBlues' or `FamilyOtherBlues'.  No alignment is done to the
+   * curved edge of a zone.
+   *
+   */
+
+
+#ifndef PSBLUES_H_
+#define PSBLUES_H_
+
+
+#include "psglue.h"
+
+
+FT_BEGIN_HEADER
+
+
+  /*
+   * `CF2_Hint' is shared by `cf2hints.h' and
+   * `cf2blues.h', but `cf2blues.h' depends on
+   * `cf2hints.h', so define it here.  Note: The typedef is in
+   * `cf2glue.h'.
+   *
+   */
+  enum
+  {
+    CF2_GhostBottom = 0x1,  /* a single bottom edge           */
+    CF2_GhostTop    = 0x2,  /* a single top edge              */
+    CF2_PairBottom  = 0x4,  /* the bottom edge of a stem hint */
+    CF2_PairTop     = 0x8,  /* the top edge of a stem hint    */
+    CF2_Locked      = 0x10, /* this edge has been aligned     */
+                            /* by a blue zone                 */
+    CF2_Synthetic   = 0x20  /* this edge was synthesized      */
+  };
+
+
+  /*
+   * Default value for OS/2 typoAscender/Descender when their difference
+   * is not equal to `unitsPerEm'.  The default is based on -250 and 1100
+   * in `CF2_Blues', assuming 1000 units per em here.
+   *
+   */
+  enum
+  {
+    CF2_ICF_Top    = cf2_intToFixed(  880 ),
+    CF2_ICF_Bottom = cf2_intToFixed( -120 )
+  };
+
+
+  /*
+   * Constant used for hint adjustment and for synthetic em box hint
+   * placement.
+   */
+#define CF2_MIN_COUNTER  cf2_doubleToFixed( 0.5 )
+
+
+  /* shared typedef is in cf2glue.h */
+  struct  CF2_HintRec_
+  {
+    CF2_UInt  flags;  /* attributes of the edge            */
+    size_t    index;  /* index in original stem hint array */
+                      /* (if not synthetic)                */
+    CF2_Fixed  csCoord;
+    CF2_Fixed  dsCoord;
+    CF2_Fixed  scale;
+  };
+
+
+  typedef struct  CF2_BlueRec_
+  {
+    CF2_Fixed  csBottomEdge;
+    CF2_Fixed  csTopEdge;
+    CF2_Fixed  csFlatEdge; /* may be from either local or Family zones */
+    CF2_Fixed  dsFlatEdge; /* top edge of bottom zone or bottom edge   */
+                           /* of top zone (rounded)                    */
+    FT_Bool  bottomZone;
+
+  } CF2_BlueRec;
+
+
+  /* max total blue zones is 12 */
+  enum
+  {
+    CF2_MAX_BLUES      = 7,
+    CF2_MAX_OTHERBLUES = 5
+  };
+
+
+  typedef struct  CF2_BluesRec_
+  {
+    CF2_Fixed  scale;
+    CF2_UInt   count;
+    FT_Bool    suppressOvershoot;
+    FT_Bool    doEmBoxHints;
+
+    CF2_Fixed  blueScale;
+    CF2_Fixed  blueShift;
+    CF2_Fixed  blueFuzz;
+
+    CF2_Fixed  boost;
+
+    CF2_HintRec  emBoxTopEdge;
+    CF2_HintRec  emBoxBottomEdge;
+
+    CF2_BlueRec  zone[CF2_MAX_BLUES + CF2_MAX_OTHERBLUES];
+
+  } CF2_BluesRec, *CF2_Blues;
+
+
+  FT_LOCAL( void )
+  cf2_blues_init( CF2_Blues  blues,
+                  CF2_Font   font );
+  FT_LOCAL( FT_Bool )
+  cf2_blues_capture( const CF2_Blues  blues,
+                     CF2_Hint         bottomHintEdge,
+                     CF2_Hint         topHintEdge );
+
+
+FT_END_HEADER
+
+
+#endif /* PSBLUES_H_ */
+
+
+/* END */

data/vendor/git.savannah.nongnu.org/r/freetype/freetype2/src/psaux/psconv.c

@@ -0,0 +1,611 @@
+/***************************************************************************/
+/*                                                                         */
+/*  psconv.c                                                               */
+/*                                                                         */
+/*    Some convenience conversions (body).                                 */
+/*                                                                         */
+/*  Copyright 2006-2018 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_POSTSCRIPT_AUX_H
+#include FT_INTERNAL_DEBUG_H
+
+#include "psconv.h"
+#include "psauxerr.h"
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
+  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
+  /* messages during execution.                                            */
+  /*                                                                       */
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_psconv
+
+
+  /* The following array is used by various functions to quickly convert */
+  /* digits (both decimal and non-decimal) into numbers.                 */
+
+#if 'A' == 65
+  /* ASCII */
+
+  static const FT_Char  ft_char_table[128] =
+  {
+    /* 0x00 */
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+     0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1,
+    -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+    25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1,
+    -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+    25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1,
+  };
+
+  /* no character >= 0x80 can represent a valid number */
+#define OP  >=
+
+#endif /* 'A' == 65 */
+
+#if 'A' == 193
+  /* EBCDIC */
+
+  static const FT_Char  ft_char_table[128] =
+  {
+    /* 0x80 */
+    -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, -1, -1, -1, -1, -1, -1,
+    -1, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, -1, -1, -1, -1,
+    -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, -1, -1, -1, -1, -1, -1,
+    -1, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, -1, -1, -1, -1,
+    -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, -1,
+     0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1,
+  };
+
+  /* no character < 0x80 can represent a valid number */
+#define OP  <
+
+#endif /* 'A' == 193 */
+
+
+  FT_LOCAL_DEF( FT_Long )
+  PS_Conv_Strtol( FT_Byte**  cursor,
+                  FT_Byte*   limit,
+                  FT_Long    base )
+  {
+    FT_Byte*  p = *cursor;
+
+    FT_Long   num           = 0;
+    FT_Bool   sign          = 0;
+    FT_Bool   have_overflow = 0;
+
+    FT_Long   num_limit;
+    FT_Char   c_limit;
+
+
+    if ( p >= limit )
+      goto Bad;
+
+    if ( base < 2 || base > 36 )
+    {
+      FT_TRACE4(( "!!!INVALID BASE:!!!" ));
+      return 0;
+    }
+
+    if ( *p == '-' || *p == '+' )
+    {
+      sign = FT_BOOL( *p == '-' );
+
+      p++;
+      if ( p == limit )
+        goto Bad;
+
+      /* only a single sign is allowed */
+      if ( *p == '-' || *p == '+' )
+        return 0;
+    }
+
+    num_limit = 0x7FFFFFFFL / base;
+    c_limit   = (FT_Char)( 0x7FFFFFFFL % base );
+
+    for ( ; p < limit; p++ )
+    {
+      FT_Char  c;
+
+
+      if ( IS_PS_SPACE( *p ) || *p OP 0x80 )
+        break;
+
+      c = ft_char_table[*p & 0x7F];
+
+      if ( c < 0 || c >= base )
+        break;
+
+      if ( num > num_limit || ( num == num_limit && c > c_limit ) )
+        have_overflow = 1;
+      else
+        num = num * base + c;
+    }
+
+    *cursor = p;
+
+    if ( have_overflow )
+    {
+      num = 0x7FFFFFFFL;
+      FT_TRACE4(( "!!!OVERFLOW:!!!" ));
+    }
+
+    if ( sign )
+      num = -num;
+
+    return num;
+
+  Bad:
+    FT_TRACE4(( "!!!END OF DATA:!!!" ));
+    return 0;
+  }
+
+
+  FT_LOCAL_DEF( FT_Long )
+  PS_Conv_ToInt( FT_Byte**  cursor,
+                 FT_Byte*   limit )
+
+  {
+    FT_Byte*  p = *cursor;
+    FT_Byte*  curp;
+
+    FT_Long   num;
+
+
+    curp = p;
+    num  = PS_Conv_Strtol( &p, limit, 10 );
+
+    if ( p == curp )
+      return 0;
+
+    if ( p < limit && *p == '#' )
+    {
+      p++;
+
+      curp = p;
+      num  = PS_Conv_Strtol( &p, limit, num );
+
+      if ( p == curp )
+        return 0;
+    }
+
+    *cursor = p;
+
+    return num;
+  }
+
+
+  FT_LOCAL_DEF( FT_Fixed )
+  PS_Conv_ToFixed( FT_Byte**  cursor,
+                   FT_Byte*   limit,
+                   FT_Long    power_ten )
+  {
+    FT_Byte*  p = *cursor;
+    FT_Byte*  curp;
+
+    FT_Fixed  integral = 0;
+    FT_Long   decimal  = 0;
+    FT_Long   divider  = 1;
+
+    FT_Bool   sign           = 0;
+    FT_Bool   have_overflow  = 0;
+    FT_Bool   have_underflow = 0;
+
+
+    if ( p >= limit )
+      goto Bad;
+
+    if ( *p == '-' || *p == '+' )
+    {
+      sign = FT_BOOL( *p == '-' );
+
+      p++;
+      if ( p == limit )
+        goto Bad;
+
+      /* only a single sign is allowed */
+      if ( *p == '-' || *p == '+' )
+        return 0;
+    }
+
+    /* read the integer part */
+    if ( *p != '.' )
+    {
+      curp     = p;
+      integral = PS_Conv_ToInt( &p, limit );
+
+      if ( p == curp )
+        return 0;
+
+      if ( integral > 0x7FFF )
+        have_overflow = 1;
+      else
+        integral = (FT_Fixed)( (FT_UInt32)integral << 16 );
+    }
+
+    /* read the decimal part */
+    if ( p < limit && *p == '.' )
+    {
+      p++;
+
+      for ( ; p < limit; p++ )
+      {
+        FT_Char  c;
+
+
+        if ( IS_PS_SPACE( *p ) || *p OP 0x80 )
+          break;
+
+        c = ft_char_table[*p & 0x7F];
+
+        if ( c < 0 || c >= 10 )
+          break;
+
+        /* only add digit if we don't overflow */
+        if ( divider < 0xCCCCCCCL && decimal < 0xCCCCCCCL )
+        {
+          decimal = decimal * 10 + c;
+
+          if ( !integral && power_ten > 0 )
+            power_ten--;
+          else
+            divider *= 10;
+        }
+      }
+    }
+
+    /* read exponent, if any */
+    if ( p + 1 < limit && ( *p == 'e' || *p == 'E' ) )
+    {
+      FT_Long  exponent;
+
+
+      p++;
+
+      curp     = p;
+      exponent = PS_Conv_ToInt( &p, limit );
+
+      if ( curp == p )
+        return 0;
+
+      /* arbitrarily limit exponent */
+      if ( exponent > 1000 )
+        have_overflow = 1;
+      else if ( exponent < -1000 )
+        have_underflow = 1;
+      else
+        power_ten += exponent;
+    }
+
+    *cursor = p;
+
+    if ( !integral && !decimal )
+      return 0;
+
+    if ( have_overflow )
+      goto Overflow;
+    if ( have_underflow )
+      goto Underflow;
+
+    while ( power_ten > 0 )
+    {
+      if ( integral >= 0xCCCCCCCL )
+        goto Overflow;
+      integral *= 10;
+
+      if ( decimal >= 0xCCCCCCCL )
+      {
+        if ( divider == 1 )
+          goto Overflow;
+        divider /= 10;
+      }
+      else
+        decimal *= 10;
+
+      power_ten--;
+    }
+
+    while ( power_ten < 0 )
+    {
+      integral /= 10;
+      if ( divider < 0xCCCCCCCL )
+        divider *= 10;
+      else
+        decimal /= 10;
+
+      if ( !integral && !decimal )
+        goto Underflow;
+
+      power_ten++;
+    }
+
+    if ( decimal )
+    {
+      decimal = FT_DivFix( decimal, divider );
+      /* it's not necessary to check this addition for overflow */
+      /* due to the structure of the real number representation */
+      integral += decimal;
+    }
+
+  Exit:
+    if ( sign )
+      integral = -integral;
+
+    return integral;
+
+  Bad:
+    FT_TRACE4(( "!!!END OF DATA:!!!" ));
+    return 0;
+
+  Overflow:
+    integral = 0x7FFFFFFFL;
+    FT_TRACE4(( "!!!OVERFLOW:!!!" ));
+    goto Exit;
+
+  Underflow:
+    FT_TRACE4(( "!!!UNDERFLOW:!!!" ));
+    return 0;
+  }
+
+
+#if 0
+  FT_LOCAL_DEF( FT_UInt )
+  PS_Conv_StringDecode( FT_Byte**  cursor,
+                        FT_Byte*   limit,
+                        FT_Byte*   buffer,
+                        FT_Offset  n )
+  {
+    FT_Byte*  p;
+    FT_UInt   r = 0;
+
+
+    for ( p = *cursor; r < n && p < limit; p++ )
+    {
+      FT_Byte  b;
+
+
+      if ( *p != '\\' )
+      {
+        buffer[r++] = *p;
+
+        continue;
+      }
+
+      p++;
+
+      switch ( *p )
+      {
+      case 'n':
+        b = '\n';
+        break;
+      case 'r':
+        b = '\r';
+        break;
+      case 't':
+        b = '\t';
+        break;
+      case 'b':
+        b = '\b';
+        break;
+      case 'f':
+        b = '\f';
+        break;
+      case '\r':
+        p++;
+        if ( *p != '\n' )
+        {
+          b = *p;
+
+          break;
+        }
+        /* no break */
+      case '\n':
+        continue;
+        break;
+      default:
+        if ( IS_PS_DIGIT( *p ) )
+        {
+          b = *p - '0';
+
+          p++;
+
+          if ( IS_PS_DIGIT( *p ) )
+          {
+            b = b * 8 + *p - '0';
+
+            p++;
+
+            if ( IS_PS_DIGIT( *p ) )
+              b = b * 8 + *p - '0';
+            else
+            {
+              buffer[r++] = b;
+              b = *p;
+            }
+          }
+          else
+          {
+            buffer[r++] = b;
+            b = *p;
+          }
+        }
+        else
+          b = *p;
+        break;
+      }
+
+      buffer[r++] = b;
+    }
+
+    *cursor = p;
+
+    return r;
+  }
+#endif /* 0 */
+
+
+  FT_LOCAL_DEF( FT_UInt )
+  PS_Conv_ASCIIHexDecode( FT_Byte**  cursor,
+                          FT_Byte*   limit,
+                          FT_Byte*   buffer,
+                          FT_Offset  n )
+  {
+    FT_Byte*  p;
+    FT_UInt   r   = 0;
+    FT_UInt   w   = 0;
+    FT_UInt   pad = 0x01;
+
+
+    n *= 2;
+
+#if 1
+
+    p = *cursor;
+
+    if ( p >= limit )
+      return 0;
+
+    if ( n > (FT_UInt)( limit - p ) )
+      n = (FT_UInt)( limit - p );
+
+    /* we try to process two nibbles at a time to be as fast as possible */
+    for ( ; r < n; r++ )
+    {
+      FT_UInt  c = p[r];
+
+
+      if ( IS_PS_SPACE( c ) )
+        continue;
+
+      if ( c OP 0x80 )
+        break;
+
+      c = (FT_UInt)ft_char_table[c & 0x7F];
+      if ( c >= 16 )
+        break;
+
+      pad = ( pad << 4 ) | c;
+      if ( pad & 0x100 )
+      {
+        buffer[w++] = (FT_Byte)pad;
+        pad         = 0x01;
+      }
+    }
+
+    if ( pad != 0x01 )
+      buffer[w++] = (FT_Byte)( pad << 4 );
+
+    *cursor = p + r;
+
+    return w;
+
+#else /* 0 */
+
+    for ( r = 0; r < n; r++ )
+    {
+      FT_Char  c;
+
+
+      if ( IS_PS_SPACE( *p ) )
+        continue;
+
+      if ( *p OP 0x80 )
+        break;
+
+      c = ft_char_table[*p & 0x7F];
+
+      if ( (unsigned)c >= 16 )
+        break;
+
+      if ( r & 1 )
+      {
+        *buffer = (FT_Byte)(*buffer + c);
+        buffer++;
+      }
+      else
+        *buffer = (FT_Byte)(c << 4);
+
+      r++;
+    }
+
+    *cursor = p;
+
+    return ( r + 1 ) / 2;
+
+#endif /* 0 */
+
+  }
+
+
+  FT_LOCAL_DEF( FT_UInt )
+  PS_Conv_EexecDecode( FT_Byte**   cursor,
+                       FT_Byte*    limit,
+                       FT_Byte*    buffer,
+                       FT_Offset   n,
+                       FT_UShort*  seed )
+  {
+    FT_Byte*  p;
+    FT_UInt   r;
+    FT_UInt   s = *seed;
+
+
+#if 1
+
+    p = *cursor;
+
+    if ( p >= limit )
+      return 0;
+
+    if ( n > (FT_UInt)(limit - p) )
+      n = (FT_UInt)(limit - p);
+
+    for ( r = 0; r < n; r++ )
+    {
+      FT_UInt  val = p[r];
+      FT_UInt  b   = ( val ^ ( s >> 8 ) );
+
+
+      s         = ( (val + s)*52845U + 22719 ) & 0xFFFFU;
+      buffer[r] = (FT_Byte) b;
+    }
+
+    *cursor = p + n;
+    *seed   = (FT_UShort)s;
+
+#else /* 0 */
+
+    for ( r = 0, p = *cursor; r < n && p < limit; r++, p++ )
+    {
+      FT_Byte  b = (FT_Byte)( *p ^ ( s >> 8 ) );
+
+
+      s = (FT_UShort)( ( *p + s ) * 52845U + 22719 );
+      *buffer++ = b;
+    }
+    *cursor = p;
+    *seed   = s;
+
+#endif /* 0 */
+
+    return r;
+  }
+
+
+/* END */