Remove two more unused variables that compilers now complain about.
[pdfium.git] / core / src / fxge / freetype / fx_freetype.c
index fe144d6..78dec9a 100644 (file)
 #include "../../../include/fxge/fx_freetype.h"
 #include "../../../../third_party/freetype/src/psnames/pstables.h"
 
-static int xyq_search_node(char* glyph_name, int name_offset, int table_offset, wchar_t unicode)\r
-{\r
-    int i, count;\r
-\r
-    // copy letters\r
-    while (1) {\r
-        glyph_name[name_offset] = ft_adobe_glyph_list[table_offset] & 0x7f;\r
-        name_offset++;\r
-        table_offset++;\r
-        if (!(ft_adobe_glyph_list[table_offset - 1] & 0x80)) break;\r
-    }\r
-    glyph_name[name_offset] = 0;\r
-\r
-    // get child count\r
-    count = ft_adobe_glyph_list[table_offset] & 0x7f;\r
-\r
-    // check if we have value for this node\r
-    if (ft_adobe_glyph_list[table_offset] & 0x80) {\r
-        unsigned short thiscode = ft_adobe_glyph_list[table_offset + 1] * 256 + ft_adobe_glyph_list[table_offset + 2];\r
-        if (thiscode == (unsigned short)unicode)       // found it!\r
-            return 1;\r
-        table_offset += 3;\r
-    }\r
-    else\r
-        table_offset++;\r
-\r
-    // now search in sub-nodes\r
-    if (count == 0) return 0;\r
-    for (i = 0; i < count; i++) {\r
-        int child_offset = ft_adobe_glyph_list[table_offset + i * 2] * 256 + ft_adobe_glyph_list[table_offset + i * 2 + 1];\r
-        if (xyq_search_node(glyph_name, name_offset, child_offset, unicode))\r
-            // found in child\r
-            return 1;\r
-    }\r
-    return 0;\r
+static int xyq_search_node(char* glyph_name, int name_offset, int table_offset, wchar_t unicode)
+{
+    int i, count;
+
+    // copy letters
+    while (1) {
+        glyph_name[name_offset] = ft_adobe_glyph_list[table_offset] & 0x7f;
+        name_offset++;
+        table_offset++;
+        if (!(ft_adobe_glyph_list[table_offset - 1] & 0x80)) break;
+    }
+    glyph_name[name_offset] = 0;
+
+    // get child count
+    count = ft_adobe_glyph_list[table_offset] & 0x7f;
+
+    // check if we have value for this node
+    if (ft_adobe_glyph_list[table_offset] & 0x80) {
+        unsigned short thiscode = ft_adobe_glyph_list[table_offset + 1] * 256 + ft_adobe_glyph_list[table_offset + 2];
+        if (thiscode == (unsigned short)unicode)       // found it!
+            return 1;
+        table_offset += 3;
+    }
+    else
+        table_offset++;
+
+    // now search in sub-nodes
+    if (count == 0) return 0;
+    for (i = 0; i < count; i++) {
+        int child_offset = ft_adobe_glyph_list[table_offset + i * 2] * 256 + ft_adobe_glyph_list[table_offset + i * 2 + 1];
+        if (xyq_search_node(glyph_name, name_offset, child_offset, unicode))
+            // found in child
+            return 1;
+    }
+    return 0;
 }
 
 #define VARIANT_BIT         0x80000000UL
 
-int FXFT_unicode_from_adobe_name(const char*  glyph_name)\r
-{\r
-    /* If the name begins with `uni', then the glyph name may be a */\r
-    /* hard-coded unicode character code.                          */\r
-    if (glyph_name[0] == 'u' &&\r
-        glyph_name[1] == 'n' &&\r
-        glyph_name[2] == 'i')\r
-    {\r
-        /* determine whether the next four characters following are */\r
-        /* hexadecimal.                                             */\r
-\r
-        /* XXX: Add code to deal with ligatures, i.e. glyph names like */\r
-        /*      `uniXXXXYYYYZZZZ'...                                   */\r
-\r
-        FT_Int       count;\r
-        FT_UInt32    value = 0;\r
-        const char*  p = glyph_name + 3;\r
-\r
-\r
-        for (count = 4; count > 0; count--, p++)\r
-        {\r
-            char          c = *p;\r
-            unsigned int  d;\r
-\r
-\r
-            d = (unsigned char)c - '0';\r
-            if (d >= 10)\r
-            {\r
-                d = (unsigned char)c - 'A';\r
-                if (d >= 6)\r
-                    d = 16;\r
-                else\r
-                    d += 10;\r
-            }\r
-\r
-            /* Exit if a non-uppercase hexadecimal character was found   */\r
-            /* -- this also catches character codes below `0' since such */\r
-            /* negative numbers cast to `unsigned int' are far too big.  */\r
-            if (d >= 16)\r
-                break;\r
-\r
-            value = (value << 4) + d;\r
-        }\r
-\r
-        /* there must be exactly four hex digits */\r
-        if (count == 0)\r
-        {\r
-            if (*p == '\0')\r
-                return value;\r
-            if (*p == '.')\r
-                return (FT_UInt32)(value | VARIANT_BIT);\r
-        }\r
-    }\r
-\r
-    /* If the name begins with `u', followed by four to six uppercase */\r
-    /* hexadecimal digits, it is a hard-coded unicode character code. */\r
-    if (glyph_name[0] == 'u')\r
-    {\r
-        FT_Int       count;\r
-        FT_UInt32    value = 0;\r
-        const char*  p = glyph_name + 1;\r
-\r
-\r
-        for (count = 6; count > 0; count--, p++)\r
-        {\r
-            char          c = *p;\r
-            unsigned int  d;\r
-\r
-\r
-            d = (unsigned char)c - '0';\r
-            if (d >= 10)\r
-            {\r
-                d = (unsigned char)c - 'A';\r
-                if (d >= 6)\r
-                    d = 16;\r
-                else\r
-                    d += 10;\r
-            }\r
-\r
-            if (d >= 16)\r
-                break;\r
-\r
-            value = (value << 4) + d;\r
-        }\r
-\r
-        if (count <= 2)\r
-        {\r
-            if (*p == '\0')\r
-                return value;\r
-            if (*p == '.')\r
-                return (FT_UInt32)(value | VARIANT_BIT);\r
-        }\r
-    }\r
-\r
-    /* Look for a non-initial dot in the glyph name in order to */\r
-    /* find variants like `A.swash', `e.final', etc.            */\r
-    {\r
-        const char*  p = glyph_name;\r
-        const char*  dot = NULL;\r
-\r
-\r
-        for (; *p; p++)\r
-        {\r
-            if (*p == '.' && p > glyph_name)\r
-            {\r
-                dot = p;\r
-                break;\r
-            }\r
-        }\r
-\r
-        /* now look up the glyph in the Adobe Glyph List */\r
-        if (!dot)\r
-            return (FT_UInt32)ft_get_adobe_glyph_index(glyph_name, p);\r
-        else\r
-            return (FT_UInt32)(ft_get_adobe_glyph_index(glyph_name, dot) |\r
-            VARIANT_BIT);\r
-    }\r
-}\r
-\r
-void FXFT_adobe_name_from_unicode(char* glyph_name, wchar_t unicode)\r
-{\r
-    int i, count;\r
-\r
-    // start from top level node\r
-    count = ft_adobe_glyph_list[1];\r
-    for (i = 0; i < count; i++) {\r
-        int child_offset = ft_adobe_glyph_list[i * 2 + 2] * 256 + ft_adobe_glyph_list[i * 2 + 3];\r
-        if (xyq_search_node(glyph_name, 0, child_offset, unicode))\r
-            return;\r
-    }\r
-\r
-    // failed, clear the buffer\r
-    glyph_name[0] = 0;\r
-}\r
+int FXFT_unicode_from_adobe_name(const char*  glyph_name)
+{
+    /* If the name begins with `uni', then the glyph name may be a */
+    /* hard-coded unicode character code.                          */
+    if (glyph_name[0] == 'u' &&
+        glyph_name[1] == 'n' &&
+        glyph_name[2] == 'i')
+    {
+        /* determine whether the next four characters following are */
+        /* hexadecimal.                                             */
+
+        /* XXX: Add code to deal with ligatures, i.e. glyph names like */
+        /*      `uniXXXXYYYYZZZZ'...                                   */
+
+        FT_Int       count;
+        FT_UInt32    value = 0;
+        const char*  p = glyph_name + 3;
+
+
+        for (count = 4; count > 0; count--, p++)
+        {
+            char          c = *p;
+            unsigned int  d;
+
+
+            d = (unsigned char)c - '0';
+            if (d >= 10)
+            {
+                d = (unsigned char)c - 'A';
+                if (d >= 6)
+                    d = 16;
+                else
+                    d += 10;
+            }
+
+            /* Exit if a non-uppercase hexadecimal character was found   */
+            /* -- this also catches character codes below `0' since such */
+            /* negative numbers cast to `unsigned int' are far too big.  */
+            if (d >= 16)
+                break;
+
+            value = (value << 4) + d;
+        }
+
+        /* there must be exactly four hex digits */
+        if (count == 0)
+        {
+            if (*p == '\0')
+                return value;
+            if (*p == '.')
+                return (FT_UInt32)(value | VARIANT_BIT);
+        }
+    }
+
+    /* If the name begins with `u', followed by four to six uppercase */
+    /* hexadecimal digits, it is a hard-coded unicode character code. */
+    if (glyph_name[0] == 'u')
+    {
+        FT_Int       count;
+        FT_UInt32    value = 0;
+        const char*  p = glyph_name + 1;
+
+
+        for (count = 6; count > 0; count--, p++)
+        {
+            char          c = *p;
+            unsigned int  d;
+
+
+            d = (unsigned char)c - '0';
+            if (d >= 10)
+            {
+                d = (unsigned char)c - 'A';
+                if (d >= 6)
+                    d = 16;
+                else
+                    d += 10;
+            }
+
+            if (d >= 16)
+                break;
+
+            value = (value << 4) + d;
+        }
+
+        if (count <= 2)
+        {
+            if (*p == '\0')
+                return value;
+            if (*p == '.')
+                return (FT_UInt32)(value | VARIANT_BIT);
+        }
+    }
+
+    /* Look for a non-initial dot in the glyph name in order to */
+    /* find variants like `A.swash', `e.final', etc.            */
+    {
+        const char*  p = glyph_name;
+        const char*  dot = NULL;
+
+
+        for (; *p; p++)
+        {
+            if (*p == '.' && p > glyph_name)
+            {
+                dot = p;
+                break;
+            }
+        }
+
+        /* now look up the glyph in the Adobe Glyph List */
+        if (!dot)
+            return (FT_UInt32)ft_get_adobe_glyph_index(glyph_name, p);
+        else
+            return (FT_UInt32)(ft_get_adobe_glyph_index(glyph_name, dot) |
+            VARIANT_BIT);
+    }
+}
+
+void FXFT_adobe_name_from_unicode(char* glyph_name, wchar_t unicode)
+{
+    int i, count;
+
+    // start from top level node
+    count = ft_adobe_glyph_list[1];
+    for (i = 0; i < count; i++) {
+        int child_offset = ft_adobe_glyph_list[i * 2 + 2] * 256 + ft_adobe_glyph_list[i * 2 + 3];
+        if (xyq_search_node(glyph_name, 0, child_offset, unicode))
+            return;
+    }
+
+    // failed, clear the buffer
+    glyph_name[0] = 0;
+}