shithub: freetype+ttf2subf

Download patch

ref: b8a7a0bdea780ac43dc8c8495f9ef08c046e5ed8
parent: 34f1c2f5f4e12e84acfa1c12f6f8cedff6f162fa
author: David Turner <[email protected]>
date: Wed Aug 23 18:48:50 EDT 2000

removing obsolete files. These are moved to a new
CVS module called "ftlayout"

git/fs: mount .git/fs: mount/attach disallowed
--- a/src/otlayout/oltypes.c
+++ /dev/null
@@ -1,614 +1,0 @@
-#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 );
-   }
- }
-
--- a/src/otlayout/oltypes.h
+++ /dev/null
@@ -1,312 +1,0 @@
-#ifndef OLTYPES_H
-#define OLTYPES_H
-
-#include <freetype/internal/ftobjs.h>
-
- /*************************************************************
-  *
-  * <Struct> OTL_Table
-  *
-  * <Description>
-  *    The base table of most OpenType Layout sub-tables.
-  *    Provides a simple way to scan a table for script,
-  *    languages, features and lookups..
-  *
-  * <Fields>
-  *    num_scripts  :: number of scripts in table's script list
-  *    script_tags  :: array of tags for each table script
-  *
-  *    max_languages :: max number of languages for any script in
-  *                     the table.
-  *    num_languages :: number of languages available for current script
-  *    language_tags :: tags of all languages available for current script.
-  *
-  *    max_features  :: total number of features in table
-  *    feature_tags  :: tags of all features for current script/language
-  *    features      :: selection flags for all features in current script/lang
-  *
-  *    max_lookups   :: total number of lookups in table
-  *    lookups       :: selection flags for all lookups for current
-  *                     feature list.
-  *
-  ****************************************************************/
-
-  typedef enum OTL_Type_
-  {
-    otl_type_none = 0,
-    otl_type_base,
-    otl_type_gdef,
-    otl_type_gpos,
-    otl_type_gsub,
-    otl_type_jstf
-
-  } OTL_Type;
-
-
-  typedef struct OTL_Table_
-  {
-    FT_Memory memory;
-
-    FT_Int    num_scripts;
-    FT_Tag*   script_tags;
-
-    FT_Int    max_languages;
-    FT_Int    num_languages;
-    FT_Tag*   language_tags;
-
-    FT_Int    max_features;
-    FT_Tag*   feature_tags;
-    FT_Bool*  features;
-
-    FT_Int    max_lookups;
-    FT_Bool*  lookups;
-
-    FT_Byte*  scripts_table;
-    FT_Long   scripts_len;
-
-    FT_Byte*  features_table;
-    FT_Long*  features_len;
-
-    FT_Byte*  lookups_table;
-    FT_Byte*  lookups_len;
-
-    FT_Byte*  cur_script;   /* current script   */
-    FT_Byte*  cur_language; /* current language */
-
-    FT_Byte*  cur_base_values;
-    FT_Byte*  cur_min_max;
-
-    OTL_Type  otl_type;
-
-  } OTL_Table;
-
-
-  typedef struct OTL_BaseCoord_
-  {
-    FT_UShort  format;
-    FT_Short   coordinate;
-    FT_UShort  ref_glyph;
-    FT_UShort  ref_point;
-    FT_Byte*   device;
-
-  } OTL_BaseCoord;
-
-
-  typedef struct OTL_ValueRecord_
-  {
-    FT_Vector  placement;
-    FT_Vector  advance;
-
-    FT_Byte*   device_pla_x;
-    FT_Byte*   device_pla_y;
-    FT_Byte*   device_adv_x;
-    FT_Byte*   device_adv_y;
-
-  } OTL_ValueRecord;
-
-
-  typedef struct OTL_Anchor_
-  {
-    FT_UInt    format;
-    FT_Vector  coord;
-    FT_UInt    anchor_point;
-    FT_Byte*   device_x;
-    FT_Byte*   device_y;
-
-  } OTL_Anchor;
-
-
-  LOCAL_DEF
-  FT_Error  OTL_Table_Init( OTL_Table*  table,
-                            FT_Memory   memory );
-
-  LOCAL_DEF
-  void      OTL_Table_Done( OTL_Table*  table );
-
-
-
-/*****************************************************
- *
- *  Typical uses:
- *
- *  - after OTL_Table_Set_Scripts have been called :
- *
- *      table->script_tags contains the list of tags of all
- *      scripts defined for this table.
- *
- *      table->num_scripts is the number of scripts
- *
- */
-  LOCAL_DEF
-  FT_Error  OTL_Table_Set_Scripts( OTL_Table*  table,
-                                   FT_Byte*    bytes,
-                                   FT_Long     len,
-                                   OTL_Type    otl_type );
-
-
-/********************************************************
- *
- *  - after calling OTL_Table_Set_Features:
- *
- *      table->max_features is the number of all features
- *      in the table
- *
- *      table->feature_tags is the list of tags of all
- *      features in the table
- *
- *      table->features[] is an array of boolean used to
- *      indicate which feature is active for a given script/language
- *      it is empty (zero-filled) by default.
- *
- */
-  LOCAL_DEF
-  FT_Error  OTL_Table_Set_Features( OTL_Table*  table,
-                                    FT_Byte*    bytes,
-                                    FT_Long     len );
-
-
-
-  LOCAL_DEF
-  FT_Error  OTL_Table_Set_Lookups( OTL_Table*  table,
-                                   FT_Byte*    bytes,
-                                   FT_Long     len );
-
-
-/*******************************************************************
- *
- *  - after calling OTL_Get_Languages_List(script_tag):
- *
- *      table->num_languages is the number of language systems
- *      available for the script, including the default
- *      langsys if there is one
- *
- *      table->language_tags contains the list of tags of all
- *      languages for the script. Note that the default langsys
- *      has tag "0" and is always placed first in "language_tags".
- *
- *
- *
- */
-  LOCAL_DEF
-  void  OTL_Get_Languages_List( OTL_Table*  table,
-                                FT_ULong    script_tag );
-
-
-/*******************************************************************
- *
- *  - after calling OTL_Get_Features_List(language_tag):
- *
- *      table->features[] is an array of booleans used to indicate
- *      which features are active for the current script/language
- *
- *      note that this function must be called after OTL_Get_Languages
- *      which remembers the last "script_tag" used..
- *
- *      A client application can change the table->features[] array
- *      to add or remove features from the list.
- *
- *
- *
- */
-  LOCAL_DEF
-  void OTL_Get_Features_List( OTL_Table*  table,
-                              FT_ULong    language_tag );
-
-  LOCAL_DEF
-  void OTL_Get_Baseline_Values( OTL_Table*  table,
-                                FT_ULong    language_tag );
-
-  LOCAL_DEF
-  void OTL_Get_Justification( OTL_Table*  table,
-                              FT_ULong    language_tag );
-
-/*******************************************************************
- *
- *  - after calling OTL_Get_Lookups_List():
- *
- *      The function uses the table->features[] array of boolean
- *      to determine which lookups must be processed.
- *
- *      It fills the table->lookups[] array accordingly. It is also
- *      an array of booleans (one for each lookup).
- *
- *
- */
-
-  LOCAL_DEF
-  void  OTL_Get_Lookups_List( OTL_Table*  table );
-
-
-/***************************************************************
- *
- *  So the whole thing looks like:
- *
- *
- *  1.  A client specifies a given script and requests available
- *      language through OTL_Get_Languages_List()
- *
- *  2.  It selects the language tag it needs, then calls
- *      OTL_Get_Features_List()
- *
- *  3.  It updates the list of active features if it needs to
- *
- *  4.  It calls OTL_Get_Lookups_List()
- *      It now has a list of active lookups in "table->lookups[]"
- *
- *  5.  The lookups are processed according to the table's type..
- *
- */
-
-
-
-
-  LOCAL_DEF
-  FT_Long  OTL_Get_Coverage_Index( FT_Byte*  coverage,
-                                   FT_UInt   glyph_id );
-
-  LOCAL_DEF
-  FT_UInt  OTL_Get_Glyph_Class( FT_Byte*  class_def,
-                                FT_UInt   glyph_id );
-
-  LOCAL_DEF
-  FT_Int  OTL_Get_Device_Adjustment( FT_Byte* device,
-                                     FT_UInt  size );
-
-  LOCAL_DEF
-  void    OTL_Get_Base_Coordinate( FT_Byte*        base_coord,
-                                   OTL_BaseCoord*  coord );
-
-
-  LOCAL_DEF
-  FT_Int  OTL_ValueRecord_Size( FT_UShort  value_format );
-
-
-  LOCAL_DEF
-  void  OTL_Get_ValueRecord( FT_Byte*          value_record,
-                             FT_UShort         value_format,
-			     FT_Byte*          pos_table,
-			     OTL_ValueRecord*  record );
-
-
-  LOCAL_DEF
-  void  OTL_Get_Anchor( FT_Byte*     anchor_table,
-                        OTL_Anchor*  anchor );
-
-
-  LOCAL_DEF
-  void  OTL_Get_Mark( FT_Byte*     mark_array,
-                      FT_UInt      index,
-		      FT_UShort*   clazz,
-		      OTL_Anchor*  anchor );
-
-
-
-#define OTL_Byte(p)   (p++, p[-1])
-
-#define OTL_UShort(p) (p+=2, ((FT_UShort)p[-2] << 8) | p[-1])
-
-#define OTL_ULong(p)  (p+=4, ((FT_ULong)p[-4] << 24) |        \
-                             ((FT_ULong)p[-3] << 16) |        \
-                             ((FT_ULong)p[-2] << 8 ) | p[-1] )
-
-#endif /* OLTYPES_H */