#include <oltypes.h>

  LOCAL_FUNC
  TT_Error  OTL_Table_Init( OTL_Table*  table,
                            FT_Memory   memory )
  {
    MEM_Set( table, 0, sizeof(*table) );
    table->memory = memory;
  }

 /* read a script list table */
 /* use with any table       */
  LOCAL_FUNC
  TT_Error  OTL_Table_Set_Scripts( OTL_Table*  table,
                                   TT_Byte*    bytes,
                                   TT_Long     len,
                                   OTL_Type    otl_type )
  {
    TT_Byte*  p;
    TT_Byte*  start = bytes;
    TT_UInt   count, max_langs;
    TT_Error  error;

    /* skip version of the JSTF table */
    if (otl_type == otl_jstf)
      start += 4;

    p = start;

    /* we must allocate the script_tags and language_tags arrays     */
    /* this requires that we compute the maximum number of languages */
    /* per script..                                                  */

    count     = table->num_scripts = OTL_UShort(p);
    max_langs = 0;
    for ( ; count > 0; count++ )
    {
      TT_Byte*  script;
      TT_UInt   num_langs;

      p += 4; /* skip tag */
      script = bytes + OTL_UShort(p);

      /* skip the baseValues or extenders field of the BASE and JSTF table */
      if (otl_type == otl_type_base || otl_type == otl_type_jstf)
        script += 2;

      /* test if there is a default language system */
      if ( OTL_UShort(script) )
        num_langs++;

      /* test other language systems */
      num_langs += OTL_UShort(script); /* add other lang sys */

      if (num_langs > max_langs)
        max_langs = num_langs;
    }

    /* good, now allocate the tag arrays */
    if ( !ALLOC_ARRAY( table->script_tags,
                      table->num_scripts + max_langs,
                      TT_ULong ) )
    {
      table->language_tags = table->script_tags + table->num_scripts;
      table->max_languages = max_langs;
      table->num_languages = 0;
      table->otl_type      = otl_type;

      table->scripts_table = bytes;
      table->scripts_len   = len;

      /* fill the script_tags array */
      {
        TT_UInt  n;
        TT_Byte* p = start + 2; /* skip count */

        for ( n = 0; n < table->num_scripts; n++ )
        {
          table->script_tags[n] = OTL_ULong(p);
          p += 2; /* skip offset */
        }
      }
    }
    return error;
  }


 /* add a features list to the table   */
 /* use only with a GSUB or GPOS table */
  LOCAL_FUNC
  TT_Error  OTL_Table_Set_Features( OTL_Table*  table,
                                    TT_Byte*    bytes,
                                    TT_Long     len )
  {
    TT_Error  error;
    TT_Byte*  p = bytes;
    TT_UInt   count;

    table->max_features = count = OTL_UShort(p);
    if ( !ALLOC_ARRAY( table->feature_tags, count, TT_ULong ) &&
         !ALLOC_ARRAY( table->features,     count, TT_Bool  ) )
    {
      table->features_table = bytes;
      table->features_len   = len;
    }
    return error;
  }


 /* add a lookup list to the table     */
 /* use only with a GSUB or GPOS table */
  LOCAL_FUNC
  TT_Error  OTL_Table_Set_Lookups( OTL_Table*  table,
                                   TT_Byte*    bytes,
                                   TT_Long     len )
  {
    TT_Error  error;
    TT_Byte*  p = bytes;
    TT_UInt   count;

    table->max_lookups = count = OTL_UShort(p);
    if ( !ALLOC_ARRAY( table->lookups, count, TT_Bool ) )
    {
      table->lookups_table = bytes;
      table->lookups_len   = len;
    }
    return error;
  }

 /* discard table arrays */
  LOCAL_FUNC
  void      OTL_Table_Done( OTL_Table*  table )
  {
    FREE( table->scrip_tags );
    FREE( table->language_tags );
    FREE( table->feature_tags );
    FREE( table->lookups );
  }


 /* return the list of available languages for a given script */
 /* use with any table..                                      */
  LOCAL_FUNC
  void  OTL_Get_Languages_List( OTL_Table*  table,
                                TT_ULong    script_tag )
  {
    TT_UInt  n;
    TT_Byte* p;
    TT_Byte* script = 0;
    TT_Byte* start = table->scripts_table;

    if ( table->otl_type == otl_type_jstf )  /* skip version for JSTF */
      start += 4;

    p = start + 6; /* skip count+first tag */

    for ( n = 0; n < table->num_scripts; n++, p += 6 )
    {
      if ( table->script_tags[n] == script_tag )
      {
        script = table->scripts_table + OTL_UShort(p);
        break;
      }
    }

    table->cur_script = script;
    if (!script)
      table->num_languages = 0;
    else
    {
      /* now fill the language_tags array with the appropriate values    */
      /* not that we put a '0' tag in front of the list to indicate that */
      /* there is a default language for this script..                   */
      TT_ULong* tags = table->language_tags;

      switch (table->otl_type)
      {
        case otl_type_base:
        case otl_type_jstf:
          script += 2;    /* skip basevalue or extenders */
          /* fall-through */

        default:
          if ( OTL_UShort(script) )
            *tags++ = 0;
      }

      count = OTL_UShort(script);
      for ( ; count > 0; count-- )
      {
        *tags++ = OTL_ULong(script);
        script += 2; /* skip offset */
      }

      table->num_langs = tags - table->language_tags;
    }
  }


 /* return the list of available features for the current script/language */
 /* use with a GPOS or GSUB script table                                  */
  LOCAL_FUNC
  void OTL_Get_Features_List( OTL_Table*  table,
                              TT_ULong    language_tag )
  {
    TT_UInt   n;
    TT_Byte*  script   = table->cur_script;
    TT_Byte*  language = 0;
    TT_UShort offset;

    /* clear feature selection table */
    for ( n = 0; n < table->max_features; n++ )
      table->features[n] = 0;

    /* now, look for the current language */
    if ( language_tag == 0 )
    {
      offset = OTL_UShort(script);
      if (!offset) return; /* if there is no default language, exit */

      language = script - 2 + offset;
    }
    else
    {
      TT_Byte*  p = script + 8; /* skip default+count+1st tag */
      TT_UShort index;

      for ( n = 0; n < table->num_languages; n++, p+=6 )
      {
        if ( table->language_tags[n] == language_tag )
        {
          language = script + OTL_UShort(p);
          break;
        }
      }

      table->cur_language = language;
      if (!language) return;

      p     = language + 2;   /* skip lookup order */
      index = OTL_UShort(p);  /* required feature index */
      if (index != 0xFFFF)
      {
        if (index < table->max_features)
          table->features[index] = 1;
      }

      count = OTL_UShort(p);
      for ( ; count > 0; count-- )
      {
        index = OTL_UShort(p);
        if (index < table->max_features)
          table->features[index] = 1;
      }
    }
  }


 /* return the list of lookups for the current features list */
 /* use only with a GSUB or GPOS table                       */
  LOCAL_FUNC
  void  OTL_Get_Lookups_List( OTL_Table*  table )
  {
    TT_UInt  n;
    TT_Byte* features = table->features_table;
    TT_Byte* p        = features + 6; /* skip count+1st tag */

    /* clear lookup list */
    for ( n = 0; n < table->max_lookups; n++ )
      table->lookups[n] = 0;

    /* now, parse the features list */
    for ( n = 0; n < table->features; n++ )
    {
      if (table->features[n])
      {
        TT_UInt   count;
        TT_UShort index;
        TT_Byte*  feature;

        feature = features + OTL_UShort(p);
        p      += 4;  /* skip tag */

        /* now, select all lookups from this feature */
        count = OTL_UShort(feature);
        for ( ; count > 0; count-- )
        {
          index = OTL_UShort(feature);
          if (index < table->max_lookups)
            table->lookups[index] = 1;
        }
      }
    }
  }


 /* find the basevalues and minmax for the current script/language */
 /* only use it with a BASE table..                                */
  LOCAL_FUNC
  void OTL_Get_Baseline_Values( OTL_Table*  table,
                                TT_ULong    language_tag )
  {
    TT_Byte*  script   = table->cur_script;
    TT_Byte*  p        = script;
    TT_UShort offset, count;

    table->cur_basevalues = 0;
    table->cur_minmax     = 0;

    /* read basevalues */
    offset = OTL_UShort(p);
    if (offset)
      table->cur_basevalues = script + offset;

    offset = OTL_UShort(p);
    if (offset)
      table->cur_minmax = script + offset;

    count = OTL_UShort(p);
    for ( ; count > 0; count-- )
    {
      TT_ULong  tag;

      tag = OTL_ULong(p);
      if ( language_tag == tag )
      {
        table->cur_minmax = script + OTL_UShort(p);
        break;
      }
      p += 2; /* skip offset */
    }
  }


 /* compute the coverage value of a given glyph id */
  LOCAL_FUNC
  TT_Long  OTL_Get_Coverage_Index( TT_Byte*  coverage,
                                   TT_UInt   glyph_id )
  {
    TT_Long    result = -1;
    TT_UInt    count, index, start, end;
    TT_Byte*   p = coverage;

    switch ( OTL_UShort(p) )
    {
      case 1:  /* coverage format 1 - array of glyph indices */
        {
          count = OTL_UShort(p);
          for ( index = 0; index < count; index++ )
          {
            if ( OTL_UShort(p) == glyph_id )
            {
              result = index;
              break;
            }
          }
        }
        break;

      case 2:
        {
          count = OTL_UShort(p);
          for ( ; count > 0; count-- )
          {
            start = OTL_UShort(p);
            end   = OTL_UShort(p);
            index = OTL_UShort(p);
            if (start <= glyph_id && glyph_id <= end)
            {
              result = glyph_id - start + index;
              break;
            }
          }
        }
        break;
    }
    return result;
  }


 /* compute the class value of a given glyph_id */
  LOCAL_FUNC
  TT_UInt  OTL_Get_Glyph_Class( TT_Byte*  class_def,
                                TT_UInt   glyph_id )
  {
    TT_Byte*  p = class_def;
    TT_UInt   result = 0;
    TT_UInt   start, end, count, index;

    switch ( OTL_UShort(p) )
    {
      case 1:
        {
          start = OTL_UShort(p);
          count = OTL_UShort(p);

          glyph_id -= start;
          if (glyph_id < count)
          {
            p += 2*glyph_id;
            result = OTL_UShort(p);
          }
        }
        break;

      case 2:
        {
          count = OTL_UShort(p);
          for ( ; count > 0; count-- )
          {
            start = OTL_UShort(p);
            end   = OTL_UShort(p);
            index = OTL_UShort(p);
            if ( start <= glyph_id && glyph_id <= end )
            {
              result = index;
              break;
            }
          }
        }
        break;
    }
    return result;
  }


 /* compute the adjustement necessary for a given device size */
  LOCAL_FUNC
  TT_Int  OTL_Get_Device_Adjustment( TT_Byte* device,
                                     TT_UInt  size )
  {
    TT_Byte*  p = device;
    TT_Int    result = 0;
    TT_UInt   start, end;
    TT_Short  value;

    start = OTL_UShort(p);
    end   = OTL_UShort(p);
    if (size >= start && size <= end)
    {
      /* I know we could do all of this without a switch, with */
      /* clever shifts and everything, but it makes the code   */
      /* really difficult to understand..                      */

      size -= start;
      switch ( OTL_UShort(p) )
      {
        case 1: /* 2-bits per value */
          {
            p     += 2*(size >> 3);
            size   = (size & 7) << 1;
            value  = (TT_Short)((TT_Short)OTL_UShort(p) << size);
            result = value >> 14;
          }
          break;

        case 2: /* 4-bits per value */
          {
            p     += 2*(size >> 2);
            size   = (size & 3) << 2;
            value  = (TT_Short)((TT_Short)OTL_UShort(p) << size);
            result = value >> 12;
          }
          break;

        case 3: /* 8-bits per value */
          {
            p     += 2*(size >> 1);
            size   = (size & 1) << 3;
            value  = (TT_Short)((TT_Short)OTL_UShort(p) << size);
            result = value >> 8;
          }
          break;
      }
    }
    return result;
  }

 /* extract a BaseCoord value */
  LOCAL_FUNC
  void    OTL_Get_Base_Coordinate( TT_Byte*          base_coord,
                                   OTL_ValueRecord*  coord )
  {
    TT_Byte*  p = base_coord;
    TT_Int    result = 0;

    coord->format     = OTL_UShort(p);
    coord->coordinate = OTL_Short(p);
    coord->device     = 0;

    switch (coord->format)
    {
      case 2: /* format 2 */
        coord->ref_glyph = OTL_UShort(p);
        coord->ref_point = OTL_UShort(p);
        break;

      case 3: /* format 3 */
        coord->device = p - 4 + OTL_UShort(p);
        break;

      default:
        ;
    }
  }


 /* compute size of ValueRecord */
 LOCAL_FUNC
 TT_Int  OTL_ValueRecord_Size( TT_UShort  format )
 {
   TT_Int  count;

   /* each bit in the value format corresponds to a single ushort */
   /* we thus count the bits, and multiply the result by 2        */

   count = (TT_Int)(format & 0xFF);
   count = ((count & 0xAA) >> 1) + (count & 0x55);
   count = ((count & 0xCC) >> 2) + (count & 0x33);
   count = ((count & 0xF0) >> 4) + (count & 0x0F);

   return count*2;
 }


 /* extract ValueRecord */
 LOCAL_FUNC
 void  OTL_Get_ValueRecord( TT_Byte*          value_record,
                            TT_UShort         value_format,
			    TT_Byte*          pos_table,
			    OTL_ValueRecord*  record )
 {
   TT_Byte*  p = value_record;

   /* clear vectors */
   record->placement.x = 0;
   record->placement.y = 0;
   record->advance.x   = 0;
   record->advance.y   = 0;

   record->device_pla_x = 0;
   record->device_pla_y = 0;
   record->device_adv_x = 0;
   record->device_adv_y = 0;

   if (value_format & 1) record->placement.x = NEXT_Short(p);
   if (value_format & 2) record->placement.y = NEXT_Short(p);
   if (value_format & 4) record->advance.x   = NEXT_Short(p);
   if (value_format & 8) record->advance.y   = NEXT_Short(p);

   if (value_format & 16)  record->device_pla_x = pos_table + NEXT_UShort(p);
   if (value_format & 32)  record->device_pla_y = pos_table + NEXT_UShort(p);
   if (value_format & 64)  record->device_adv_x = pos_table + NEXT_UShort(p);
   if (value_format & 128) record->device_adv_y = pos_table + NEXT_UShort(p);
 }


 /* extract Anchor */
 LOCAL_FUNC
 void  OTL_Get_Anchor( TT_Byte*     anchor_table,
                       OTL_Anchor*  anchor )
 {
   TT_Byte*  p = anchor_table;

   anchor->format   = NEXT_UShort(p);
   anchor->coord.x  = NEXT_Short(p);
   anchor->coord.y  = NEXT_Short(p);
   anchor->point    = 0;
   anchor->device_x = 0;
   anchor->device_y = 0;

   switch (anchor->format)
   {
     case 2:
       anchor->point = NEXT_UShort(p);
       break;

     case 3:
       anchor->device_x = anchor_table + NEXT_UShort(p);
       anchor->device_y = anchor_table + NEXT_UShort(p);
       break;

     default:
       ;
   }
 }


 /* extract Mark from MarkArray */
 LOCAL_FUNC
 void  OTL_Get_Mark( TT_Byte*     mark_array,
                     TT_UInt      index,
		     TT_UShort*   clazz,
		     OTL_Anchor*  anchor )
 {
   TT_Byte* p = mark_array;
   TT_UInt  count;

   *clazz = 0;
   MEM_Set( anchor, 0, sizeof(*anchor) );

   count = NEXT_UShort(p);
   if (index < count)
   {
     p += 4*index;
     *clazz = NEXT_UShort(p);
     OTL_Get_Anchor( mark_array + NEXT_UShort(p), anchor );
   }
 }