# --- ROCK-COPYRIGHT-NOTE-BEGIN --- # # This copyright note is auto-generated by ./scripts/Create-CopyPatch. # Please add additional copyright information _after_ the line containing # the ROCK-COPYRIGHT-NOTE-END tag. Otherwise it might get removed by # the ./scripts/Create-CopyPatch script. Do not edit this copyright text! # # ROCK Linux: rock-src/package/x11/xfree86/fontconfig-update.patch # ROCK Linux is Copyright (C) 1998 - 2004 Clifford Wolf # # This patch file is dual-licensed. It is available under the license the # patched project is licensed under, as long as it is an OpenSource license # as defined at http://www.opensource.org/ (e.g. BSD, X11) or under the terms # of the GNU General Public License as published by the Free Software # Foundation; either version 2 of the License, or (at your option) any later # version. # # --- ROCK-COPYRIGHT-NOTE-END --- This updates the fontconfig version included inside XFree to Keith's external and official 2.2.1 release. The patch matches the license of these projects (X11/BSD/...) and is intended for inclusion into XFree. The GPL license above is only the ROCK Linux license as it. - Rene Rebe - Juergen Sawinski --- xc/lib/fontconfig/Imakefile~ 2003-12-19 05:45:53.000000000 +0100 +++ xc-fontconfig/lib/fontconfig/Imakefile 2003-12-21 16:16:33.000000000 +0100 @@ -7,6 +7,8 @@ #define DoProfileLib ProfileLibFontconfig #define HasSharedData YES #define LibName fontconfig + +SOFONTCONFIGREV=2.2 #define SoRev SOFONTCONFIGREV #define IncSubdir fontconfig --- xc/extras/fontconfig/src/fcfreetype.c 2003-11-21 06:56:14.000000000 +0100 +++ xc-fontconfig/extras/fontconfig/src/fcfreetype.c 2003-12-21 16:20:08.000000000 +0100 @@ -22,6 +22,28 @@ * PERFORMANCE OF THIS SOFTWARE. */ +/* + Copyright © 2002-2003 by Juliusz Chroboczek + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ + #include #include #include @@ -33,6 +55,19 @@ #include FT_SFNT_NAMES_H #include FT_TRUETYPE_IDS_H +#include + +#if (FREETYPE_MINOR > 1 || (FREETYPE_MINOR == 1 && FREETYPE_PATCH >= 4)) +#include +#include +#define USE_FTBDF +#define HAS_BDF_PROPERTY(f) ((f) && (f)->driver && \ + (f)->driver->root.clazz->get_interface) +#define MY_Get_BDF_Property(f,n,p) (HAS_BDF_PROPERTY(f) ? \ + FT_Get_BDF_Property(f,n,p) : \ + FT_Err_Invalid_Argument) +#endif + /* * Keep Han languages separated by eliminating languages * that the codePageRange bits says aren't supported @@ -90,7 +125,8 @@ return FcTrue; if (page == 0xfb) return FcTrue; - if (page == 0xff) + /* halfwidth forms, don't include kana or white parens */ + if (0xff01 <= ucs4 && ucs4 <= 0xff5e) return FcTrue; return FcFalse; } @@ -112,6 +148,115 @@ return FcTrue; } +/* Order is significant. For example, some B&H fonts are hinted by + URW++, and both strings appear in the notice. */ + +static const struct { + const FcChar8 *notice; + const FcChar8 *foundry; +} FcNoticeFoundries[] = { + { (const FcChar8*) "Bigelow", (const FcChar8 *) "b&h" }, + { (const FcChar8*) "Adobe", (const FcChar8 *) "adobe" }, + { (const FcChar8*) "Bitstream", (const FcChar8 *) "bitstream" }, + { (const FcChar8*) "Monotype", (const FcChar8 *) "monotype" }, + { (const FcChar8*) "Linotype", (const FcChar8 *) "linotype" }, + { (const FcChar8*) "LINOTYPE-HELL", (const FcChar8 *) "linotype" }, + { (const FcChar8*) "IBM", (const FcChar8 *) "ibm" }, + { (const FcChar8*) "URW", (const FcChar8 *) "urw" }, + { (const FcChar8*) "International Typeface Corporation", + (const FcChar8 *) "itc" }, + { (const FcChar8*) "Tiro Typeworks",(const FcChar8 *) "tiro" }, + { (const FcChar8*) "XFree86", (const FcChar8 *) "xfree86" }, + { (const FcChar8*) "Microsoft", (const FcChar8 *) "microsoft" }, + { (const FcChar8*) "Omega", (const FcChar8 *) "omega" }, + { (const FcChar8*) "Font21", (const FcChar8 *) "hwan" }, + { (const FcChar8*) "HanYang System",(const FcChar8 *) "hanyang" } +}; + +#define NUM_NOTICE_FOUNDRIES (sizeof (FcNoticeFoundries) / sizeof (FcNoticeFoundries[0])) + +static const FcChar8 * +FcNoticeFoundry(const char *notice) +{ + int i; + + if (notice) + for(i = 0; i < NUM_NOTICE_FOUNDRIES; i++) + if (strstr ((const char *) notice, (const char *) FcNoticeFoundries[i].notice)) + return FcNoticeFoundries[i].foundry; + return 0; +} + +static FcBool +FcVendorMatch(const char *vendor, const char *vendor_string) +{ + /* vendor is not necessarily NUL-terminated. */ + int i, len; + + len = strlen(vendor_string); + if (memcmp(vendor, vendor_string, len) != 0) + return FcFalse; + for (i = len; i < 4; i++) + if (vendor[i] != ' ' && vendor[i] != '\0') + return FcFalse; + return FcTrue; +} + +/* This table is partly taken from ttmkfdir by Joerg Pommnitz. */ + +/* It should not contain useless entries (such as UNKN) nor duplicate + entries for padding both with spaces and NULs. */ + +static const struct { + const FcChar8 *vendor; + const FcChar8 *foundry; +} FcVendorFoundries[] = { + { (const FcChar8*) "ADBE", (const FcChar8 *) "adobe"}, + { (const FcChar8*) "AGFA", (const FcChar8 *) "agfa"}, + { (const FcChar8*) "ALTS", (const FcChar8 *) "altsys"}, + { (const FcChar8*) "APPL", (const FcChar8 *) "apple"}, + { (const FcChar8*) "ARPH", (const FcChar8 *) "arphic"}, + { (const FcChar8*) "ATEC", (const FcChar8 *) "alltype"}, + { (const FcChar8*) "B&H", (const FcChar8 *) "b&h"}, + { (const FcChar8*) "BITS", (const FcChar8 *) "bitstream"}, + { (const FcChar8*) "CANO", (const FcChar8 *) "cannon"}, + { (const FcChar8*) "DYNA", (const FcChar8 *) "dynalab"}, + { (const FcChar8*) "EPSN", (const FcChar8 *) "epson"}, + { (const FcChar8*) "FJ", (const FcChar8 *) "fujitsu"}, + { (const FcChar8*) "IBM", (const FcChar8 *) "ibm"}, + { (const FcChar8*) "ITC", (const FcChar8 *) "itc"}, + { (const FcChar8*) "IMPR", (const FcChar8 *) "impress"}, + { (const FcChar8*) "LARA", (const FcChar8 *) "larabiefonts"}, + { (const FcChar8*) "LEAF", (const FcChar8 *) "interleaf"}, + { (const FcChar8*) "LETR", (const FcChar8 *) "letraset"}, + { (const FcChar8*) "LINO", (const FcChar8 *) "linotype"}, + { (const FcChar8*) "MACR", (const FcChar8 *) "macromedia"}, + { (const FcChar8*) "MONO", (const FcChar8 *) "monotype"}, + { (const FcChar8*) "MS", (const FcChar8 *) "microsoft"}, + { (const FcChar8*) "MT", (const FcChar8 *) "monotype"}, + { (const FcChar8*) "NEC", (const FcChar8 *) "nec"}, + { (const FcChar8*) "PARA", (const FcChar8 *) "paratype"}, + { (const FcChar8*) "QMSI", (const FcChar8 *) "qms"}, + { (const FcChar8*) "RICO", (const FcChar8 *) "ricoh"}, + { (const FcChar8*) "URW", (const FcChar8 *) "urw"}, + { (const FcChar8*) "Y&Y", (const FcChar8 *) "y&y"} +}; + +#define NUM_VENDOR_FOUNDRIES (sizeof (FcVendorFoundries) / sizeof (FcVendorFoundries[0])) + +static const FcChar8 * +FcVendorFoundry(const char *vendor) +{ + int i; + + if (vendor) + for(i = 0; i < NUM_VENDOR_FOUNDRIES; i++) + if (FcVendorMatch (vendor, FcVendorFoundries[i].vendor)) + return FcVendorFoundries[i].foundry; + return 0; +} + + FcPattern * FcFreeTypeQuery (const FcChar8 *file, int id, @@ -122,13 +267,17 @@ FcPattern *pat; int slant; int weight; + int width = -1; int i; FcCharSet *cs; FcLangSet *ls; FT_Library ftLibrary; - FcChar8 *family; - FcChar8 *style; + FcChar8 *family = 0; + FcChar8 *style = 0; + const FcChar8 *foundry = 0; + int spacing; TT_OS2 *os2; + PS_FontInfoRec psfontinfo; TT_Header *head; const FcChar8 *exclusiveLang = 0; FT_SfntName sname; @@ -163,23 +312,32 @@ if (face->style_flags & FT_STYLE_FLAG_ITALIC) slant = FC_SLANT_ITALIC; - if (!FcPatternAddInteger (pat, FC_SLANT, slant)) - goto bail1; weight = FC_WEIGHT_MEDIUM; if (face->style_flags & FT_STYLE_FLAG_BOLD) weight = FC_WEIGHT_BOLD; - if (!FcPatternAddInteger (pat, FC_WEIGHT, weight)) - goto bail1; + /* + * Get the OS/2 table + */ + os2 = (TT_OS2 *) FT_Get_Sfnt_Table (face, ft_sfnt_os2); + + /* + * Look first in the OS/2 table for the foundry, if + * not found here, the various notices will be searched for + * that information, either from the sfnt name tables or + * the Postscript FontInfo dictionary. Finally, the + * BDF properties will queried. + */ + + if (os2 && os2->version >= 0x0001 && os2->version != 0xffff) + foundry = FcVendorFoundry(os2->achVendID); /* * Grub through the name table looking for family * and style names. FreeType makes quite a hash * of them */ - family = 0; - style = 0; snamec = FT_Get_Sfnt_Name_Count (face); for (snamei = 0; snamei < snamec; snamei++) { @@ -289,7 +447,9 @@ prio |= FC_NAME_PRIO_NAME_PS; break; case TT_NAME_ID_FONT_SUBFAMILY: - break; + case TT_NAME_ID_TRADEMARK: + case TT_NAME_ID_MANUFACTURER: + break; default: continue; } @@ -402,6 +562,12 @@ style_prio = prio; } break; + case TT_NAME_ID_TRADEMARK: + case TT_NAME_ID_MANUFACTURER: + /* If the foundry wasn't found in the OS/2 table, look here */ + if(!foundry) + foundry = FcNoticeFoundry(utf8); + break; } if (utf8) free (utf8); @@ -468,7 +634,12 @@ if (!FcPatternAddString (pat, FC_SOURCE, (FcChar8 *) "FreeType")) goto bail1; -#if 1 +#if 0 + /* + * don't even try this -- CJK 'monospace' fonts are really + * dual width, and most other fonts don't bother to set + * the attribute. Sigh. + */ if ((face->face_flags & FT_FACE_FLAG_FIXED_WIDTH) != 0) if (!FcPatternAddInteger (pat, FC_SPACING, FC_MONO)) goto bail1; @@ -489,10 +660,6 @@ goto bail1; } - /* - * Get the OS/2 table and poke about - */ - os2 = (TT_OS2 *) FT_Get_Sfnt_Table (face, ft_sfnt_os2); if (os2 && os2->version >= 0x0001 && os2->version != 0xffff) { for (i = 0; i < NUM_CODE_PAGE_RANGE; i++) @@ -526,10 +693,185 @@ } } + if (os2 && os2->version != 0xffff) + { + if (os2->usWeightClass == 0) + weight = -1; + else if (os2->usWeightClass < 150) + weight = FC_WEIGHT_THIN; + else if (os2->usWeightClass < 250) + weight = FC_WEIGHT_EXTRALIGHT; + else if (os2->usWeightClass < 350) + weight = FC_WEIGHT_LIGHT; + else if (os2->usWeightClass < 450) + weight = FC_WEIGHT_REGULAR; + else if (os2->usWeightClass < 550) + weight = FC_WEIGHT_MEDIUM; + else if (os2->usWeightClass < 650) + weight = FC_WEIGHT_SEMIBOLD; + else if (os2->usWeightClass < 750) + weight = FC_WEIGHT_BOLD; + else if (os2->usWeightClass < 850) + weight = FC_WEIGHT_EXTRABOLD; + else if (os2->usWeightClass < 950) + weight = FC_WEIGHT_BLACK; + else + weight = FC_WEIGHT_MEDIUM; + + switch (os2->usWidthClass) { + case 1: width = FC_WIDTH_ULTRACONDENSED; break; + case 2: width = FC_WIDTH_EXTRACONDENSED; break; + case 3: width = FC_WIDTH_CONDENSED; break; + case 4: width = FC_WIDTH_SEMICONDENSED; break; + case 5: width = FC_WIDTH_NORMAL; break; + case 6: width = FC_WIDTH_SEMIEXPANDED; break; + case 7: width = FC_WIDTH_EXPANDED; break; + case 8: width = FC_WIDTH_EXTRAEXPANDED; break; + case 9: width = FC_WIDTH_ULTRAEXPANDED; break; + } + } + + /* + * Type 1: Check for FontInfo dictionary information + * Code from g2@magestudios.net (Gerard Escalante) + */ + + if (FT_Get_PS_Font_Info(face, &psfontinfo) == 0) + { + if (psfontinfo.weight) + { + static struct { + char *name; + int value; + } ps_weights[] = { + { "thin", FC_WEIGHT_THIN }, + { "extralight", FC_WEIGHT_EXTRALIGHT }, + { "ultralight", FC_WEIGHT_ULTRALIGHT }, + { "light", FC_WEIGHT_LIGHT }, + { "regular", FC_WEIGHT_REGULAR }, + { "normal", FC_WEIGHT_NORMAL }, + { "medium", FC_WEIGHT_MEDIUM }, + { "demibold", FC_WEIGHT_DEMIBOLD }, + { "semibold", FC_WEIGHT_SEMIBOLD }, + { "bold", FC_WEIGHT_BOLD }, + { "extrabold", FC_WEIGHT_EXTRABOLD }, + { "ultrabold", FC_WEIGHT_ULTRABOLD }, + { "black", FC_WEIGHT_BLACK }, + { "heavy", FC_WEIGHT_HEAVY }, + }; +#define NUM_PS_WEIGHTS (sizeof (ps_weights) / sizeof (ps_weights[0])) + int w; + for (w = 0; w < NUM_PS_WEIGHTS; w++) + if (!FcStrCmpIgnoreCase ((FcChar8 *) ps_weights[w].name, + (FcChar8 *) psfontinfo.weight)) + { + weight = ps_weights[w].value; + break; + } + } + +#if 0 + /* + * Don't bother with italic_angle; FreeType already extracts that + * information for us and sticks it into style_flags + */ + if (psfontinfo.italic_angle < 0) + slant = FC_SLANT_ITALIC; + else if (psfontinfo.italic_angle >= 0) + slant = FC_SLANT_ROMAN; +#endif + + if(!foundry) + foundry = FcNoticeFoundry(psfontinfo.notice); + } + +#ifdef USE_FTBDF + /* + * Finally, look for a FOUNDRY BDF property if no other + * mechanism has managed to locate a foundry + */ + + if (!foundry) + { + int rc; + BDF_PropertyRec prop; + rc = MY_Get_BDF_Property(face, "FOUNDRY", &prop); + if(rc == 0 && prop.type == BDF_PROPERTY_TYPE_ATOM) + foundry = prop.u.atom; + } + + if (width == -1) + { + BDF_PropertyRec prop; + if (MY_Get_BDF_Property(face, "RELATIVE_SETWIDTH", &prop) == 0 && + (prop.type == BDF_PROPERTY_TYPE_INTEGER || + prop.type == BDF_PROPERTY_TYPE_CARDINAL)) + { + FT_Int32 value; + + if (prop.type == BDF_PROPERTY_TYPE_INTEGER) + value = prop.u.integer; + else + value = (FT_Int32) prop.u.cardinal; + switch ((value + 5) / 10) { + case 1: width = FC_WIDTH_ULTRACONDENSED; break; + case 2: width = FC_WIDTH_EXTRACONDENSED; break; + case 3: width = FC_WIDTH_CONDENSED; break; + case 4: width = FC_WIDTH_SEMICONDENSED; break; + case 5: width = FC_WIDTH_NORMAL; break; + case 6: width = FC_WIDTH_SEMIEXPANDED; break; + case 7: width = FC_WIDTH_EXPANDED; break; + case 8: width = FC_WIDTH_EXTRAEXPANDED; break; + case 9: width = FC_WIDTH_ULTRAEXPANDED; break; + } + } + else if (MY_Get_BDF_Property (face, "SETWIDTH_NAME", &prop) == 0 && + prop.type == BDF_PROPERTY_TYPE_ATOM) + { + static struct { + FcChar8 *width_name; + int width; + } FcSetWidths[] = { + { "Condensed", FC_WIDTH_CONDENSED }, + { "SemiCondensed", FC_WIDTH_SEMICONDENSED }, + { "Normal", FC_WIDTH_NORMAL }, + }; + int i; + + if (FcDebug () & FC_DBG_SCANV) + printf ("\nsetwidth: %s\n", prop.u.atom); + for (i = 0; i < sizeof (FcSetWidths) / sizeof (FcSetWidths[0]); i++) + if (!FcStrCmpIgnoreCase ((FcChar8 *) prop.u.atom, + FcSetWidths[i].width_name)) + { + width = FcSetWidths[i].width; + break; + } + } + } + +#endif + + if (!FcPatternAddInteger (pat, FC_SLANT, slant)) + goto bail1; + + if (!FcPatternAddInteger (pat, FC_WEIGHT, weight)) + goto bail1; + + if (width != -1) + if (!FcPatternAddInteger (pat, FC_WIDTH, width)) + goto bail1; + + if(foundry) + { + if(!FcPatternAddString (pat, FC_FOUNDRY, foundry)) + goto bail1; + } + /* * Compute the unicode coverage for the font */ - cs = FcFreeTypeCharSet (face, blanks); + cs = FcFreeTypeCharSetAndSpacing (face, blanks, &spacing); if (!cs) goto bail1; @@ -553,6 +895,10 @@ if (!FcPatternAddLangSet (pat, FC_LANG, ls)) goto bail2; + if (spacing != FC_PROPORTIONAL) + if (!FcPatternAddInteger (pat, FC_SPACING, spacing)) + goto bail2; + /* * Drop our reference to the charset */ @@ -582,3 +928,802 @@ FT_Done_FreeType (ftLibrary); return 0; } + + +/* + * Figure out whether the available freetype has FT_Get_Next_Char + */ + +#if FREETYPE_MAJOR > 2 +# define HAS_NEXT_CHAR +#else +# if FREETYPE_MAJOR == 2 +# if FREETYPE_MINOR > 0 +# define HAS_NEXT_CHAR +# else +# if FREETYPE_MINOR == 0 +# if FREETYPE_PATCH >= 9 +# define HAS_NEXT_CHAR +# endif +# endif +# endif +# endif +#endif + +/* + * For our purposes, this approximation is sufficient + */ +#ifndef HAS_NEXT_CHAR +#define FT_Get_First_Char(face, gi) ((*(gi) = 1), 1) +#define FT_Get_Next_Char(face, ucs4, gi) ((ucs4) >= 0xffffff ? \ + (*(gi) = 0), 0 : \ + (*(gi) = 1), (ucs4) + 1) +#warning "No FT_Get_Next_Char" +#endif + +typedef struct _FcCharEnt { + FcChar16 bmp; + unsigned char encode; +} FcCharEnt; + +struct _FcCharMap { + const FcCharEnt *ent; + int nent; +}; + +typedef struct _FcFontDecode { + FT_Encoding encoding; + const FcCharMap *map; + FcChar32 max; +} FcFontDecode; + +static const FcCharEnt AppleRomanEnt[] = { + { 0x0020, 0x20 }, /* SPACE */ + { 0x0021, 0x21 }, /* EXCLAMATION MARK */ + { 0x0022, 0x22 }, /* QUOTATION MARK */ + { 0x0023, 0x23 }, /* NUMBER SIGN */ + { 0x0024, 0x24 }, /* DOLLAR SIGN */ + { 0x0025, 0x25 }, /* PERCENT SIGN */ + { 0x0026, 0x26 }, /* AMPERSAND */ + { 0x0027, 0x27 }, /* APOSTROPHE */ + { 0x0028, 0x28 }, /* LEFT PARENTHESIS */ + { 0x0029, 0x29 }, /* RIGHT PARENTHESIS */ + { 0x002A, 0x2A }, /* ASTERISK */ + { 0x002B, 0x2B }, /* PLUS SIGN */ + { 0x002C, 0x2C }, /* COMMA */ + { 0x002D, 0x2D }, /* HYPHEN-MINUS */ + { 0x002E, 0x2E }, /* FULL STOP */ + { 0x002F, 0x2F }, /* SOLIDUS */ + { 0x0030, 0x30 }, /* DIGIT ZERO */ + { 0x0031, 0x31 }, /* DIGIT ONE */ + { 0x0032, 0x32 }, /* DIGIT TWO */ + { 0x0033, 0x33 }, /* DIGIT THREE */ + { 0x0034, 0x34 }, /* DIGIT FOUR */ + { 0x0035, 0x35 }, /* DIGIT FIVE */ + { 0x0036, 0x36 }, /* DIGIT SIX */ + { 0x0037, 0x37 }, /* DIGIT SEVEN */ + { 0x0038, 0x38 }, /* DIGIT EIGHT */ + { 0x0039, 0x39 }, /* DIGIT NINE */ + { 0x003A, 0x3A }, /* COLON */ + { 0x003B, 0x3B }, /* SEMICOLON */ + { 0x003C, 0x3C }, /* LESS-THAN SIGN */ + { 0x003D, 0x3D }, /* EQUALS SIGN */ + { 0x003E, 0x3E }, /* GREATER-THAN SIGN */ + { 0x003F, 0x3F }, /* QUESTION MARK */ + { 0x0040, 0x40 }, /* COMMERCIAL AT */ + { 0x0041, 0x41 }, /* LATIN CAPITAL LETTER A */ + { 0x0042, 0x42 }, /* LATIN CAPITAL LETTER B */ + { 0x0043, 0x43 }, /* LATIN CAPITAL LETTER C */ + { 0x0044, 0x44 }, /* LATIN CAPITAL LETTER D */ + { 0x0045, 0x45 }, /* LATIN CAPITAL LETTER E */ + { 0x0046, 0x46 }, /* LATIN CAPITAL LETTER F */ + { 0x0047, 0x47 }, /* LATIN CAPITAL LETTER G */ + { 0x0048, 0x48 }, /* LATIN CAPITAL LETTER H */ + { 0x0049, 0x49 }, /* LATIN CAPITAL LETTER I */ + { 0x004A, 0x4A }, /* LATIN CAPITAL LETTER J */ + { 0x004B, 0x4B }, /* LATIN CAPITAL LETTER K */ + { 0x004C, 0x4C }, /* LATIN CAPITAL LETTER L */ + { 0x004D, 0x4D }, /* LATIN CAPITAL LETTER M */ + { 0x004E, 0x4E }, /* LATIN CAPITAL LETTER N */ + { 0x004F, 0x4F }, /* LATIN CAPITAL LETTER O */ + { 0x0050, 0x50 }, /* LATIN CAPITAL LETTER P */ + { 0x0051, 0x51 }, /* LATIN CAPITAL LETTER Q */ + { 0x0052, 0x52 }, /* LATIN CAPITAL LETTER R */ + { 0x0053, 0x53 }, /* LATIN CAPITAL LETTER S */ + { 0x0054, 0x54 }, /* LATIN CAPITAL LETTER T */ + { 0x0055, 0x55 }, /* LATIN CAPITAL LETTER U */ + { 0x0056, 0x56 }, /* LATIN CAPITAL LETTER V */ + { 0x0057, 0x57 }, /* LATIN CAPITAL LETTER W */ + { 0x0058, 0x58 }, /* LATIN CAPITAL LETTER X */ + { 0x0059, 0x59 }, /* LATIN CAPITAL LETTER Y */ + { 0x005A, 0x5A }, /* LATIN CAPITAL LETTER Z */ + { 0x005B, 0x5B }, /* LEFT SQUARE BRACKET */ + { 0x005C, 0x5C }, /* REVERSE SOLIDUS */ + { 0x005D, 0x5D }, /* RIGHT SQUARE BRACKET */ + { 0x005E, 0x5E }, /* CIRCUMFLEX ACCENT */ + { 0x005F, 0x5F }, /* LOW LINE */ + { 0x0060, 0x60 }, /* GRAVE ACCENT */ + { 0x0061, 0x61 }, /* LATIN SMALL LETTER A */ + { 0x0062, 0x62 }, /* LATIN SMALL LETTER B */ + { 0x0063, 0x63 }, /* LATIN SMALL LETTER C */ + { 0x0064, 0x64 }, /* LATIN SMALL LETTER D */ + { 0x0065, 0x65 }, /* LATIN SMALL LETTER E */ + { 0x0066, 0x66 }, /* LATIN SMALL LETTER F */ + { 0x0067, 0x67 }, /* LATIN SMALL LETTER G */ + { 0x0068, 0x68 }, /* LATIN SMALL LETTER H */ + { 0x0069, 0x69 }, /* LATIN SMALL LETTER I */ + { 0x006A, 0x6A }, /* LATIN SMALL LETTER J */ + { 0x006B, 0x6B }, /* LATIN SMALL LETTER K */ + { 0x006C, 0x6C }, /* LATIN SMALL LETTER L */ + { 0x006D, 0x6D }, /* LATIN SMALL LETTER M */ + { 0x006E, 0x6E }, /* LATIN SMALL LETTER N */ + { 0x006F, 0x6F }, /* LATIN SMALL LETTER O */ + { 0x0070, 0x70 }, /* LATIN SMALL LETTER P */ + { 0x0071, 0x71 }, /* LATIN SMALL LETTER Q */ + { 0x0072, 0x72 }, /* LATIN SMALL LETTER R */ + { 0x0073, 0x73 }, /* LATIN SMALL LETTER S */ + { 0x0074, 0x74 }, /* LATIN SMALL LETTER T */ + { 0x0075, 0x75 }, /* LATIN SMALL LETTER U */ + { 0x0076, 0x76 }, /* LATIN SMALL LETTER V */ + { 0x0077, 0x77 }, /* LATIN SMALL LETTER W */ + { 0x0078, 0x78 }, /* LATIN SMALL LETTER X */ + { 0x0079, 0x79 }, /* LATIN SMALL LETTER Y */ + { 0x007A, 0x7A }, /* LATIN SMALL LETTER Z */ + { 0x007B, 0x7B }, /* LEFT CURLY BRACKET */ + { 0x007C, 0x7C }, /* VERTICAL LINE */ + { 0x007D, 0x7D }, /* RIGHT CURLY BRACKET */ + { 0x007E, 0x7E }, /* TILDE */ + { 0x00A0, 0xCA }, /* NO-BREAK SPACE */ + { 0x00A1, 0xC1 }, /* INVERTED EXCLAMATION MARK */ + { 0x00A2, 0xA2 }, /* CENT SIGN */ + { 0x00A3, 0xA3 }, /* POUND SIGN */ + { 0x00A5, 0xB4 }, /* YEN SIGN */ + { 0x00A7, 0xA4 }, /* SECTION SIGN */ + { 0x00A8, 0xAC }, /* DIAERESIS */ + { 0x00A9, 0xA9 }, /* COPYRIGHT SIGN */ + { 0x00AA, 0xBB }, /* FEMININE ORDINAL INDICATOR */ + { 0x00AB, 0xC7 }, /* LEFT-POINTING DOUBLE ANGLE QUOTATION MARK */ + { 0x00AC, 0xC2 }, /* NOT SIGN */ + { 0x00AE, 0xA8 }, /* REGISTERED SIGN */ + { 0x00AF, 0xF8 }, /* MACRON */ + { 0x00B0, 0xA1 }, /* DEGREE SIGN */ + { 0x00B1, 0xB1 }, /* PLUS-MINUS SIGN */ + { 0x00B4, 0xAB }, /* ACUTE ACCENT */ + { 0x00B5, 0xB5 }, /* MICRO SIGN */ + { 0x00B6, 0xA6 }, /* PILCROW SIGN */ + { 0x00B7, 0xE1 }, /* MIDDLE DOT */ + { 0x00B8, 0xFC }, /* CEDILLA */ + { 0x00BA, 0xBC }, /* MASCULINE ORDINAL INDICATOR */ + { 0x00BB, 0xC8 }, /* RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK */ + { 0x00BF, 0xC0 }, /* INVERTED QUESTION MARK */ + { 0x00C0, 0xCB }, /* LATIN CAPITAL LETTER A WITH GRAVE */ + { 0x00C1, 0xE7 }, /* LATIN CAPITAL LETTER A WITH ACUTE */ + { 0x00C2, 0xE5 }, /* LATIN CAPITAL LETTER A WITH CIRCUMFLEX */ + { 0x00C3, 0xCC }, /* LATIN CAPITAL LETTER A WITH TILDE */ + { 0x00C4, 0x80 }, /* LATIN CAPITAL LETTER A WITH DIAERESIS */ + { 0x00C5, 0x81 }, /* LATIN CAPITAL LETTER A WITH RING ABOVE */ + { 0x00C6, 0xAE }, /* LATIN CAPITAL LETTER AE */ + { 0x00C7, 0x82 }, /* LATIN CAPITAL LETTER C WITH CEDILLA */ + { 0x00C8, 0xE9 }, /* LATIN CAPITAL LETTER E WITH GRAVE */ + { 0x00C9, 0x83 }, /* LATIN CAPITAL LETTER E WITH ACUTE */ + { 0x00CA, 0xE6 }, /* LATIN CAPITAL LETTER E WITH CIRCUMFLEX */ + { 0x00CB, 0xE8 }, /* LATIN CAPITAL LETTER E WITH DIAERESIS */ + { 0x00CC, 0xED }, /* LATIN CAPITAL LETTER I WITH GRAVE */ + { 0x00CD, 0xEA }, /* LATIN CAPITAL LETTER I WITH ACUTE */ + { 0x00CE, 0xEB }, /* LATIN CAPITAL LETTER I WITH CIRCUMFLEX */ + { 0x00CF, 0xEC }, /* LATIN CAPITAL LETTER I WITH DIAERESIS */ + { 0x00D1, 0x84 }, /* LATIN CAPITAL LETTER N WITH TILDE */ + { 0x00D2, 0xF1 }, /* LATIN CAPITAL LETTER O WITH GRAVE */ + { 0x00D3, 0xEE }, /* LATIN CAPITAL LETTER O WITH ACUTE */ + { 0x00D4, 0xEF }, /* LATIN CAPITAL LETTER O WITH CIRCUMFLEX */ + { 0x00D5, 0xCD }, /* LATIN CAPITAL LETTER O WITH TILDE */ + { 0x00D6, 0x85 }, /* LATIN CAPITAL LETTER O WITH DIAERESIS */ + { 0x00D8, 0xAF }, /* LATIN CAPITAL LETTER O WITH STROKE */ + { 0x00D9, 0xF4 }, /* LATIN CAPITAL LETTER U WITH GRAVE */ + { 0x00DA, 0xF2 }, /* LATIN CAPITAL LETTER U WITH ACUTE */ + { 0x00DB, 0xF3 }, /* LATIN CAPITAL LETTER U WITH CIRCUMFLEX */ + { 0x00DC, 0x86 }, /* LATIN CAPITAL LETTER U WITH DIAERESIS */ + { 0x00DF, 0xA7 }, /* LATIN SMALL LETTER SHARP S */ + { 0x00E0, 0x88 }, /* LATIN SMALL LETTER A WITH GRAVE */ + { 0x00E1, 0x87 }, /* LATIN SMALL LETTER A WITH ACUTE */ + { 0x00E2, 0x89 }, /* LATIN SMALL LETTER A WITH CIRCUMFLEX */ + { 0x00E3, 0x8B }, /* LATIN SMALL LETTER A WITH TILDE */ + { 0x00E4, 0x8A }, /* LATIN SMALL LETTER A WITH DIAERESIS */ + { 0x00E5, 0x8C }, /* LATIN SMALL LETTER A WITH RING ABOVE */ + { 0x00E6, 0xBE }, /* LATIN SMALL LETTER AE */ + { 0x00E7, 0x8D }, /* LATIN SMALL LETTER C WITH CEDILLA */ + { 0x00E8, 0x8F }, /* LATIN SMALL LETTER E WITH GRAVE */ + { 0x00E9, 0x8E }, /* LATIN SMALL LETTER E WITH ACUTE */ + { 0x00EA, 0x90 }, /* LATIN SMALL LETTER E WITH CIRCUMFLEX */ + { 0x00EB, 0x91 }, /* LATIN SMALL LETTER E WITH DIAERESIS */ + { 0x00EC, 0x93 }, /* LATIN SMALL LETTER I WITH GRAVE */ + { 0x00ED, 0x92 }, /* LATIN SMALL LETTER I WITH ACUTE */ + { 0x00EE, 0x94 }, /* LATIN SMALL LETTER I WITH CIRCUMFLEX */ + { 0x00EF, 0x95 }, /* LATIN SMALL LETTER I WITH DIAERESIS */ + { 0x00F1, 0x96 }, /* LATIN SMALL LETTER N WITH TILDE */ + { 0x00F2, 0x98 }, /* LATIN SMALL LETTER O WITH GRAVE */ + { 0x00F3, 0x97 }, /* LATIN SMALL LETTER O WITH ACUTE */ + { 0x00F4, 0x99 }, /* LATIN SMALL LETTER O WITH CIRCUMFLEX */ + { 0x00F5, 0x9B }, /* LATIN SMALL LETTER O WITH TILDE */ + { 0x00F6, 0x9A }, /* LATIN SMALL LETTER O WITH DIAERESIS */ + { 0x00F7, 0xD6 }, /* DIVISION SIGN */ + { 0x00F8, 0xBF }, /* LATIN SMALL LETTER O WITH STROKE */ + { 0x00F9, 0x9D }, /* LATIN SMALL LETTER U WITH GRAVE */ + { 0x00FA, 0x9C }, /* LATIN SMALL LETTER U WITH ACUTE */ + { 0x00FB, 0x9E }, /* LATIN SMALL LETTER U WITH CIRCUMFLEX */ + { 0x00FC, 0x9F }, /* LATIN SMALL LETTER U WITH DIAERESIS */ + { 0x00FF, 0xD8 }, /* LATIN SMALL LETTER Y WITH DIAERESIS */ + { 0x0131, 0xF5 }, /* LATIN SMALL LETTER DOTLESS I */ + { 0x0152, 0xCE }, /* LATIN CAPITAL LIGATURE OE */ + { 0x0153, 0xCF }, /* LATIN SMALL LIGATURE OE */ + { 0x0178, 0xD9 }, /* LATIN CAPITAL LETTER Y WITH DIAERESIS */ + { 0x0192, 0xC4 }, /* LATIN SMALL LETTER F WITH HOOK */ + { 0x02C6, 0xF6 }, /* MODIFIER LETTER CIRCUMFLEX ACCENT */ + { 0x02C7, 0xFF }, /* CARON */ + { 0x02D8, 0xF9 }, /* BREVE */ + { 0x02D9, 0xFA }, /* DOT ABOVE */ + { 0x02DA, 0xFB }, /* RING ABOVE */ + { 0x02DB, 0xFE }, /* OGONEK */ + { 0x02DC, 0xF7 }, /* SMALL TILDE */ + { 0x02DD, 0xFD }, /* DOUBLE ACUTE ACCENT */ + { 0x03A9, 0xBD }, /* GREEK CAPITAL LETTER OMEGA */ + { 0x03C0, 0xB9 }, /* GREEK SMALL LETTER PI */ + { 0x2013, 0xD0 }, /* EN DASH */ + { 0x2014, 0xD1 }, /* EM DASH */ + { 0x2018, 0xD4 }, /* LEFT SINGLE QUOTATION MARK */ + { 0x2019, 0xD5 }, /* RIGHT SINGLE QUOTATION MARK */ + { 0x201A, 0xE2 }, /* SINGLE LOW-9 QUOTATION MARK */ + { 0x201C, 0xD2 }, /* LEFT DOUBLE QUOTATION MARK */ + { 0x201D, 0xD3 }, /* RIGHT DOUBLE QUOTATION MARK */ + { 0x201E, 0xE3 }, /* DOUBLE LOW-9 QUOTATION MARK */ + { 0x2020, 0xA0 }, /* DAGGER */ + { 0x2021, 0xE0 }, /* DOUBLE DAGGER */ + { 0x2022, 0xA5 }, /* BULLET */ + { 0x2026, 0xC9 }, /* HORIZONTAL ELLIPSIS */ + { 0x2030, 0xE4 }, /* PER MILLE SIGN */ + { 0x2039, 0xDC }, /* SINGLE LEFT-POINTING ANGLE QUOTATION MARK */ + { 0x203A, 0xDD }, /* SINGLE RIGHT-POINTING ANGLE QUOTATION MARK */ + { 0x2044, 0xDA }, /* FRACTION SLASH */ + { 0x20AC, 0xDB }, /* EURO SIGN */ + { 0x2122, 0xAA }, /* TRADE MARK SIGN */ + { 0x2202, 0xB6 }, /* PARTIAL DIFFERENTIAL */ + { 0x2206, 0xC6 }, /* INCREMENT */ + { 0x220F, 0xB8 }, /* N-ARY PRODUCT */ + { 0x2211, 0xB7 }, /* N-ARY SUMMATION */ + { 0x221A, 0xC3 }, /* SQUARE ROOT */ + { 0x221E, 0xB0 }, /* INFINITY */ + { 0x222B, 0xBA }, /* INTEGRAL */ + { 0x2248, 0xC5 }, /* ALMOST EQUAL TO */ + { 0x2260, 0xAD }, /* NOT EQUAL TO */ + { 0x2264, 0xB2 }, /* LESS-THAN OR EQUAL TO */ + { 0x2265, 0xB3 }, /* GREATER-THAN OR EQUAL TO */ + { 0x25CA, 0xD7 }, /* LOZENGE */ + { 0xF8FF, 0xF0 }, /* Apple logo */ + { 0xFB01, 0xDE }, /* LATIN SMALL LIGATURE FI */ + { 0xFB02, 0xDF }, /* LATIN SMALL LIGATURE FL */ +}; + +static const FcCharMap AppleRoman = { + AppleRomanEnt, + sizeof (AppleRomanEnt) / sizeof (AppleRomanEnt[0]) +}; + +static const FcCharEnt AdobeSymbolEnt[] = { + { 0x0020, 0x20 }, /* SPACE # space */ + { 0x0021, 0x21 }, /* EXCLAMATION MARK # exclam */ + { 0x0023, 0x23 }, /* NUMBER SIGN # numbersign */ + { 0x0025, 0x25 }, /* PERCENT SIGN # percent */ + { 0x0026, 0x26 }, /* AMPERSAND # ampersand */ + { 0x0028, 0x28 }, /* LEFT PARENTHESIS # parenleft */ + { 0x0029, 0x29 }, /* RIGHT PARENTHESIS # parenright */ + { 0x002B, 0x2B }, /* PLUS SIGN # plus */ + { 0x002C, 0x2C }, /* COMMA # comma */ + { 0x002E, 0x2E }, /* FULL STOP # period */ + { 0x002F, 0x2F }, /* SOLIDUS # slash */ + { 0x0030, 0x30 }, /* DIGIT ZERO # zero */ + { 0x0031, 0x31 }, /* DIGIT ONE # one */ + { 0x0032, 0x32 }, /* DIGIT TWO # two */ + { 0x0033, 0x33 }, /* DIGIT THREE # three */ + { 0x0034, 0x34 }, /* DIGIT FOUR # four */ + { 0x0035, 0x35 }, /* DIGIT FIVE # five */ + { 0x0036, 0x36 }, /* DIGIT SIX # six */ + { 0x0037, 0x37 }, /* DIGIT SEVEN # seven */ + { 0x0038, 0x38 }, /* DIGIT EIGHT # eight */ + { 0x0039, 0x39 }, /* DIGIT NINE # nine */ + { 0x003A, 0x3A }, /* COLON # colon */ + { 0x003B, 0x3B }, /* SEMICOLON # semicolon */ + { 0x003C, 0x3C }, /* LESS-THAN SIGN # less */ + { 0x003D, 0x3D }, /* EQUALS SIGN # equal */ + { 0x003E, 0x3E }, /* GREATER-THAN SIGN # greater */ + { 0x003F, 0x3F }, /* QUESTION MARK # question */ + { 0x005B, 0x5B }, /* LEFT SQUARE BRACKET # bracketleft */ + { 0x005D, 0x5D }, /* RIGHT SQUARE BRACKET # bracketright */ + { 0x005F, 0x5F }, /* LOW LINE # underscore */ + { 0x007B, 0x7B }, /* LEFT CURLY BRACKET # braceleft */ + { 0x007C, 0x7C }, /* VERTICAL LINE # bar */ + { 0x007D, 0x7D }, /* RIGHT CURLY BRACKET # braceright */ + { 0x00A0, 0x20 }, /* NO-BREAK SPACE # space */ + { 0x00AC, 0xD8 }, /* NOT SIGN # logicalnot */ + { 0x00B0, 0xB0 }, /* DEGREE SIGN # degree */ + { 0x00B1, 0xB1 }, /* PLUS-MINUS SIGN # plusminus */ + { 0x00B5, 0x6D }, /* MICRO SIGN # mu */ + { 0x00D7, 0xB4 }, /* MULTIPLICATION SIGN # multiply */ + { 0x00F7, 0xB8 }, /* DIVISION SIGN # divide */ + { 0x0192, 0xA6 }, /* LATIN SMALL LETTER F WITH HOOK # florin */ + { 0x0391, 0x41 }, /* GREEK CAPITAL LETTER ALPHA # Alpha */ + { 0x0392, 0x42 }, /* GREEK CAPITAL LETTER BETA # Beta */ + { 0x0393, 0x47 }, /* GREEK CAPITAL LETTER GAMMA # Gamma */ + { 0x0394, 0x44 }, /* GREEK CAPITAL LETTER DELTA # Delta */ + { 0x0395, 0x45 }, /* GREEK CAPITAL LETTER EPSILON # Epsilon */ + { 0x0396, 0x5A }, /* GREEK CAPITAL LETTER ZETA # Zeta */ + { 0x0397, 0x48 }, /* GREEK CAPITAL LETTER ETA # Eta */ + { 0x0398, 0x51 }, /* GREEK CAPITAL LETTER THETA # Theta */ + { 0x0399, 0x49 }, /* GREEK CAPITAL LETTER IOTA # Iota */ + { 0x039A, 0x4B }, /* GREEK CAPITAL LETTER KAPPA # Kappa */ + { 0x039B, 0x4C }, /* GREEK CAPITAL LETTER LAMDA # Lambda */ + { 0x039C, 0x4D }, /* GREEK CAPITAL LETTER MU # Mu */ + { 0x039D, 0x4E }, /* GREEK CAPITAL LETTER NU # Nu */ + { 0x039E, 0x58 }, /* GREEK CAPITAL LETTER XI # Xi */ + { 0x039F, 0x4F }, /* GREEK CAPITAL LETTER OMICRON # Omicron */ + { 0x03A0, 0x50 }, /* GREEK CAPITAL LETTER PI # Pi */ + { 0x03A1, 0x52 }, /* GREEK CAPITAL LETTER RHO # Rho */ + { 0x03A3, 0x53 }, /* GREEK CAPITAL LETTER SIGMA # Sigma */ + { 0x03A4, 0x54 }, /* GREEK CAPITAL LETTER TAU # Tau */ + { 0x03A5, 0x55 }, /* GREEK CAPITAL LETTER UPSILON # Upsilon */ + { 0x03A6, 0x46 }, /* GREEK CAPITAL LETTER PHI # Phi */ + { 0x03A7, 0x43 }, /* GREEK CAPITAL LETTER CHI # Chi */ + { 0x03A8, 0x59 }, /* GREEK CAPITAL LETTER PSI # Psi */ + { 0x03A9, 0x57 }, /* GREEK CAPITAL LETTER OMEGA # Omega */ + { 0x03B1, 0x61 }, /* GREEK SMALL LETTER ALPHA # alpha */ + { 0x03B2, 0x62 }, /* GREEK SMALL LETTER BETA # beta */ + { 0x03B3, 0x67 }, /* GREEK SMALL LETTER GAMMA # gamma */ + { 0x03B4, 0x64 }, /* GREEK SMALL LETTER DELTA # delta */ + { 0x03B5, 0x65 }, /* GREEK SMALL LETTER EPSILON # epsilon */ + { 0x03B6, 0x7A }, /* GREEK SMALL LETTER ZETA # zeta */ + { 0x03B7, 0x68 }, /* GREEK SMALL LETTER ETA # eta */ + { 0x03B8, 0x71 }, /* GREEK SMALL LETTER THETA # theta */ + { 0x03B9, 0x69 }, /* GREEK SMALL LETTER IOTA # iota */ + { 0x03BA, 0x6B }, /* GREEK SMALL LETTER KAPPA # kappa */ + { 0x03BB, 0x6C }, /* GREEK SMALL LETTER LAMDA # lambda */ + { 0x03BC, 0x6D }, /* GREEK SMALL LETTER MU # mu */ + { 0x03BD, 0x6E }, /* GREEK SMALL LETTER NU # nu */ + { 0x03BE, 0x78 }, /* GREEK SMALL LETTER XI # xi */ + { 0x03BF, 0x6F }, /* GREEK SMALL LETTER OMICRON # omicron */ + { 0x03C0, 0x70 }, /* GREEK SMALL LETTER PI # pi */ + { 0x03C1, 0x72 }, /* GREEK SMALL LETTER RHO # rho */ + { 0x03C2, 0x56 }, /* GREEK SMALL LETTER FINAL SIGMA # sigma1 */ + { 0x03C3, 0x73 }, /* GREEK SMALL LETTER SIGMA # sigma */ + { 0x03C4, 0x74 }, /* GREEK SMALL LETTER TAU # tau */ + { 0x03C5, 0x75 }, /* GREEK SMALL LETTER UPSILON # upsilon */ + { 0x03C6, 0x66 }, /* GREEK SMALL LETTER PHI # phi */ + { 0x03C7, 0x63 }, /* GREEK SMALL LETTER CHI # chi */ + { 0x03C8, 0x79 }, /* GREEK SMALL LETTER PSI # psi */ + { 0x03C9, 0x77 }, /* GREEK SMALL LETTER OMEGA # omega */ + { 0x03D1, 0x4A }, /* GREEK THETA SYMBOL # theta1 */ + { 0x03D2, 0xA1 }, /* GREEK UPSILON WITH HOOK SYMBOL # Upsilon1 */ + { 0x03D5, 0x6A }, /* GREEK PHI SYMBOL # phi1 */ + { 0x03D6, 0x76 }, /* GREEK PI SYMBOL # omega1 */ + { 0x2022, 0xB7 }, /* BULLET # bullet */ + { 0x2026, 0xBC }, /* HORIZONTAL ELLIPSIS # ellipsis */ + { 0x2032, 0xA2 }, /* PRIME # minute */ + { 0x2033, 0xB2 }, /* DOUBLE PRIME # second */ + { 0x2044, 0xA4 }, /* FRACTION SLASH # fraction */ + { 0x20AC, 0xA0 }, /* EURO SIGN # Euro */ + { 0x2111, 0xC1 }, /* BLACK-LETTER CAPITAL I # Ifraktur */ + { 0x2118, 0xC3 }, /* SCRIPT CAPITAL P # weierstrass */ + { 0x211C, 0xC2 }, /* BLACK-LETTER CAPITAL R # Rfraktur */ + { 0x2126, 0x57 }, /* OHM SIGN # Omega */ + { 0x2135, 0xC0 }, /* ALEF SYMBOL # aleph */ + { 0x2190, 0xAC }, /* LEFTWARDS ARROW # arrowleft */ + { 0x2191, 0xAD }, /* UPWARDS ARROW # arrowup */ + { 0x2192, 0xAE }, /* RIGHTWARDS ARROW # arrowright */ + { 0x2193, 0xAF }, /* DOWNWARDS ARROW # arrowdown */ + { 0x2194, 0xAB }, /* LEFT RIGHT ARROW # arrowboth */ + { 0x21B5, 0xBF }, /* DOWNWARDS ARROW WITH CORNER LEFTWARDS # carriagereturn */ + { 0x21D0, 0xDC }, /* LEFTWARDS DOUBLE ARROW # arrowdblleft */ + { 0x21D1, 0xDD }, /* UPWARDS DOUBLE ARROW # arrowdblup */ + { 0x21D2, 0xDE }, /* RIGHTWARDS DOUBLE ARROW # arrowdblright */ + { 0x21D3, 0xDF }, /* DOWNWARDS DOUBLE ARROW # arrowdbldown */ + { 0x21D4, 0xDB }, /* LEFT RIGHT DOUBLE ARROW # arrowdblboth */ + { 0x2200, 0x22 }, /* FOR ALL # universal */ + { 0x2202, 0xB6 }, /* PARTIAL DIFFERENTIAL # partialdiff */ + { 0x2203, 0x24 }, /* THERE EXISTS # existential */ + { 0x2205, 0xC6 }, /* EMPTY SET # emptyset */ + { 0x2206, 0x44 }, /* INCREMENT # Delta */ + { 0x2207, 0xD1 }, /* NABLA # gradient */ + { 0x2208, 0xCE }, /* ELEMENT OF # element */ + { 0x2209, 0xCF }, /* NOT AN ELEMENT OF # notelement */ + { 0x220B, 0x27 }, /* CONTAINS AS MEMBER # suchthat */ + { 0x220F, 0xD5 }, /* N-ARY PRODUCT # product */ + { 0x2211, 0xE5 }, /* N-ARY SUMMATION # summation */ + { 0x2212, 0x2D }, /* MINUS SIGN # minus */ + { 0x2215, 0xA4 }, /* DIVISION SLASH # fraction */ + { 0x2217, 0x2A }, /* ASTERISK OPERATOR # asteriskmath */ + { 0x221A, 0xD6 }, /* SQUARE ROOT # radical */ + { 0x221D, 0xB5 }, /* PROPORTIONAL TO # proportional */ + { 0x221E, 0xA5 }, /* INFINITY # infinity */ + { 0x2220, 0xD0 }, /* ANGLE # angle */ + { 0x2227, 0xD9 }, /* LOGICAL AND # logicaland */ + { 0x2228, 0xDA }, /* LOGICAL OR # logicalor */ + { 0x2229, 0xC7 }, /* INTERSECTION # intersection */ + { 0x222A, 0xC8 }, /* UNION # union */ + { 0x222B, 0xF2 }, /* INTEGRAL # integral */ + { 0x2234, 0x5C }, /* THEREFORE # therefore */ + { 0x223C, 0x7E }, /* TILDE OPERATOR # similar */ + { 0x2245, 0x40 }, /* APPROXIMATELY EQUAL TO # congruent */ + { 0x2248, 0xBB }, /* ALMOST EQUAL TO # approxequal */ + { 0x2260, 0xB9 }, /* NOT EQUAL TO # notequal */ + { 0x2261, 0xBA }, /* IDENTICAL TO # equivalence */ + { 0x2264, 0xA3 }, /* LESS-THAN OR EQUAL TO # lessequal */ + { 0x2265, 0xB3 }, /* GREATER-THAN OR EQUAL TO # greaterequal */ + { 0x2282, 0xCC }, /* SUBSET OF # propersubset */ + { 0x2283, 0xC9 }, /* SUPERSET OF # propersuperset */ + { 0x2284, 0xCB }, /* NOT A SUBSET OF # notsubset */ + { 0x2286, 0xCD }, /* SUBSET OF OR EQUAL TO # reflexsubset */ + { 0x2287, 0xCA }, /* SUPERSET OF OR EQUAL TO # reflexsuperset */ + { 0x2295, 0xC5 }, /* CIRCLED PLUS # circleplus */ + { 0x2297, 0xC4 }, /* CIRCLED TIMES # circlemultiply */ + { 0x22A5, 0x5E }, /* UP TACK # perpendicular */ + { 0x22C5, 0xD7 }, /* DOT OPERATOR # dotmath */ + { 0x2320, 0xF3 }, /* TOP HALF INTEGRAL # integraltp */ + { 0x2321, 0xF5 }, /* BOTTOM HALF INTEGRAL # integralbt */ + { 0x2329, 0xE1 }, /* LEFT-POINTING ANGLE BRACKET # angleleft */ + { 0x232A, 0xF1 }, /* RIGHT-POINTING ANGLE BRACKET # angleright */ + { 0x25CA, 0xE0 }, /* LOZENGE # lozenge */ + { 0x2660, 0xAA }, /* BLACK SPADE SUIT # spade */ + { 0x2663, 0xA7 }, /* BLACK CLUB SUIT # club */ + { 0x2665, 0xA9 }, /* BLACK HEART SUIT # heart */ + { 0x2666, 0xA8 }, /* BLACK DIAMOND SUIT # diamond */ + { 0xF6D9, 0xD3 }, /* COPYRIGHT SIGN SERIF # copyrightserif (CUS) */ + { 0xF6DA, 0xD2 }, /* REGISTERED SIGN SERIF # registerserif (CUS) */ + { 0xF6DB, 0xD4 }, /* TRADE MARK SIGN SERIF # trademarkserif (CUS) */ + { 0xF8E5, 0x60 }, /* RADICAL EXTENDER # radicalex (CUS) */ + { 0xF8E6, 0xBD }, /* VERTICAL ARROW EXTENDER # arrowvertex (CUS) */ + { 0xF8E7, 0xBE }, /* HORIZONTAL ARROW EXTENDER # arrowhorizex (CUS) */ + { 0xF8E8, 0xE2 }, /* REGISTERED SIGN SANS SERIF # registersans (CUS) */ + { 0xF8E9, 0xE3 }, /* COPYRIGHT SIGN SANS SERIF # copyrightsans (CUS) */ + { 0xF8EA, 0xE4 }, /* TRADE MARK SIGN SANS SERIF # trademarksans (CUS) */ + { 0xF8EB, 0xE6 }, /* LEFT PAREN TOP # parenlefttp (CUS) */ + { 0xF8EC, 0xE7 }, /* LEFT PAREN EXTENDER # parenleftex (CUS) */ + { 0xF8ED, 0xE8 }, /* LEFT PAREN BOTTOM # parenleftbt (CUS) */ + { 0xF8EE, 0xE9 }, /* LEFT SQUARE BRACKET TOP # bracketlefttp (CUS) */ + { 0xF8EF, 0xEA }, /* LEFT SQUARE BRACKET EXTENDER # bracketleftex (CUS) */ + { 0xF8F0, 0xEB }, /* LEFT SQUARE BRACKET BOTTOM # bracketleftbt (CUS) */ + { 0xF8F1, 0xEC }, /* LEFT CURLY BRACKET TOP # bracelefttp (CUS) */ + { 0xF8F2, 0xED }, /* LEFT CURLY BRACKET MID # braceleftmid (CUS) */ + { 0xF8F3, 0xEE }, /* LEFT CURLY BRACKET BOTTOM # braceleftbt (CUS) */ + { 0xF8F4, 0xEF }, /* CURLY BRACKET EXTENDER # braceex (CUS) */ + { 0xF8F5, 0xF4 }, /* INTEGRAL EXTENDER # integralex (CUS) */ + { 0xF8F6, 0xF6 }, /* RIGHT PAREN TOP # parenrighttp (CUS) */ + { 0xF8F7, 0xF7 }, /* RIGHT PAREN EXTENDER # parenrightex (CUS) */ + { 0xF8F8, 0xF8 }, /* RIGHT PAREN BOTTOM # parenrightbt (CUS) */ + { 0xF8F9, 0xF9 }, /* RIGHT SQUARE BRACKET TOP # bracketrighttp (CUS) */ + { 0xF8FA, 0xFA }, /* RIGHT SQUARE BRACKET EXTENDER # bracketrightex (CUS) */ + { 0xF8FB, 0xFB }, /* RIGHT SQUARE BRACKET BOTTOM # bracketrightbt (CUS) */ + { 0xF8FC, 0xFC }, /* RIGHT CURLY BRACKET TOP # bracerighttp (CUS) */ + { 0xF8FD, 0xFD }, /* RIGHT CURLY BRACKET MID # bracerightmid (CUS) */ + { 0xF8FE, 0xFE }, /* RIGHT CURLY BRACKET BOTTOM # bracerightbt (CUS) */ +}; + +static const FcCharMap AdobeSymbol = { + AdobeSymbolEnt, + sizeof (AdobeSymbolEnt) / sizeof (AdobeSymbolEnt[0]), +}; + +static const FcFontDecode fcFontDecoders[] = { + { ft_encoding_unicode, 0, (1 << 21) - 1 }, + { ft_encoding_symbol, &AdobeSymbol, (1 << 16) - 1 }, + { ft_encoding_apple_roman, &AppleRoman, (1 << 16) - 1 }, +}; + +#define NUM_DECODE (sizeof (fcFontDecoders) / sizeof (fcFontDecoders[0])) + +FcChar32 +FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map) +{ + int low, high, mid; + FcChar16 bmp; + + low = 0; + high = map->nent - 1; + if (ucs4 < map->ent[low].bmp || map->ent[high].bmp < ucs4) + return ~0; + while (low <= high) + { + mid = (high + low) >> 1; + bmp = map->ent[mid].bmp; + if (ucs4 == bmp) + return (FT_ULong) map->ent[mid].encode; + if (ucs4 < bmp) + high = mid - 1; + else + low = mid + 1; + } + return ~0; +} + +FcChar32 +FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map) +{ + int i; + + for (i = 0; i < map->nent; i++) + if (map->ent[i].encode == private) + return (FcChar32) map->ent[i].bmp; + return ~0; +} + +const FcCharMap * +FcFreeTypeGetPrivateMap (FT_Encoding encoding) +{ + int i; + + for (i = 0; i < NUM_DECODE; i++) + if (fcFontDecoders[i].encoding == encoding) + return fcFontDecoders[i].map; + return 0; +} + +/* + * Map a UCS4 glyph to a glyph index. Use all available encoding + * tables to try and find one that works. This information is expected + * to be cached by higher levels, so performance isn't critical + */ + +FT_UInt +FcFreeTypeCharIndex (FT_Face face, FcChar32 ucs4) +{ + int initial, offset, decode; + FT_UInt glyphindex; + FcChar32 charcode; + + initial = 0; + /* + * Find the current encoding + */ + if (face->charmap) + { + for (; initial < NUM_DECODE; initial++) + if (fcFontDecoders[initial].encoding == face->charmap->encoding) + break; + if (initial == NUM_DECODE) + initial = 0; + } + /* + * Check each encoding for the glyph, starting with the current one + */ + for (offset = 0; offset < NUM_DECODE; offset++) + { + decode = (initial + offset) % NUM_DECODE; + if (!face->charmap || face->charmap->encoding != fcFontDecoders[decode].encoding) + if (FT_Select_Charmap (face, fcFontDecoders[decode].encoding) != 0) + continue; + if (fcFontDecoders[decode].map) + { + charcode = FcFreeTypeUcs4ToPrivate (ucs4, fcFontDecoders[decode].map); + if (charcode == ~0) + continue; + } + else + charcode = ucs4; + glyphindex = FT_Get_Char_Index (face, (FT_ULong) charcode); + if (glyphindex) + return glyphindex; + } + return 0; +} + +static FcBool +FcFreeTypeCheckGlyph (FT_Face face, FcChar32 ucs4, + FT_UInt glyph, FcBlanks *blanks, + FT_Pos *advance) +{ + FT_Int load_flags = FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING; + FT_GlyphSlot slot; + + /* + * When using scalable fonts, only report those glyphs + * which can be scaled; otherwise those fonts will + * only be available at some sizes, and never when + * transformed. Avoid this by simply reporting bitmap-only + * glyphs as missing + */ + if (face->face_flags & FT_FACE_FLAG_SCALABLE) + load_flags |= FT_LOAD_NO_BITMAP; + + if (FT_Load_Glyph (face, glyph, load_flags)) + return FcFalse; + + slot = face->glyph; + if (!glyph) + return FcFalse; + + *advance = slot->metrics.horiAdvance; + + switch (slot->format) { + case ft_glyph_format_bitmap: + /* + * Bitmaps are assumed to be reasonable; if + * this proves to be a rash assumption, this + * code can be easily modified + */ + return FcTrue; + case ft_glyph_format_outline: + /* + * Glyphs with contours are always OK + */ + if (slot->outline.n_contours != 0) + return FcTrue; + /* + * Glyphs with no contours are only OK if + * they're members of the Blanks set specified + * in the configuration. If blanks isn't set, + * then allow any glyph to be blank + */ + if (!blanks || FcBlanksIsMember (blanks, ucs4)) + return FcTrue; + /* fall through ... */ + default: + break; + } + return FcFalse; +} + +FcCharSet * +FcFreeTypeCharSetAndSpacing (FT_Face face, FcBlanks *blanks, int *spacing) +{ + FcChar32 page, off, max, ucs4; +#ifdef CHECK + FcChar32 font_max = 0; +#endif + FcCharSet *fcs; + FcCharLeaf *leaf; + const FcCharMap *map; + int o; + int i; + FT_UInt glyph; + FT_Pos advance, all_advance = 0; + FcBool has_advance = FcFalse, fixed_advance = FcTrue; + + fcs = FcCharSetCreate (); + if (!fcs) + goto bail0; + + for (o = 0; o < NUM_DECODE; o++) + { + if (FT_Select_Charmap (face, fcFontDecoders[o].encoding) != 0) + continue; + map = fcFontDecoders[o].map; + if (map) + { + /* + * Non-Unicode tables are easy; there's a list of all possible + * characters + */ + for (i = 0; i < map->nent; i++) + { + ucs4 = map->ent[i].bmp; + glyph = FT_Get_Char_Index (face, map->ent[i].encode); + if (glyph && + FcFreeTypeCheckGlyph (face, ucs4, glyph, blanks, &advance)) + { + if (!has_advance) + { + has_advance = FcTrue; + all_advance = advance; + } + else if (advance != all_advance) + fixed_advance = FcFalse; + leaf = FcCharSetFindLeafCreate (fcs, ucs4); + if (!leaf) + goto bail1; + leaf->map[(ucs4 & 0xff) >> 5] |= (1 << (ucs4 & 0x1f)); +#ifdef CHECK + if (ucs4 > font_max) + font_max = ucs4; +#endif + } + } + } + else + { + FT_UInt gindex; + + max = fcFontDecoders[o].max; + /* + * Find the first encoded character in the font + */ + if (FT_Get_Char_Index (face, 0)) + { + ucs4 = 0; + gindex = 1; + } + else + { + ucs4 = FT_Get_Next_Char (face, 0, &gindex); + if (!ucs4) + gindex = 0; + } + + while (gindex) + { + page = ucs4 >> 8; + leaf = 0; + while ((ucs4 >> 8) == page) + { + glyph = FT_Get_Char_Index (face, ucs4); + if (glyph && FcFreeTypeCheckGlyph (face, ucs4, + glyph, blanks, &advance)) + { + if (!has_advance) + { + has_advance = FcTrue; + all_advance = advance; + } + else if (advance != all_advance) + fixed_advance = FcFalse; + if (!leaf) + { + leaf = FcCharSetFindLeafCreate (fcs, ucs4); + if (!leaf) + goto bail1; + } + off = ucs4 & 0xff; + leaf->map[off >> 5] |= (1 << (off & 0x1f)); +#ifdef CHECK + if (ucs4 > font_max) + font_max = ucs4; +#endif + } + ucs4++; + } + ucs4 = FT_Get_Next_Char (face, ucs4 - 1, &gindex); + if (!ucs4) + gindex = 0; + } +#ifdef CHECK + for (ucs4 = 0; ucs4 < 0x10000; ucs4++) + { + FcBool FT_Has, FC_Has; + + FT_Has = FT_Get_Char_Index (face, ucs4) != 0; + FC_Has = FcCharSetHasChar (fcs, ucs4); + if (FT_Has != FC_Has) + { + printf ("0x%08x FT says %d FC says %d\n", ucs4, FT_Has, FC_Has); + } + } +#endif + } + } +#ifdef CHECK + printf ("%d glyphs %d encoded\n", (int) face->num_glyphs, FcCharSetCount (fcs)); + for (ucs4 = 0; ucs4 <= font_max; ucs4++) + { + FcBool has_char = FcFreeTypeCharIndex (face, ucs4) != 0; + FcBool has_bit = FcCharSetHasChar (fcs, ucs4); + + if (has_char && !has_bit) + printf ("Bitmap missing char 0x%x\n", ucs4); + else if (!has_char && has_bit) + printf ("Bitmap extra char 0x%x\n", ucs4); + } +#endif + if (fixed_advance) + *spacing = FC_MONO; + else + *spacing = FC_PROPORTIONAL; + return fcs; +bail1: + FcCharSetDestroy (fcs); +bail0: + return 0; +} + +FcCharSet * +FcFreeTypeCharSet (FT_Face face, FcBlanks *blanks) +{ + int spacing; + + return FcFreeTypeCharSetAndSpacing (face, blanks, &spacing); +} --- xc/extras/fontconfig/src/fccache.c 2003-12-03 05:57:04.000000000 +0100 +++ xc-fontconfig/extras/fontconfig/src/fccache.c 2003-12-21 12:27:04.000000000 +0100 @@ -1,5 +1,7 @@ /* - * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * $RCSId: xc/lib/fontconfig/src/fccache.c,v 1.12 2002/08/22 07:36:44 keithp Exp $ + * + * Copyright © 2000 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that @@ -187,9 +189,19 @@ if (dir) if (!FcCacheWriteChars (f, dir)) return FcFalse; +#ifdef _WIN32 + if (dir && + dir[strlen((const char *) dir) - 1] != '/' && + dir[strlen((const char *) dir) - 1] != '\\') + { + if (!FcCacheWriteChars (f, "\\")) + return FcFalse; + } +#else if (dir && dir[strlen((const char *) dir) - 1] != '/') if (PUTC ('/', f) == EOF) return FcFalse; +#endif if (!FcCacheWriteChars (f, file)) return FcFalse; if (PUTC ('"', f) == EOF) @@ -257,8 +269,13 @@ return FcFalse; } strncpy ((char *) path, (const char *) dir, dir_len); +#ifdef _WIN32 + if (dir[dir_len - 1] != '/' && dir[dir_len - 1] != '\\' ) + path[dir_len++] = '\\'; +#else if (dir[dir_len - 1] != '/') path[dir_len++] = '/'; +#endif strcpy ((char *) path + dir_len, (const char *) file); if (!FcStrCmp (name, FC_FONT_FILE_DIR)) { @@ -294,28 +311,28 @@ } static unsigned int -FcCacheHash (const FcChar8 *string) +FcCacheHash (const FcChar8 *string, int len) { unsigned int h = 0; FcChar8 c; - while ((c = *string++)) + while (len-- && (c = *string++)) h = (h << 1) ^ c; - return 0; + return h; } /* * Verify the saved timestamp for a file */ FcBool -FcGlobalCacheCheckTime (FcGlobalCacheInfo *info) +FcGlobalCacheCheckTime (const FcChar8 *file, FcGlobalCacheInfo *info) { struct stat statb; - if (stat ((char *) info->file, &statb) < 0) + if (stat ((char *) file, &statb) < 0) { if (FcDebug () & FC_DBG_CACHE) - printf (" file missing\n"); + printf (" file %s missing\n", file); return FcFalse; } if (statb.st_mtime != info->time) @@ -360,7 +377,7 @@ FcFilePathInfo i; FcChar8 *slash; - slash = (FcChar8 *) strrchr ((const char *) path, '/'); + slash = FcStrLastSlash (path); if (slash) { i.dir = path; @@ -375,7 +392,7 @@ i.dir_len = 1; i.base = path; } - i.base_hash = FcCacheHash (i.base); + i.base_hash = FcCacheHash (i.base, -1); return i; } @@ -385,7 +402,7 @@ int len, FcBool create_missing) { - unsigned int hash = FcCacheHash (dir); + unsigned int hash = FcCacheHash (dir, len); FcGlobalCacheDir *d, **prev; for (prev = &cache->ents[hash % FC_GLOBAL_CACHE_DIR_HASH_SIZE]; @@ -426,13 +443,29 @@ FcGlobalCacheDirAdd (FcGlobalCache *cache, const FcChar8 *dir, time_t time, - FcBool replace) + FcBool replace, + FcBool create_missing) { FcGlobalCacheDir *d; FcFilePathInfo i; FcGlobalCacheSubdir *subdir; FcGlobalCacheDir *parent; + i = FcFilePathInfoGet (dir); + parent = FcGlobalCacheDirGet (cache, i.dir, i.dir_len, create_missing); + /* + * Tricky here -- directories containing fonts.cache-1 files + * need entries only when the parent doesn't have a cache file. + * That is, when the parent already exists in the cache, is + * referenced and has a "real" timestamp. The time of 0 is + * special and marks directories which got stuck in the + * global cache for this very reason. Yes, it could + * use a separate boolean field, and probably should. + */ + if (!parent || (!create_missing && + (!parent->info.referenced || + (parent->info.time == 0)))) + return 0; /* * Add this directory to the cache */ @@ -440,13 +473,9 @@ if (!d) return 0; d->info.time = time; - i = FcFilePathInfoGet (dir); /* * Add this directory to the subdirectory list of the parent */ - parent = FcGlobalCacheDirGet (cache, i.dir, i.dir_len, FcTrue); - if (!parent) - return 0; subdir = malloc (sizeof (FcGlobalCacheSubdir)); if (!subdir) return 0; @@ -483,6 +512,30 @@ free (d); } +/* + * If the parent is in the global cache and referenced, add + * an entry for 'dir' to the global cache. This is used + * for directories with fonts.cache files + */ + +void +FcGlobalCacheReferenceSubdir (FcGlobalCache *cache, + const FcChar8 *dir) +{ + FcGlobalCacheInfo *info; + info = FcGlobalCacheDirAdd (cache, dir, 0, FcFalse, FcFalse); + if (info && !info->referenced) + { + info->referenced = FcTrue; + cache->referenced++; + } +} + +/* + * Check to see if the global cache contains valid data for 'dir'. + * If so, scan the global cache for files and directories in 'dir'. + * else, return False. + */ FcBool FcGlobalCacheScanDir (FcFontSet *set, FcStrSet *dirs, @@ -496,6 +549,7 @@ int h; int dir_len; FcGlobalCacheSubdir *subdir; + FcBool any_in_cache = FcFalse; if (FcDebug() & FC_DBG_CACHE) printf ("FcGlobalCacheScanDir %s\n", dir); @@ -507,19 +561,27 @@ return FcFalse; } - if (!FcGlobalCacheCheckTime (&d->info)) + /* + * See if the timestamp recorded in the global cache + * matches the directory time, if not, return False + */ + if (!FcGlobalCacheCheckTime (d->info.file, &d->info)) { if (FcDebug () & FC_DBG_CACHE) printf ("\tdir cache entry time mismatch\n"); return FcFalse; } + /* + * Add files from 'dir' to the fontset + */ dir_len = strlen ((const char *) dir); for (h = 0; h < FC_GLOBAL_CACHE_FILE_HASH_SIZE; h++) for (f = d->ents[h]; f; f = f->next) { if (FcDebug() & FC_DBG_CACHEV) printf ("FcGlobalCacheScanDir add file %s\n", f->info.file); + any_in_cache = FcTrue; if (!FcCacheFontSetAdd (set, dirs, dir, dir_len, f->info.file, f->name)) { @@ -528,11 +590,14 @@ } FcGlobalCacheReferenced (cache, &f->info); } + /* + * Add directories in 'dir' to 'dirs' + */ for (subdir = d->subdirs; subdir; subdir = subdir->next) { - FcFilePathInfo info; + FcFilePathInfo info = FcFilePathInfoGet (subdir->ent->info.file); - info = FcFilePathInfoGet (subdir->ent->info.file); + any_in_cache = FcTrue; if (!FcCacheFontSetAdd (set, dirs, dir, dir_len, info.base, FC_FONT_FILE_DIR)) { @@ -544,7 +609,15 @@ FcGlobalCacheReferenced (cache, &d->info); - return FcTrue; + /* + * To recover from a bug in previous versions of fontconfig, + * return FcFalse if no entries in the cache were found + * for this directory. This will cause any empty directories + * to get rescanned every time fontconfig is initialized. This + * might get removed at some point when the older cache files are + * presumably fixed. + */ + return any_in_cache; } /* @@ -576,7 +649,7 @@ } } if (count) - *count = max; + *count = max + 1; return match; } @@ -713,7 +786,7 @@ if (FcDebug () & FC_DBG_CACHEV) printf ("FcGlobalCacheLoad \"%s\" \"%20.20s\"\n", file, name); if (!FcStrCmp (name, FC_FONT_FILE_DIR)) - info = FcGlobalCacheDirAdd (cache, file, time, FcFalse); + info = FcGlobalCacheDirAdd (cache, file, time, FcFalse, FcTrue); else info = FcGlobalCacheFileAdd (cache, file, id, time, name, FcFalse); if (!info) @@ -743,14 +816,17 @@ int id, const FcChar8 *name) { + const FcChar8 *match; struct stat statb; FcGlobalCacheInfo *info; + match = file; + if (stat ((char *) file, &statb) < 0) return FcFalse; if (S_ISDIR (statb.st_mode)) info = FcGlobalCacheDirAdd (cache, file, statb.st_mtime, - FcTrue); + FcTrue, FcTrue); else info = FcGlobalCacheFileAdd (cache, file, id, statb.st_mtime, name, FcTrue); @@ -780,9 +856,11 @@ if (cache->broken) return FcFalse; +#if defined (HAVE_GETUID) && defined (HAVE_GETEUID) /* Set-UID programs can't safely update the cache */ if (getuid () != geteuid ()) return FcFalse; +#endif atomic = FcAtomicCreate (cache_file); if (!atomic) @@ -973,7 +1051,7 @@ { const FcChar8 *cache_slash; - cache_slash = (const FcChar8 *) strrchr ((const char *) cache, '/'); + cache_slash = FcStrLastSlash (cache); if (cache_slash && !strncmp ((const char *) cache, (const char *) file, (cache_slash + 1) - cache)) return file + ((cache_slash + 1) - cache); --- xc/extras/fontconfig/src/fcstr.c 2003-11-21 06:56:14.000000000 +0100 +++ xc-fontconfig/extras/fontconfig/src/fcstr.c 2003-12-21 16:22:58.000000000 +0100 @@ -1,5 +1,7 @@ /* - * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * $RCSId: xc/lib/fontconfig/src/fcstr.c,v 1.10 2002/08/31 22:17:32 keithp Exp $ + * + * Copyright © 2000 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that @@ -71,11 +73,7 @@ { c1 = *s1++; c2 = *s2++; - if (!c1 || !c2) - break; - c1 = FcToLower (c1); - c2 = FcToLower (c2); - if (c1 != c2) + if (!c1 || (c1 != c2 && (c1 = FcToLower(c1)) != (c2 = FcToLower(c2)))) break; } return (int) c1 - (int) c2; @@ -94,11 +92,7 @@ do c2 = *s2++; while (c2 == ' '); - if (!c1 || !c2) - break; - c1 = FcToLower (c1); - c2 = FcToLower (c2); - if (c1 != c2) + if (!c1 || (c1 != c2 && (c1 = FcToLower(c1)) != (c2 = FcToLower(c2)))) break; } return (int) c1 - (int) c2; @@ -115,9 +109,7 @@ { c1 = *s1++; c2 = *s2++; - if (!c1 || !c2) - break; - if (c1 != c2) + if (!c1 || c1 != c2) break; } return (int) c1 - (int) c2; @@ -419,6 +411,12 @@ return FcTrue; } +FcBool +FcStrUsesHome (const FcChar8 *s) +{ + return *s == '~'; +} + FcChar8 * FcStrCopyFilename (const FcChar8 *s) { @@ -426,7 +424,7 @@ if (*s == '~') { - FcChar8 *home = (FcChar8 *) getenv ("HOME"); + FcChar8 *home = FcConfigHome (); int size; if (!home) return 0; @@ -451,12 +449,31 @@ } FcChar8 * +FcStrLastSlash (const FcChar8 *path) +{ + FcChar8 *slash; + + slash = (FcChar8 *) strrchr ((const char *) path, '/'); +#ifdef _WIN32 + { + FcChar8 *backslash; + + backslash = (FcChar8 *) strrchr ((const char *) path, '\\'); + if (!slash || (backslash && backslash > slash)) + slash = backslash; + } +#endif + + return slash; +} + +FcChar8 * FcStrDirname (const FcChar8 *file) { FcChar8 *slash; FcChar8 *dir; - slash = (FcChar8 *) strrchr ((char *) file, '/'); + slash = FcStrLastSlash (file); if (!slash) return FcStrCopy ((FcChar8 *) "."); dir = malloc ((slash - file) + 1); @@ -473,7 +490,7 @@ { FcChar8 *slash; - slash = (FcChar8 *) strrchr ((char *) file, '/'); + slash = FcStrLastSlash (file); if (!slash) return FcStrCopy (file); return FcStrCopy (slash + 1); --- xc/extras/fontconfig/fontconfig/fcfreetype.h 2003-11-21 06:56:14.000000000 +0100 +++ xc-fontconfig/extras/fontconfig/fontconfig/fcfreetype.h 2003-12-21 12:27:04.000000000 +0100 @@ -31,6 +31,9 @@ FcFreeTypeCharIndex (FT_Face face, FcChar32 ucs4); FcCharSet * +FcFreeTypeCharSetAndSpacing (FT_Face face, FcBlanks *blanks, int *spacing); + +FcCharSet * FcFreeTypeCharSet (FT_Face face, FcBlanks *blanks); FcResult diff -urN xc/extras/fontconfig/Imakefile xc-fontconfig/extras/fontconfig/Imakefile --- xc/extras/fontconfig/Imakefile 2003-09-25 13:01:13.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/Imakefile 2003-11-21 01:42:41.000000000 +0100 @@ -7,6 +7,9 @@ SUBDIRS=fontconfig $(LINTSUBDIRS) +SOFONTCONFIGREV=2.2 +#define SoRev SOFONTCONFIGREV + FONTCONFIG_REVISION=1 #ifndef FontconfigFontsConfDir diff -urN xc/extras/fontconfig/configure xc-fontconfig/extras/fontconfig/configure --- xc/extras/fontconfig/configure 2003-09-25 13:01:14.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/configure 2003-11-21 01:35:12.000000000 +0100 @@ -1248,7 +1248,7 @@ fi -PACKAGE_VERSION=1.0.1 +PACKAGE_VERSION=2.2.1 # Set major version PACKAGE_MAJOR=`echo $PACKAGE_VERSION | awk -F . '{ print $1 }'` diff -urN xc/extras/fontconfig/configure.in xc-fontconfig/extras/fontconfig/configure.in --- xc/extras/fontconfig/configure.in 2003-09-25 13:01:14.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/configure.in 2003-11-21 01:35:12.000000000 +0100 @@ -43,7 +43,7 @@ AC_PROG_LN_S AC_PATH_X -PACKAGE_VERSION=1.0.1 +PACKAGE_VERSION=2.2.1 # Set major version PACKAGE_MAJOR=`echo $PACKAGE_VERSION | awk -F . '{ print $1 }'` diff -urN xc/extras/fontconfig/fc-cache/fc-cache.c xc-fontconfig/extras/fontconfig/fc-cache/fc-cache.c --- xc/extras/fontconfig/fc-cache/fc-cache.c 2003-09-25 13:01:15.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/fc-cache/fc-cache.c 2003-11-21 01:35:12.000000000 +0100 @@ -1,7 +1,7 @@ /* - * $XFree86: xc/extras/fontconfig/fc-cache/fc-cache.c,v 1.2 2003/09/13 21:33:00 dawes Exp $ + * $RCSId: xc/lib/fontconfig/fc-cache/fc-cache.c,v 1.8tsi Exp $ * - * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc. + * Copyright © 2002 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that @@ -36,9 +36,6 @@ #define HAVE_GETOPT_LONG 1 #endif #define HAVE_GETOPT 1 -#if defined(ISC) || defined(Lynx) -#define HAVE_OPTARG_IN_UNISTD 0 -#endif #endif #ifndef HAVE_GETOPT @@ -47,9 +44,6 @@ #ifndef HAVE_GETOPT_LONG #define HAVE_GETOPT_LONG 0 #endif -#ifndef HAVE_OPTARG_IN_UNISTD -#define HAVE_OPTARG_IN_UNISTD HAVE_GETOPT -#endif #if HAVE_GETOPT_LONG #undef _GNU_SOURCE @@ -57,13 +51,14 @@ #include const struct option longopts[] = { {"force", 0, 0, 'f'}, + {"system-only", 0, 0, 's'}, {"version", 0, 0, 'V'}, {"verbose", 0, 0, 'v'}, {"help", 0, 0, '?'}, {NULL,0,0,0}, }; #else -#if HAVE_GETOPT && !HAVE_OPTARG_IN_UNISTD +#if HAVE_GETOPT extern char *optarg; extern int optind, opterr, optopt; #endif @@ -78,6 +73,7 @@ "(all directories in font configuration by default).\n"); fprintf (stderr, "\n"); fprintf (stderr, " -f, --force scan directories with apparently valid caches\n"); + fprintf (stderr, " -s, --system-only scan system-wide directories only\n"); fprintf (stderr, " -v, --verbose display status information while busy\n"); fprintf (stderr, " -V, --version display font config version and exit\n"); fprintf (stderr, " -?, --help display this help and exit\n"); @@ -135,21 +131,33 @@ continue; } - if (stat ((char *) dir, &statb) == -1) + if (access ((char *) dir, W_OK) < 0) { - if (errno == ENOENT || errno == ENOTDIR) - { + switch (errno) { + case ENOENT: + case ENOTDIR: if (verbose) - printf ("no such directory, skipping\n"); - } - else - { + printf ("skipping, no such directory\n"); + break; + case EACCES: + case EROFS: + if (verbose) + printf ("skipping, no write access\n"); + break; + default: fprintf (stderr, "\"%s\": ", dir); perror (""); ret++; } continue; } + if (stat ((char *) dir, &statb) == -1) + { + fprintf (stderr, "\"%s\": ", dir); + perror (""); + ret++; + continue; + } if (!S_ISDIR (statb.st_mode)) { fprintf (stderr, "\"%s\": not a directory, skipping\n", dir); @@ -200,6 +208,7 @@ FcStrList *list; FcBool verbose = FcFalse; FcBool force = FcFalse; + FcBool systemOnly = FcFalse; FcConfig *config; int i; int ret; @@ -216,6 +225,9 @@ case 'f': force = FcTrue; break; + case 's': + systemOnly = FcTrue; + break; case 'V': fprintf (stderr, "fontconfig version %d.%d.%d\n", FC_MAJOR, FC_MINOR, FC_REVISION); @@ -232,6 +244,8 @@ i = 1; #endif + if (systemOnly) + FcConfigEnableHome (FcFalse); config = FcInitLoadConfig (); if (!config) { diff -urN xc/extras/fontconfig/fc-lang/fc-lang.c xc-fontconfig/extras/fontconfig/fc-lang/fc-lang.c --- xc/extras/fontconfig/fc-lang/fc-lang.c 2003-06-04 18:29:38.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/fc-lang/fc-lang.c 2003-11-21 01:35:12.000000000 +0100 @@ -1,5 +1,7 @@ /* - * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc. + * $RCSId: xc/lib/fontconfig/fc-lang/fc-lang.c,v 1.3 2002/08/22 07:36:43 keithp Exp $ + * + * Copyright © 2002 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that @@ -19,22 +21,38 @@ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ -/* $XFree86: xc/extras/fontconfig/fc-lang/fc-lang.c,v 1.2 2003/06/04 16:29:38 dawes Exp $ */ #include "fcint.h" +#include "fccharset.c" +#include "fcstr.c" /* * fc-lang * * Read a set of language orthographies and build C declarations for * charsets which can then be used to identify which languages are - * supported by a given font. Note that it would be nice if - * this could be done while compiling the library, but this - * code uses a number of routines from the library. It's - * expediant to just ship the pre-built version along with the - * source orthographies. + * supported by a given font. Note that this uses some utilities + * from the fontconfig library, so the necessary file is simply + * included in this compilation. A couple of extra utility + * functions are also needed in slightly modified form */ +void +FcMemAlloc (int kind, int size) +{ +} + +void +FcMemFree (int kind, int size) +{ +} + +FcChar8 * +FcConfigHome (void) +{ + return getenv ("HOME"); +} + static void fatal (char *file, int lineno, char *msg) { @@ -146,8 +164,8 @@ while ((c = *name++)) { - if (isupper (c)) - c = tolower (c); + if (isupper ((int) (unsigned char) c)) + c = tolower ((int) (unsigned char) c); if (c == '_') c = '-'; if (c == ' ') @@ -189,6 +207,9 @@ char line[1024]; FcChar32 map[MAX_LANG_SET_MAP]; int num_lang_set_map; + int setRangeStart[26]; + int setRangeEnd[26]; + FcChar8 setRangeChar; while (*++argv) { @@ -282,6 +303,21 @@ } /* + * Find ranges for each letter for faster searching + */ + setRangeChar = 'a'; + for (i = 0; sets[i]; i++) + { + char c = names[i][0]; + + while (setRangeChar <= c && c <= 'z') + setRangeStart[setRangeChar++ - 'a'] = i; + } + for (setRangeChar = 'a'; setRangeChar < 'z'; setRangeChar++) + setRangeEnd[setRangeChar - 'a'] = setRangeStart[setRangeChar+1-'a'] - 1; + setRangeEnd[setRangeChar - 'a'] = i - 1; + + /* * Dump arrays */ for (i = 0; sets[i]; i++) @@ -325,13 +361,16 @@ printf ("};\n\n"); } printf ("#undef L\n\n"); + /* * Dump sets */ + printf ("static const FcLangCharSet fcLangCharSets[] = {\n"); for (i = 0; sets[i]; i++) { int j = duplicate[i]; + if (j < 0) j = i; printf (" { (FcChar8 *) \"%s\",\n" @@ -386,6 +425,19 @@ printf ("#define NUM_COUNTRY_SET %d\n", ncountry_ent); } + + /* + * Dump sets start/finish for the fastpath + */ + printf ("static const FcLangCharSetRange fcLangCharSetRanges[] = {\n"); + for (setRangeChar = 'a'; setRangeChar <= 'z' ; setRangeChar++) + { + printf (" { %d, %d }, /* %c */\n", + setRangeStart[setRangeChar - 'a'], + setRangeEnd[setRangeChar - 'a'], setRangeChar); + } + printf ("};\n\n"); + while (fgets (line, sizeof (line), stdin)) fputs (line, stdout); diff -urN xc/extras/fontconfig/fc-lang/fclang.h xc-fontconfig/extras/fontconfig/fc-lang/fclang.h --- xc/extras/fontconfig/fc-lang/fclang.h 2003-06-04 18:29:38.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/fc-lang/fclang.h 2003-11-21 01:35:12.000000000 +0100 @@ -1,5 +1,7 @@ /* - * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc. + * $RCSId: xc/lib/fontconfig/fc-lang/fclang.tmpl.h,v 1.1 2002/07/06 23:21:36 keithp Exp $ + * + * Copyright © 2002 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that @@ -19,11 +21,10 @@ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ -/* $XFree86: xc/extras/fontconfig/fc-lang/fclang.h,v 1.2 2003/06/04 16:29:38 dawes Exp $ */ -/* total size: 877 unique leaves: 599 */ +/* total size: 881 unique leaves: 602 */ -static const FcCharLeaf leaves[599] = { +static const FcCharLeaf leaves[602] = { { { /* 0 */ 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, 0x00000000, 0x00000000, 0x08104404, 0x08104404, @@ -41,11 +42,11 @@ 0x00000000, 0x00000000, 0x00000000, 0x00000000, } }, { { /* 4 */ - 0xffffff7f, 0xffffffff, 0x3d7f3d7f, 0xffffffff, - 0xffff3d7f, 0x7f3d7fff, 0xff7f7f3d, 0xffff7fff, + 0xff7fff7f, 0xff01ff7f, 0x00003d7f, 0x00ff00ff, + 0x00ff3d7f, 0x003d7fff, 0xff7f7f00, 0x00ff7f00, } }, { { /* 5 */ - 0x7f3d7fff, 0xffffffff, 0x07ffff7f, 0x00000000, + 0x003d7f00, 0xffff01ff, 0x007fff7f, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, } }, { { /* 6 */ @@ -213,8 +214,8 @@ 0x00000000, 0x00000000, 0x90400010, 0x10400010, } }, { { /* 47 */ - 0x00000000, 0x00000000, 0x00000000, 0x44300000, - 0xffffd7f0, 0xfffffffb, 0x00007fff, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xffffd740, 0xfffffffb, 0x00007fff, 0x00000000, } }, { { /* 48 */ 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, @@ -1313,1110 +1314,1122 @@ 0x00000000, 0x00000000, 0x00000000, 0x00000000, } }, { { /* 322 */ + 0xff7fff7f, 0xff01ff00, 0x3dff3d7f, 0xffff7fff, + 0xffff0000, 0x003d7fff, 0xff7f7f3d, 0x00ff7fff, + } }, + { { /* 323 */ + 0x003d7fff, 0xffffffff, 0x007fff00, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 324 */ + 0xff7fff7f, 0xff01ff00, 0x00003d7f, 0xffff7fff, + 0x00ff0000, 0x003d7f7f, 0xff7f7f00, 0x00ff7f00, + } }, + { { /* 325 */ 0xffff0002, 0xffffffff, 0x0002ffff, 0x00000000, 0x00c00000, 0x0000c00c, 0x03000000, 0x00000000, } }, - { { /* 323 */ + { { /* 326 */ 0x000fdfff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, } }, - { { /* 324 */ + { { /* 327 */ 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, 0x00000000, 0x00000000, 0x00100400, 0x00100400, } }, - { { /* 325 */ + { { /* 328 */ 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, 0x00000000, 0x00000000, 0x18404084, 0x18404084, } }, - { { /* 326 */ + { { /* 329 */ 0xc0000000, 0x00030000, 0xc0000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, } }, - { { /* 327 */ + { { /* 330 */ 0xffff0002, 0xffffffff, 0x0002ffff, 0x00000000, 0x00c00000, 0x0c00c00c, 0x03000000, 0x00000000, } }, - { { /* 328 */ + { { /* 331 */ 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, 0x00000000, 0x00000000, 0x00220008, 0x00220008, } }, - { { /* 329 */ + { { /* 332 */ 0x00000000, 0x00000300, 0x00000000, 0x00000300, 0x00010040, 0x00000000, 0x00000000, 0x00000000, } }, - { { /* 330 */ + { { /* 333 */ 0x00000000, 0x00000000, 0x08100000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, } }, - { { /* 331 */ + { { /* 334 */ 0x00000048, 0x00000200, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, } }, - { { /* 332 */ + { { /* 335 */ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x30000000, 0x00000000, 0x03000000, } }, - { { /* 333 */ + { { /* 336 */ 0xffff00d0, 0xffffffff, 0x00d0ffff, 0x00000000, 0x00030000, 0x00000000, 0x00000000, 0x00000000, } }, - { { /* 334 */ + { { /* 337 */ 0xffff0002, 0xffffe5ff, 0x0002e5ff, 0x00000000, 0x0c0c0000, 0x000c0000, 0x00000000, 0x00030000, } }, - { { /* 335 */ + { { /* 338 */ 0x000c0000, 0x30000000, 0x00000c30, 0x00030000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, } }, - { { /* 336 */ + { { /* 339 */ 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, 0x00000000, 0x00000000, 0x263c370f, 0x263c370f, } }, - { { /* 337 */ + { { /* 340 */ 0x0003000c, 0x00000300, 0x00000000, 0x00000300, 0x00000000, 0x00018003, 0x00000000, 0x00000000, } }, - { { /* 338 */ + { { /* 341 */ 0x0800024f, 0x00000008, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, } }, - { { /* 339 */ + { { /* 342 */ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0xffffffff, 0x03ffffff, } }, - { { /* 340 */ + { { /* 343 */ 0x00000000, 0x00000000, 0x077dfffe, 0x077dfffe, 0x00000000, 0x00000000, 0x10400010, 0x10400010, } }, - { { /* 341 */ + { { /* 344 */ 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, 0x00000000, 0x00000000, 0x10400010, 0x10400010, } }, - { { /* 342 */ + { { /* 345 */ 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, 0x00000000, 0x00000000, 0x081047a4, 0x081047a4, } }, - { { /* 343 */ + { { /* 346 */ 0x0c0030c0, 0x00000000, 0x0f30001e, 0x66000003, 0x00000000, 0x00000000, 0x00000000, 0x00000000, } }, - { { /* 344 */ + { { /* 347 */ 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, 0x00000000, 0x00000000, 0x000a0a09, 0x000a0a09, } }, - { { /* 345 */ + { { /* 348 */ 0x00000000, 0x00000000, 0x00000c00, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, } }, - { { /* 346 */ + { { /* 349 */ 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, 0x00000000, 0x00000000, 0x00400810, 0x00400810, } }, - { { /* 347 */ + { { /* 350 */ 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, 0x00000000, 0x00000000, 0x0e3c770f, 0x0e3c770f, } }, - { { /* 348 */ + { { /* 351 */ 0x0c000000, 0x00000300, 0x00000018, 0x00000300, 0x00000000, 0x00000000, 0x001fe000, 0x03000000, } }, - { { /* 349 */ + { { /* 352 */ 0x0000100f, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, } }, - { { /* 350 */ + { { /* 353 */ 0x00000000, 0xc0000000, 0x00000000, 0x0000000c, 0x00000000, 0x33000000, 0x00003000, 0x00000000, } }, - { { /* 351 */ + { { /* 354 */ 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000280, 0x00000000, } }, - { { /* 352 */ + { { /* 355 */ 0x7f7b7f8b, 0xef553db4, 0xf35dfba8, 0x400b0243, 0x8d3efb40, 0x8c2c7bf7, 0xe3fa6eff, 0xa8ed1d3a, } }, - { { /* 353 */ + { { /* 356 */ 0xcf83e602, 0x35558cf5, 0xffabe048, 0xd85992b9, 0x2892ab18, 0x8020d7e9, 0xf583c438, 0x450ae74a, } }, - { { /* 354 */ + { { /* 357 */ 0x9714b000, 0x54007762, 0x1420d188, 0xc8c01020, 0x00002121, 0x0c0413a8, 0x04408000, 0x082870c0, } }, - { { /* 355 */ + { { /* 358 */ 0x000408c0, 0x80000002, 0x14722b7b, 0x3bfb7924, 0x1ae43327, 0x38ef9835, 0x28029ad1, 0xbf69a813, } }, - { { /* 356 */ + { { /* 359 */ 0x2fc665cf, 0xafc96b11, 0x5053340f, 0xa00486a2, 0xe8090106, 0xc00e3f0f, 0x81450a88, 0xc6010010, } }, - { { /* 357 */ + { { /* 360 */ 0x26e1a161, 0xce00444b, 0xd4eec7aa, 0x85bbcadf, 0xa5203a74, 0x8840436c, 0x8bd23f06, 0x3befff79, } }, - { { /* 358 */ + { { /* 361 */ 0xe8eff75a, 0x5b36fbcb, 0x1bfd0d49, 0x39ee0154, 0x2e75d855, 0xa91abfd8, 0xf6bff3d7, 0xb40c67e0, } }, - { { /* 359 */ + { { /* 362 */ 0x081382c2, 0xd08bd49d, 0x1061065a, 0x59e074f2, 0xb3128f9f, 0x6aaa0080, 0xb05e3230, 0x60ac9d7a, } }, - { { /* 360 */ + { { /* 363 */ 0xc900d303, 0x8a563098, 0x13907000, 0x18421f14, 0x0008c060, 0x10808008, 0xec900400, 0xe6332817, } }, - { { /* 361 */ + { { /* 364 */ 0x90000758, 0x4e09f708, 0xfc83f485, 0x18c8af53, 0x080c187c, 0x01146adf, 0xa734c80c, 0x2710a011, } }, - { { /* 362 */ + { { /* 365 */ 0x422228c5, 0x00210413, 0x41123010, 0x40001820, 0xc60c022b, 0x10000300, 0x00220022, 0x02495810, } }, - { { /* 363 */ + { { /* 366 */ 0x9670a094, 0x1792eeb0, 0x05f2cb96, 0x23580025, 0x42cc25de, 0x4a04cf38, 0x359f0c40, 0x8a001128, } }, - { { /* 364 */ + { { /* 367 */ 0x910a13fa, 0x10560229, 0x04200641, 0x84f00484, 0x0c040000, 0x412c0400, 0x11541206, 0x00020a4b, } }, - { { /* 365 */ + { { /* 368 */ 0x00c00200, 0x00940000, 0xbfbb0001, 0x242b167c, 0x7fa89bbb, 0xe3790c7f, 0xe00d10f4, 0x9f014132, } }, - { { /* 366 */ + { { /* 369 */ 0x35728652, 0xff1210b4, 0x4223cf27, 0x8602c06b, 0x1fd33106, 0xa1aa3a0c, 0x02040812, 0x08012572, } }, - { { /* 367 */ + { { /* 370 */ 0x485040cc, 0x601062d0, 0x29001c80, 0x00109a00, 0x22000004, 0x00800000, 0x68002020, 0x609ecbe6, } }, - { { /* 368 */ + { { /* 371 */ 0x3f73916e, 0x398260c0, 0x48301034, 0xbd5c0006, 0xd6fb8cd1, 0x43e820e1, 0x084e0600, 0xc4d00500, } }, - { { /* 369 */ + { { /* 372 */ 0x89aa8d1f, 0x1602a6e1, 0x21ed0001, 0x1a8b3656, 0x13a51fb7, 0x30a06502, 0x23c7b278, 0xe9226c93, } }, - { { /* 370 */ + { { /* 373 */ 0x3a74e47f, 0x98208fe3, 0x2625280e, 0xbf49bf9c, 0xac543218, 0x1916b949, 0xb5220c60, 0x0659fbc1, } }, - { { /* 371 */ + { { /* 374 */ 0x8420e343, 0x800008d9, 0x20225500, 0x00a10184, 0x20104800, 0x40801380, 0x00160d04, 0x80200040, } }, - { { /* 372 */ + { { /* 375 */ 0x8de7fd40, 0xe0985436, 0x091e7b8b, 0xd249fec8, 0x8dee0611, 0xba221937, 0x9fdd77f4, 0xf0daf3ec, } }, - { { /* 373 */ + { { /* 376 */ 0xec424386, 0x26048d3f, 0xc021fa6c, 0x0cc2628e, 0x0145d785, 0x559977ad, 0x4045e250, 0xa154260b, } }, - { { /* 374 */ + { { /* 377 */ 0x58199827, 0xa4103443, 0x411405f2, 0x07002280, 0x426600b4, 0x15a17210, 0x41856025, 0x00000054, } }, - { { /* 375 */ + { { /* 378 */ 0x01040201, 0xcb70c820, 0x6a629320, 0x0095184c, 0x9a8b1880, 0x3201aab2, 0x00c4d87a, 0x04c3f3e5, } }, - { { /* 376 */ + { { /* 379 */ 0xa238d44d, 0x5072a1a1, 0x84fc980a, 0x44d1c152, 0x20c21094, 0x42104180, 0x3a000000, 0xd29d0240, } }, - { { /* 377 */ + { { /* 380 */ 0xa8b12f01, 0x2432bd40, 0xd04bd34d, 0xd0ada723, 0x75a10a92, 0x01e9adac, 0x771f801a, 0xa01b9225, } }, - { { /* 378 */ + { { /* 381 */ 0x20cadfa1, 0x738c0602, 0x003b577f, 0x00d00bff, 0x0088806a, 0x0029a1c4, 0x05242a05, 0x16234009, } }, - { { /* 379 */ + { { /* 382 */ 0x80056822, 0xa2112011, 0x64900004, 0x13824849, 0x193023d5, 0x08922980, 0x88115402, 0xa0042001, } }, - { { /* 380 */ + { { /* 383 */ 0x81800400, 0x60228502, 0x0b010090, 0x12020022, 0x00834011, 0x00001a01, 0x00000000, 0x00000000, } }, - { { /* 381 */ + { { /* 384 */ 0x00000000, 0x4684009f, 0x020012c8, 0x1a0004fc, 0x0c4c2ede, 0x80b80402, 0x0afca826, 0x22288c02, } }, - { { /* 382 */ + { { /* 385 */ 0x8f7ba0e0, 0x2135c7d6, 0xf8b106c7, 0x62550713, 0x8a19936e, 0xfb0e6efa, 0x48f91630, 0x7debcd2f, } }, - { { /* 383 */ + { { /* 386 */ 0x4e845892, 0x7a2e4ca0, 0x561eedea, 0x1190c649, 0xe83a5324, 0x8124cfdb, 0x634218f1, 0x1a8a5853, } }, - { { /* 384 */ + { { /* 387 */ 0x24d37420, 0x0514aa3b, 0x89586018, 0xc0004800, 0x91018268, 0x2cd684a4, 0xc4ba8886, 0x02100377, } }, - { { /* 385 */ + { { /* 388 */ 0x00388244, 0x404aae11, 0x510028c0, 0x15146044, 0x10007310, 0x02480082, 0x40060205, 0x0000c003, } }, - { { /* 386 */ + { { /* 389 */ 0x0c020000, 0x02200008, 0x40009000, 0xd161b800, 0x32744621, 0x3b8af800, 0x8b00050f, 0x2280bbd0, } }, - { { /* 387 */ + { { /* 390 */ 0x07690600, 0x00438040, 0x50005420, 0x250c41d0, 0x83108410, 0x02281101, 0x00304008, 0x020040a1, } }, - { { /* 388 */ + { { /* 391 */ 0x20000040, 0xabe31500, 0xaa443180, 0xc624c2c6, 0x8004ac13, 0x03d1b000, 0x4285611e, 0x1d9ff303, } }, - { { /* 389 */ + { { /* 392 */ 0x78e8440a, 0xc3925e26, 0x00852000, 0x4000b001, 0x88424a90, 0x0c8dca04, 0x4203a705, 0x000422a1, } }, - { { /* 390 */ + { { /* 393 */ 0x0c018668, 0x10795564, 0xdea00002, 0x40c12000, 0x5001488b, 0x04000380, 0x50040000, 0x80d0c05d, } }, - { { /* 391 */ + { { /* 394 */ 0x970aa010, 0x4dafbb20, 0x1e10d921, 0x83140460, 0xa6d68848, 0x733fd83b, 0x497427bc, 0x92130ddc, } }, - { { /* 392 */ + { { /* 395 */ 0x8ba1142b, 0xd1392e75, 0x50503009, 0x69008808, 0x024a49d4, 0x80164010, 0x89d7e564, 0x5316c020, } }, - { { /* 393 */ + { { /* 396 */ 0x86002b92, 0x15e0a345, 0x0c03008b, 0xe200196e, 0x80067031, 0xa82916a5, 0x18802000, 0xe1487aac, } }, - { { /* 394 */ + { { /* 397 */ 0xb5d63207, 0x5f9132e8, 0x20e550a1, 0x10807c00, 0x9d8a7280, 0x421f00aa, 0x02310e22, 0x04941100, } }, - { { /* 395 */ + { { /* 398 */ 0x40080022, 0x5c100010, 0xfcc80343, 0x0580a1a5, 0x04008433, 0x6e080080, 0x81262a4b, 0x2901aad8, } }, - { { /* 396 */ + { { /* 399 */ 0x4490684d, 0xba880009, 0x00820040, 0x87d10000, 0xb1e6215b, 0x80083161, 0xc2400800, 0xa600a069, } }, - { { /* 397 */ + { { /* 400 */ 0x4a328d58, 0x550a5d71, 0x2d579aa0, 0x4aa64005, 0x30b12021, 0x01123fc6, 0x260a10c2, 0x50824462, } }, - { { /* 398 */ + { { /* 401 */ 0x80409880, 0x810004c0, 0x00002003, 0x38180000, 0xf1a60200, 0x720e4434, 0x92e035a2, 0x09008101, } }, - { { /* 399 */ + { { /* 402 */ 0x00000400, 0x00008885, 0x00000000, 0x00804000, 0x00000000, 0x00004040, 0x00000000, 0x00000000, } }, - { { /* 400 */ + { { /* 403 */ 0x00000000, 0x08000000, 0x00000082, 0x00000000, 0x88000004, 0xe7efbfff, 0xffbfffff, 0xfdffefef, } }, - { { /* 401 */ + { { /* 404 */ 0xbffefbff, 0x057fffff, 0x85b30034, 0x42164706, 0xe4105402, 0xb3058092, 0x81305422, 0x180b4263, } }, - { { /* 402 */ + { { /* 405 */ 0x13f5387b, 0xa9ea07e5, 0x05143c4c, 0x80020600, 0xbd481ad9, 0xf496ee37, 0x7ec0705f, 0x355fbfb2, } }, - { { /* 403 */ + { { /* 406 */ 0x455fe644, 0x41469000, 0x063b1d40, 0xfe1362a1, 0x39028505, 0x0c080548, 0x0000144f, 0x58183488, } }, - { { /* 404 */ + { { /* 407 */ 0xd8153077, 0x4bfbbd0e, 0x85008a90, 0xe61dc100, 0xb386ed14, 0x639bff72, 0xd9befd92, 0x0a92887b, } }, - { { /* 405 */ + { { /* 408 */ 0x1cb2d3fe, 0x177ab980, 0xdc1782c9, 0x3980fffb, 0x590c4260, 0x37df0f01, 0xb15094a3, 0x23070623, } }, - { { /* 406 */ + { { /* 409 */ 0x3102f85a, 0x310201f0, 0x1e820040, 0x056a3a0a, 0x12805b84, 0xa7148002, 0xa04b2612, 0x90011069, } }, - { { /* 407 */ + { { /* 410 */ 0x848a1000, 0x3f801802, 0x42400708, 0x4e140110, 0x180080b0, 0x0281c510, 0x10298202, 0x88000210, } }, - { { /* 408 */ + { { /* 411 */ 0x00420020, 0x11000280, 0x4413e000, 0xfe025804, 0x30283c07, 0x04739798, 0xcb13ced1, 0x431f6210, } }, - { { /* 409 */ + { { /* 412 */ 0x55ac278d, 0xc892422e, 0x02885380, 0x78514039, 0x8088292c, 0x2428b900, 0x080e0c41, 0x42004421, } }, - { { /* 410 */ + { { /* 413 */ 0x08680408, 0x12040006, 0x02903031, 0xe0855b3e, 0x10442936, 0x10822814, 0x83344266, 0x531b013c, } }, - { { /* 411 */ + { { /* 414 */ 0x0e0d0404, 0x00510c22, 0xc0000012, 0x88000040, 0x0000004a, 0x00000000, 0x5447dff6, 0x00088868, } }, - { { /* 412 */ + { { /* 415 */ 0x00000081, 0x40000000, 0x00000100, 0x02000000, 0x00080600, 0x00000000, 0x00000000, 0x00000000, } }, - { { /* 413 */ + { { /* 416 */ 0x00000080, 0x00000040, 0x00000000, 0x00001040, 0x00000000, 0xf7fdefff, 0xfffeff7f, 0xfffffbff, } }, - { { /* 414 */ + { { /* 417 */ 0xbffffdff, 0x00ffffff, 0x042012c2, 0x07080c06, 0x01101624, 0x00000000, 0x00000000, 0x00000000, } }, - { { /* 415 */ + { { /* 418 */ 0xe0000000, 0xfffffffe, 0x7f79ffff, 0x00f928df, 0x80120c32, 0xd53a0008, 0xecc2d858, 0x2fa89d18, } }, - { { /* 416 */ + { { /* 419 */ 0xe0109620, 0x2622d60c, 0x02060f97, 0x9055b240, 0x501180a2, 0x04049800, 0x00004000, 0x00000000, } }, - { { /* 417 */ + { { /* 420 */ 0x00000000, 0x00000000, 0x00000000, 0xfffffbc0, 0xdffbeffe, 0x62430b08, 0xfb3b41b6, 0x23896f74, } }, - { { /* 418 */ + { { /* 421 */ 0xecd7ae7f, 0x5960e047, 0x098fa096, 0xa030612c, 0x2aaa090d, 0x4f7bd44e, 0x388bc4b2, 0x6110a9c6, } }, - { { /* 419 */ + { { /* 422 */ 0x42000014, 0x0202800c, 0x6485fe48, 0xe3f7d63e, 0x0c073aa0, 0x0430e40c, 0x1002f680, 0x00000000, } }, - { { /* 420 */ + { { /* 423 */ 0x00000000, 0x00000000, 0x00000000, 0x00100000, 0x00004000, 0x00004000, 0x00000100, 0x00000000, } }, - { { /* 421 */ + { { /* 424 */ 0x00000000, 0x40000000, 0x00000000, 0x00000400, 0x00008000, 0x00000000, 0x00400400, 0x00000000, } }, - { { /* 422 */ + { { /* 425 */ 0x00000000, 0x40000000, 0x00000000, 0x00000800, 0xfebdffe0, 0xffffffff, 0xfbe77f7f, 0xf7ffffbf, } }, - { { /* 423 */ + { { /* 426 */ 0xefffffff, 0xdff7ff7e, 0xfbdff6f7, 0x804fbffe, 0x00000000, 0x00000000, 0x00000000, 0x7fffef00, } }, - { { /* 424 */ + { { /* 427 */ 0xb6f7ff7f, 0xb87e4406, 0x88313bf5, 0x00f41796, 0x1391a960, 0x72490080, 0x0024f2f3, 0x42c88701, } }, - { { /* 425 */ + { { /* 428 */ 0x5048e3d3, 0x43052400, 0x4a4c0000, 0x10580227, 0x01162820, 0x0014a809, 0x00000000, 0x00683ec0, } }, - { { /* 426 */ + { { /* 429 */ 0x00000000, 0x00000000, 0x00000000, 0xffe00000, 0xfddbb7ff, 0x000000f7, 0xc72e4000, 0x00000180, } }, - { { /* 427 */ + { { /* 430 */ 0x00012000, 0x00004000, 0x00300000, 0xb4f7ffa8, 0x03ffadf3, 0x00000120, 0x00000000, 0x00000000, } }, - { { /* 428 */ + { { /* 431 */ 0x00000000, 0x00000000, 0x00000000, 0xfffbf000, 0xfdcf9df7, 0x15c301bf, 0x810a1827, 0x0a00a842, } }, - { { /* 429 */ + { { /* 432 */ 0x80088108, 0x18048008, 0x0012a3be, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, } }, - { { /* 430 */ + { { /* 433 */ 0x00000000, 0x00000000, 0x00000000, 0x90000000, 0xdc3769e6, 0x3dff6bff, 0xf3f9fcf8, 0x00000004, } }, - { { /* 431 */ + { { /* 434 */ 0x80000000, 0xe7eebf6f, 0x5da2dffe, 0xc00b3fd8, 0xa00c0984, 0x69100040, 0xb912e210, 0x5a0086a5, } }, - { { /* 432 */ + { { /* 435 */ 0x02896800, 0x6a809005, 0x00030010, 0x80000000, 0x8e001ff9, 0x00000001, 0x00000000, 0x00000000, } }, - { { /* 433 */ + { { /* 436 */ 0x14000010, 0xa0c09512, 0x0c000200, 0x01000400, 0x050002a3, 0x98800009, 0x00004000, 0x01004c00, } }, - { { /* 434 */ + { { /* 437 */ 0x04800008, 0x02840300, 0x00000824, 0x00040000, 0x00000400, 0x20010904, 0x00001100, 0x22050030, } }, - { { /* 435 */ + { { /* 438 */ 0x00000108, 0x08104000, 0x01400000, 0x00001040, 0x00010102, 0x10000040, 0x82012000, 0x10100002, } }, - { { /* 436 */ + { { /* 439 */ 0x00006002, 0x00000800, 0x00400000, 0x02100401, 0x14400144, 0x013c4980, 0x880e8288, 0x50102014, } }, - { { /* 437 */ + { { /* 440 */ 0x80000824, 0x101000c1, 0x02800000, 0x02080101, 0x04118000, 0x02200112, 0x00031020, 0x02000003, } }, - { { /* 438 */ + { { /* 441 */ 0x00000002, 0x090c1090, 0xa0004004, 0x60102290, 0x00080000, 0x00414f45, 0x07071026, 0x40c00001, } }, - { { /* 439 */ + { { /* 442 */ 0x04580000, 0x0014800a, 0x00002800, 0x00002600, 0x50988020, 0x02140018, 0x04013800, 0x00008008, } }, - { { /* 440 */ + { { /* 443 */ 0x41082004, 0x80000928, 0x20080280, 0x020e0a00, 0x00010040, 0x16110200, 0x41800002, 0x08231400, } }, - { { /* 441 */ + { { /* 444 */ 0x40020020, 0x0080202f, 0x2015a008, 0x1c000002, 0xc0040e00, 0x82028012, 0x00400000, 0x2002a004, } }, - { { /* 442 */ + { { /* 445 */ 0x20200001, 0xa0040000, 0x8890004c, 0xc4000080, 0x10012500, 0x48100482, 0x60800110, 0x40008040, } }, - { { /* 443 */ + { { /* 446 */ 0x00040008, 0x04000044, 0x90000091, 0x000c1200, 0x06040000, 0x08610480, 0x10010800, 0x080d0001, } }, - { { /* 444 */ + { { /* 447 */ 0x800204b4, 0x00140000, 0x00000000, 0x00200020, 0x84100200, 0x01811000, 0x02000210, 0x03018800, } }, - { { /* 445 */ + { { /* 448 */ 0x04042804, 0x20001c92, 0x02100020, 0x4202490a, 0x02420146, 0x00000803, 0x0008c008, 0x44050010, } }, - { { /* 446 */ + { { /* 449 */ 0x80222000, 0x00000800, 0x00008452, 0x10502140, 0xe0410005, 0x00000400, 0x00a00008, 0x80080000, } }, - { { /* 447 */ + { { /* 450 */ 0x50180020, 0x00000009, 0x40080600, 0x00000000, 0x56000020, 0x04000000, 0x00020006, 0x00208220, } }, - { { /* 448 */ + { { /* 451 */ 0x01210000, 0x40009000, 0x08c00140, 0x08110000, 0x00004820, 0x02400810, 0x08800002, 0x00200000, } }, - { { /* 449 */ + { { /* 452 */ 0x00040a00, 0x00004000, 0x40000104, 0x84000000, 0x02040048, 0x20000000, 0x00012000, 0x1b100000, } }, - { { /* 450 */ + { { /* 453 */ 0x00007000, 0x04000020, 0x10032000, 0x0804000a, 0x00000008, 0x04020090, 0x88000014, 0x00000000, } }, - { { /* 451 */ + { { /* 454 */ 0x00000000, 0x08020008, 0x00040400, 0x40a00000, 0x40000000, 0x00080090, 0x40800000, 0x20000388, } }, - { { /* 452 */ + { { /* 455 */ 0x02001080, 0x20010004, 0x12010004, 0x20008011, 0x13200082, 0x02800000, 0x04098001, 0x00000004, } }, - { { /* 453 */ + { { /* 456 */ 0x00000000, 0x02801000, 0x00001000, 0x00000100, 0x20010024, 0x00000050, 0x80200028, 0x00000020, } }, - { { /* 454 */ + { { /* 457 */ 0x01000000, 0x00a24000, 0x00000000, 0x82001010, 0x00000800, 0x02000000, 0x40020002, 0x59000044, } }, - { { /* 455 */ + { { /* 458 */ 0x00000080, 0x0d040000, 0x04000000, 0x10020000, 0x00022000, 0x00508000, 0x20080001, 0x000004a2, } }, - { { /* 456 */ + { { /* 459 */ 0xc0020400, 0x00310000, 0x80002000, 0x00002800, 0x00000b60, 0x40200000, 0x00120000, 0x80000009, } }, - { { /* 457 */ + { { /* 460 */ 0x41000000, 0x00010008, 0x00880910, 0x20080888, 0x04044020, 0x80482010, 0x00006000, 0x00020000, } }, - { { /* 458 */ + { { /* 461 */ 0x42405004, 0x00400020, 0x00000010, 0x00000886, 0x00008000, 0x80021011, 0x00c00000, 0x42000000, } }, - { { /* 459 */ + { { /* 462 */ 0x4801201f, 0x40c00004, 0x20600480, 0x00000020, 0x01000110, 0x22400040, 0x00000428, 0x00000000, } }, - { { /* 460 */ + { { /* 463 */ 0x0f00020f, 0x40401000, 0x00200048, 0x000c0092, 0x81000421, 0x00040004, 0x00620001, 0x06000202, } }, - { { /* 461 */ + { { /* 464 */ 0x14001808, 0x00083800, 0x008c1028, 0x04120028, 0x22008404, 0x40260880, 0x01100700, 0x00400000, } }, - { { /* 462 */ + { { /* 465 */ 0x20000020, 0x00200000, 0x00840000, 0x04108000, 0x00000002, 0x00000000, 0x10000002, 0x04000402, } }, - { { /* 463 */ + { { /* 466 */ 0x10000000, 0x26a20000, 0x05000200, 0x82204000, 0x80000000, 0x00048404, 0x80004800, 0x80000400, } }, - { { /* 464 */ + { { /* 467 */ 0x00000064, 0x00000050, 0x18804000, 0x00060000, 0x00408002, 0x02020030, 0x00000000, 0x40000000, } }, - { { /* 465 */ + { { /* 468 */ 0x01208414, 0x00000600, 0x02018000, 0x10400000, 0x04000840, 0x09200000, 0x2e000000, 0x04000304, } }, - { { /* 466 */ + { { /* 469 */ 0x00c01810, 0x20100010, 0x10400010, 0x02100000, 0xa0000402, 0x48200000, 0x06080000, 0x01400000, } }, - { { /* 467 */ + { { /* 470 */ 0x40000008, 0x00001000, 0x10112800, 0xc2a09080, 0x00008a02, 0x3a0000e9, 0x80611011, 0x40220000, } }, - { { /* 468 */ + { { /* 471 */ 0x20000020, 0x48381a00, 0x00028421, 0x54ea0800, 0x01425100, 0x0490200c, 0x20020000, 0x00600800, } }, - { { /* 469 */ + { { /* 472 */ 0x00e0c201, 0x00004810, 0x10a10001, 0x00000040, 0x80108084, 0x00042000, 0x00002000, 0x00000004, } }, - { { /* 470 */ + { { /* 473 */ 0x00010014, 0x03005d00, 0x00008102, 0x00120000, 0x51009000, 0x04000480, 0x0021c200, 0x0a888056, } }, - { { /* 471 */ + { { /* 474 */ 0xd2b60004, 0x13800000, 0x204803a8, 0x04501921, 0x0a003004, 0x02100010, 0x00091100, 0x01070080, } }, - { { /* 472 */ + { { /* 475 */ 0x42004020, 0x08300000, 0x002a2444, 0x04046081, 0x40046008, 0x00120000, 0x10000108, 0x00000000, } }, - { { /* 473 */ + { { /* 476 */ 0x00000084, 0x08001000, 0x0012e001, 0x045880c0, 0x00010000, 0x00800022, 0x02401000, 0x00000000, } }, - { { /* 474 */ + { { /* 477 */ 0x4000d000, 0x00000850, 0x01000009, 0x0d840000, 0x01080000, 0x42008000, 0x20000828, 0x40100040, } }, - { { /* 475 */ + { { /* 478 */ 0x51000100, 0x32000000, 0x001a0894, 0x04000040, 0x00002102, 0x03428000, 0x018c0080, 0x00234010, } }, - { { /* 476 */ + { { /* 479 */ 0x00000040, 0x185c4000, 0x03000000, 0x40020004, 0xa20200c9, 0x00000220, 0x00101050, 0x00120004, } }, - { { /* 477 */ + { { /* 480 */ 0x00000040, 0x44002400, 0x00000228, 0x20000020, 0x000a0008, 0x18010000, 0x3c08830c, 0x40000684, } }, - { { /* 478 */ + { { /* 481 */ 0x80101800, 0x02000280, 0x0020000c, 0x08009004, 0x00040000, 0x0004000c, 0x00018000, 0x14001000, } }, - { { /* 479 */ + { { /* 482 */ 0x08240000, 0x00200000, 0x20420014, 0x58112000, 0x10004048, 0x010050c0, 0x0408228c, 0x12282040, } }, - { { /* 480 */ + { { /* 483 */ 0x00000000, 0x00000020, 0x24002000, 0x00000000, 0x00800a00, 0x00080910, 0x1019a000, 0x60200030, } }, - { { /* 481 */ + { { /* 484 */ 0x00000080, 0x00000080, 0x08000000, 0x800050a0, 0x80044000, 0x04001010, 0x80008080, 0x00000000, } }, - { { /* 482 */ + { { /* 485 */ 0x00000040, 0x00800000, 0x000c4283, 0x01020000, 0x00888000, 0x00104008, 0x20000000, 0x04000080, } }, - { { /* 483 */ + { { /* 486 */ 0x20000104, 0x1802c021, 0x08100000, 0x0000004e, 0x80000001, 0x30c00080, 0x00000040, 0x00401200, } }, - { { /* 484 */ + { { /* 487 */ 0x04945288, 0x00940400, 0x06400104, 0x10002000, 0x00080010, 0x00400420, 0x00000102, 0x00408010, } }, - { { /* 485 */ + { { /* 488 */ 0x05000000, 0x40002240, 0x00100000, 0x0e400024, 0x00000080, 0x80000440, 0x01018410, 0xb1804004, } }, - { { /* 486 */ + { { /* 489 */ 0x25000800, 0x20000000, 0x00800000, 0x0000804c, 0x10020020, 0x42001000, 0x00082000, 0x00002000, } }, - { { /* 487 */ + { { /* 490 */ 0x11500020, 0x40004053, 0x11280500, 0x80060014, 0x004c0101, 0x60002008, 0x44000000, 0x01000036, } }, - { { /* 488 */ + { { /* 491 */ 0x00010028, 0x01180000, 0x84041804, 0x00098000, 0x00800000, 0x00000000, 0x00400002, 0x10004001, } }, - { { /* 489 */ + { { /* 492 */ 0x0051a004, 0x00008100, 0x00000024, 0x40041000, 0x00040000, 0x00042001, 0x00000000, 0x00008000, } }, - { { /* 490 */ + { { /* 493 */ 0x00000000, 0x00000000, 0x00000000, 0x20030000, 0x00001840, 0x00020220, 0x04404002, 0x00204000, } }, - { { /* 491 */ + { { /* 494 */ 0x01008010, 0x00002080, 0x40008064, 0x00004031, 0x10018090, 0x80304001, 0x000080a0, 0x80200040, } }, - { { /* 492 */ + { { /* 495 */ 0x00000001, 0x00000010, 0x00102088, 0x00800020, 0x00120681, 0x100002a0, 0x00000042, 0x00000080, } }, - { { /* 493 */ + { { /* 496 */ 0x10000000, 0x21000a00, 0x00000200, 0x40000080, 0x10110000, 0x00108200, 0x04000000, 0x00000400, } }, - { { /* 494 */ + { { /* 497 */ 0x80001000, 0x80002000, 0x40003008, 0x00000204, 0x0801000a, 0x40000001, 0x00000000, 0x00000004, } }, - { { /* 495 */ + { { /* 498 */ 0x00000000, 0x00000000, 0x00020000, 0x00000000, 0x88000000, 0x00002000, 0x08502000, 0x00840a00, } }, - { { /* 496 */ + { { /* 499 */ 0x31061808, 0x00000000, 0x00000000, 0x04000000, 0x00000004, 0x00000240, 0x00100009, 0x00000000, } }, - { { /* 497 */ + { { /* 500 */ 0x00004002, 0x04002500, 0x00008040, 0x40a20100, 0x00000001, 0x12412080, 0x04004008, 0x00042014, } }, - { { /* 498 */ + { { /* 501 */ 0x02000000, 0x00012000, 0x10000402, 0x000040c0, 0x00080000, 0x5fe800a1, 0x04019402, 0x02000000, } }, - { { /* 499 */ + { { /* 502 */ 0x00040100, 0x00880000, 0x00401000, 0x00001012, 0x00000000, 0x08004100, 0x00000010, 0x00000000, } }, - { { /* 500 */ + { { /* 503 */ 0x00000000, 0x00000000, 0x52020000, 0x10410080, 0x00005000, 0x08400200, 0x80400010, 0x44400020, } }, - { { /* 501 */ + { { /* 504 */ 0x00084100, 0x10200d02, 0xa1200012, 0x00804804, 0x00008212, 0xc6024000, 0x08100000, 0x205c1828, } }, - { { /* 502 */ + { { /* 505 */ 0x00000088, 0x00031000, 0x8000013f, 0x21184b44, 0x100100f2, 0xa9002001, 0x08080840, 0x001b0001, } }, - { { /* 503 */ + { { /* 506 */ 0x28800112, 0x400020f0, 0x0910200c, 0x0a0010a0, 0x80000020, 0x00000004, 0x1000000a, 0x00400000, } }, - { { /* 504 */ + { { /* 507 */ 0x00000000, 0x00002000, 0x00000080, 0x81000000, 0x02c00020, 0x000004c5, 0x00000000, 0x00100100, } }, - { { /* 505 */ + { { /* 508 */ 0x20000000, 0x01080000, 0x00400022, 0x08000200, 0x00408002, 0x20400028, 0x00000000, 0x00100000, } }, - { { /* 506 */ + { { /* 509 */ 0x08000008, 0x00420002, 0xa0a20003, 0x00022000, 0x88000280, 0x65160000, 0x00040105, 0x00244041, } }, - { { /* 507 */ + { { /* 510 */ 0x80300000, 0x00184008, 0x00000880, 0x00201140, 0x00000000, 0x02900000, 0x50004588, 0x00221043, } }, - { { /* 508 */ + { { /* 511 */ 0x12004000, 0x0b800000, 0x20002405, 0x0000000c, 0x08000000, 0x11000410, 0x04000030, 0x00200043, } }, - { { /* 509 */ + { { /* 512 */ 0x80011000, 0x18008042, 0x11000000, 0x00001008, 0x00008000, 0x24440000, 0x00800000, 0x80100005, } }, - { { /* 510 */ + { { /* 513 */ 0x00108204, 0x02102400, 0x00010001, 0x80000200, 0xa080e80a, 0x00010000, 0x20008000, 0x80122200, } }, - { { /* 511 */ + { { /* 514 */ 0x88211404, 0x04208041, 0x20088020, 0x18040000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, } }, - { { /* 512 */ + { { /* 515 */ 0x00401004, 0x02100002, 0x40014210, 0x50006000, 0x00080008, 0x20000820, 0x00100211, 0x10000000, } }, - { { /* 513 */ + { { /* 516 */ 0x91005400, 0x00000000, 0x00000000, 0x08000000, 0x41610032, 0xa0029d44, 0x000000d2, 0x41020004, } }, - { { /* 514 */ + { { /* 517 */ 0x00800104, 0x020000c0, 0x04090030, 0x80000204, 0x82004000, 0x00000020, 0x00000000, 0x00000000, } }, - { { /* 515 */ + { { /* 518 */ 0x00000080, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, } }, - { { /* 516 */ + { { /* 519 */ 0xc373ff8b, 0x1b0f6840, 0xf34ce9ac, 0xc0080200, 0xca3e795c, 0x06487976, 0xf7f02fdf, 0xa8ff033a, } }, - { { /* 517 */ + { { /* 520 */ 0x233fef37, 0xfd59b004, 0xfffff3ca, 0xfff9de9f, 0x7df7abff, 0x8eecc000, 0xffdbeebf, 0x45fad003, } }, - { { /* 518 */ + { { /* 521 */ 0xdffefae1, 0x10abbfef, 0xfcaaffeb, 0x24fdef3f, 0x7f7678ad, 0xedfff00c, 0x2cfacff6, 0xeb6bf7f9, } }, - { { /* 519 */ + { { /* 522 */ 0x95bf1ffd, 0xbfbf6677, 0xfeb43bfb, 0x11e27bae, 0x41bea681, 0x72c31435, 0x71917d70, 0x276b0003, } }, - { { /* 520 */ + { { /* 523 */ 0x70cf57cb, 0x0def4732, 0xfc747eda, 0xbdb4fe06, 0x8bca3f9f, 0x58007e49, 0xebec228f, 0xddbb8a5c, } }, - { { /* 521 */ + { { /* 524 */ 0xb6e7ef60, 0xf293a40f, 0x549e37bb, 0x9bafd04b, 0xf7d4c414, 0x0a1430b0, 0x88d02f08, 0x192fff7e, } }, - { { /* 522 */ + { { /* 525 */ 0xfb07ffda, 0x7beb7ff1, 0x0010c5ef, 0xfdff99ff, 0x056779d7, 0xfdcbffe7, 0x4040c3ff, 0xbd8e6ff7, } }, - { { /* 523 */ + { { /* 526 */ 0x0497dffa, 0x5bfff4c0, 0xd0e7ed7b, 0xf8e0047e, 0xb73eff9f, 0x882e7dfe, 0xbe7ffffd, 0xf6c483fe, } }, - { { /* 524 */ + { { /* 527 */ 0xb8fdf357, 0xef7dd680, 0x47885767, 0xc3dfff7d, 0x37a9f0ff, 0x70fc7de0, 0xec9a3f6f, 0x86814cb3, } }, - { { /* 525 */ + { { /* 528 */ 0xdd5c3f9e, 0x4819f70d, 0x0007fea3, 0x38ffaf56, 0xefb8980d, 0xb760403d, 0x9035d8ce, 0x3fff72bf, } }, - { { /* 526 */ + { { /* 529 */ 0x7a117ff7, 0xabfff7bb, 0x6fbeff00, 0xfe72a93c, 0xf11bcfef, 0xf40adb6b, 0xef7ec3e6, 0xf6109b9c, } }, - { { /* 527 */ + { { /* 530 */ 0x16f4f048, 0x5182feb5, 0x15bbc7b1, 0xfbdf6e87, 0x63cde43f, 0x7e7ec1ff, 0x7d5ffdeb, 0xfcfe777b, } }, - { { /* 528 */ + { { /* 531 */ 0xdbea960b, 0x53e86229, 0xfdef37df, 0xbd8136f5, 0xfcbddc18, 0xffffd2e4, 0xffe03fd7, 0xabf87f6f, } }, - { { /* 529 */ + { { /* 532 */ 0x6ed99bae, 0xf115f5fb, 0xbdfb79a9, 0xadaf5a3c, 0x1facdbba, 0x837971fc, 0xc35f7cf7, 0x0567dfff, } }, - { { /* 530 */ + { { /* 533 */ 0x8467ff9a, 0xdf8b1534, 0x3373f9f3, 0x5e1af7bd, 0xa03fbf40, 0x01ebffff, 0xcfdddfc0, 0xabd37500, } }, - { { /* 531 */ + { { /* 534 */ 0xeed6f8c3, 0xb7ff43fd, 0x42275eaf, 0xf6869bac, 0xf6bc27d7, 0x35b7f787, 0xe176aacd, 0xe29f49e7, } }, - { { /* 532 */ + { { /* 535 */ 0xaff2545c, 0x61d82b3f, 0xbbb8fc3b, 0x7b7dffcf, 0x1ce0bf95, 0x43ff7dfd, 0xfffe5ff6, 0xc4ced3ef, } }, - { { /* 533 */ + { { /* 536 */ 0xadbc8db6, 0x11eb63dc, 0x23d0df59, 0xf3dbbeb4, 0xdbc71fe7, 0xfae4ff63, 0x63f7b22b, 0xadbaed3b, } }, - { { /* 534 */ + { { /* 537 */ 0x7efffe01, 0x02bcfff7, 0xef3932ff, 0x8005fffc, 0xbcf577fb, 0xfff7010d, 0xbf3afffb, 0xdfff0057, } }, - { { /* 535 */ + { { /* 538 */ 0xbd7def7b, 0xc8d4db88, 0xed7cfff3, 0x56ff5dee, 0xac5f7e0d, 0xd57fff96, 0xc1403fee, 0xffe76ff9, } }, - { { /* 536 */ + { { /* 539 */ 0x8e77779b, 0xe45d6ebf, 0x5f1f6fcf, 0xfedfe07f, 0x01fed7db, 0xfb7bff00, 0x1fdfffd4, 0xfffff800, } }, - { { /* 537 */ + { { /* 540 */ 0x007bfb8f, 0x7f5cbf00, 0x07f3ffff, 0x3de7eba0, 0xfbd7f7bf, 0x6003ffbf, 0xbfedfffd, 0x027fefbb, } }, - { { /* 538 */ + { { /* 541 */ 0xddfdfe40, 0xe2f9fdff, 0xfb1f680b, 0xaffdfbe3, 0xf7ed9fa4, 0xf80f7a7d, 0x0fd5eebe, 0xfd9fbb5d, } }, - { { /* 539 */ + { { /* 542 */ 0x3bf9f2db, 0xebccfe7f, 0x73fa876a, 0x9ffc95fc, 0xfaf7109f, 0xbbcdddb7, 0xeccdf87e, 0x3c3ff366, } }, - { { /* 540 */ + { { /* 543 */ 0xb03ffffd, 0x067ee9f7, 0xfe0696ae, 0x5fd7d576, 0xa3f33fd1, 0x6fb7cf07, 0x7f449fd1, 0xd3dd7b59, } }, - { { /* 541 */ + { { /* 544 */ 0xa9bdaf3b, 0xff3a7dcf, 0xf6ebfbe0, 0xffffb401, 0xb7bf7afa, 0x0ffdc000, 0xff1fff7f, 0x95fffefc, } }, - { { /* 542 */ + { { /* 545 */ 0xb5dc0000, 0x3f3eef63, 0x001bfb7f, 0xfbf6e800, 0xb8df9eef, 0x003fff9f, 0xf5ff7bd0, 0x3fffdfdb, } }, - { { /* 543 */ + { { /* 546 */ 0x00bffdf0, 0xbbbd8420, 0xffdedf37, 0x0ff3ff6d, 0x5efb604c, 0xfafbfffb, 0x0219fe5e, 0xf9de79f4, } }, - { { /* 544 */ + { { /* 547 */ 0xebfaa7f7, 0xff3401eb, 0xef73ebd3, 0xc040afd7, 0xdcff72bb, 0x2fd8f17f, 0xfe0bb8ec, 0x1f0bdda3, } }, - { { /* 545 */ + { { /* 548 */ 0x47cf8f1d, 0xffdeb12b, 0xda737fee, 0xcbc424ff, 0xcbf2f75d, 0xb4edecfd, 0x4dddbff9, 0xfb8d99dd, } }, - { { /* 546 */ + { { /* 549 */ 0xaf7bbb7f, 0xc959ddfb, 0xfab5fc4f, 0x6d5fafe3, 0x3f7dffff, 0xffdb7800, 0x7effb6ff, 0x022ffbaf, } }, - { { /* 547 */ + { { /* 550 */ 0xefc7ff9b, 0xffffffa5, 0xc7000007, 0xfff1f7ff, 0x01bf7ffd, 0xfdbcdc00, 0xffffbff5, 0x3effff7f, } }, - { { /* 548 */ + { { /* 551 */ 0xbe000029, 0xff7ff9ff, 0xfd7e6efb, 0x039ecbff, 0xfbdde300, 0xf6dfccff, 0x117fffff, 0xfbf6f800, } }, - { { /* 549 */ + { { /* 552 */ 0xd73ce7ef, 0xdfeffeef, 0xedbfc00b, 0xfdcdfedf, 0x40fd7bf5, 0xb75fffff, 0xf930ffdf, 0xdc97fbdf, } }, - { { /* 550 */ + { { /* 553 */ 0xbff2fef3, 0xdfbf8fdf, 0xede6177f, 0x35530f7f, 0x877e447c, 0x45bbfa12, 0x779eede0, 0xbfd98017, } }, - { { /* 551 */ + { { /* 554 */ 0xde897e55, 0x0447c16f, 0xf75d7ade, 0x290557ff, 0xfe9586f7, 0xf32f97b3, 0x9f75cfff, 0xfb1771f7, } }, - { { /* 552 */ + { { /* 555 */ 0xee1934ee, 0xef6137cc, 0xef4c9fd6, 0xfbddd68f, 0x6def7b73, 0xa431d7fe, 0x97d75e7f, 0xffd80f5b, } }, - { { /* 553 */ + { { /* 556 */ 0x7bce9d83, 0xdcff22ec, 0xef87763d, 0xfdeddfe7, 0xa0fc4fff, 0xdbfc3b77, 0x7fdc3ded, 0xf5706fa9, } }, - { { /* 554 */ + { { /* 557 */ 0x2c403ffb, 0x847fff7f, 0xdeb7ec57, 0xf22fe69c, 0xd5b50feb, 0xede7afeb, 0xfff08c2f, 0xe8f0537f, } }, - { { /* 555 */ + { { /* 558 */ 0xb5ffb99d, 0xe78fff66, 0xbe10d981, 0xe3c19c7c, 0x27339cd1, 0xff6d0cbc, 0xefb7fcb7, 0xffffa0df, } }, - { { /* 556 */ + { { /* 559 */ 0xfe7bbf0b, 0x353fa3ff, 0x97cd13cc, 0xfb277637, 0x7e6ccfd6, 0xed31ec50, 0xfc1c677c, 0x5fbff6fa, } }, - { { /* 557 */ + { { /* 560 */ 0xae2f0fba, 0x7ffea3ad, 0xde74fcf0, 0xf200ffef, 0xfea2fbbf, 0xbcff3daf, 0x5fb9f694, 0x3f8ff3ad, } }, - { { /* 558 */ + { { /* 561 */ 0xa01ff26c, 0x01bfffef, 0x70057728, 0xda03ff35, 0xc7fad2f9, 0x5c1d3fbf, 0xec33ff3a, 0xfe9cb7af, } }, - { { /* 559 */ + { { /* 562 */ 0x7a9f5236, 0xe722bffa, 0xfcff9ff7, 0xb61d2fbb, 0x1dfded06, 0xefdf7dd7, 0xf166eb23, 0x0dc07ed9, } }, - { { /* 560 */ + { { /* 563 */ 0xdfbf3d3d, 0xba83c945, 0x9dd07dd1, 0xcf737b87, 0xc3f59ff3, 0xc5fedf0d, 0x83020cb3, 0xaec0e879, } }, - { { /* 561 */ + { { /* 564 */ 0x6f0fc773, 0x093ffd7d, 0x0157fff1, 0x01ff62fb, 0x3bf3fdb4, 0x43b2b013, 0xff305ed3, 0xeb9f0fff, } }, - { { /* 562 */ + { { /* 565 */ 0xf203feef, 0xfb893fef, 0x9e9937a9, 0xa72cdef9, 0xc1f63733, 0xfe3e812e, 0xf2f75d20, 0x69d7d585, } }, - { { /* 563 */ + { { /* 566 */ 0xffffffff, 0xff6fdb07, 0xd97fc4ff, 0xbe0fefce, 0xf05ef17b, 0xffb7f6cf, 0xef845ef7, 0x0edfd7cb, } }, - { { /* 564 */ + { { /* 567 */ 0xfcffff08, 0xffffee3f, 0xd7ff13ff, 0x7ffdaf0f, 0x1ffabdc7, 0x00000000, 0x00000000, 0x00000000, } }, - { { /* 565 */ + { { /* 568 */ 0x00000000, 0xe7400000, 0xf933bd38, 0xfeed7feb, 0x7c767fe8, 0xffefb3f7, 0xd8b7feaf, 0xfbbfff6f, } }, - { { /* 566 */ + { { /* 569 */ 0xdbf7f8fb, 0xe2f91752, 0x754785c8, 0xe3ef9090, 0x3f6d9ef4, 0x0536ee2e, 0x7ff3f7bc, 0x7f3fa07b, } }, - { { /* 567 */ + { { /* 570 */ 0xeb600567, 0x6601babe, 0x583ffcd8, 0x87dfcaf7, 0xffa0bfcd, 0xfebf5bcd, 0xefa7b6fd, 0xdf9c77ef, } }, - { { /* 568 */ + { { /* 571 */ 0xf8773fb7, 0xb7fc9d27, 0xdfefcab5, 0xf1b6fb5a, 0xef1fec39, 0x7ffbfbbf, 0xdafe000d, 0x4e7fbdfb, } }, - { { /* 569 */ + { { /* 572 */ 0x5ac033ff, 0x9ffebff5, 0x005fffbf, 0xfdf80000, 0x6ffdffca, 0xa001cffd, 0xfbf2dfff, 0xff7fdfbf, } }, - { { /* 570 */ + { { /* 573 */ 0x080ffeda, 0xbfffba08, 0xeed77afd, 0x67f9fbeb, 0xff93e044, 0x9f57df97, 0x08dffef7, 0xfedfdf80, } }, - { { /* 571 */ + { { /* 574 */ 0xf7feffc5, 0x6803fffb, 0x6bfa67fb, 0x5fe27fff, 0xff73ffff, 0xe7fb87df, 0xf7a7ebfd, 0xefc7bf7e, } }, - { { /* 572 */ + { { /* 575 */ 0xdf821ef3, 0xdf7e76ff, 0xda7d79c9, 0x1e9befbe, 0x77fb7ce0, 0xfffb87be, 0xffdb1bff, 0x4fe03f5c, } }, - { { /* 573 */ + { { /* 576 */ 0x5f0e7fff, 0xddbf77ff, 0xfffff04f, 0x0ff8ffff, 0xfddfa3be, 0xfffdfc1c, 0xfb9e1f7d, 0xdedcbdff, } }, - { { /* 574 */ + { { /* 577 */ 0xbafb3f6f, 0xfbefdf7f, 0x2eec7d1b, 0xf2f7af8e, 0xcfee7b0f, 0x77c61d96, 0xfff57e07, 0x7fdfd982, } }, - { { /* 575 */ + { { /* 578 */ 0xc7ff5ee6, 0x79effeee, 0xffcf9a56, 0xde5efe5f, 0xf9e8896e, 0xe6c4f45e, 0xbe7c0001, 0xdddf3b7f, } }, - { { /* 576 */ + { { /* 579 */ 0xe9efd59d, 0xde5334ac, 0x4bf7f573, 0x9eff7b4f, 0x476eb8fe, 0xff450dfb, 0xfbfeabfd, 0xddffe9d7, } }, - { { /* 577 */ + { { /* 580 */ 0x7fffedf7, 0x7eebddfd, 0xb7ffcfe7, 0xef91bde9, 0xd77c5d75, 0x00000000, 0x00000000, 0x00000000, } }, - { { /* 578 */ + { { /* 581 */ 0x00000000, 0xfa800000, 0xb4f1ffee, 0x2fefbf76, 0x77bfb677, 0xfffd9fbf, 0xf6ae95bf, 0x7f3b75ff, } }, - { { /* 579 */ + { { /* 582 */ 0x0af9a7f5, 0x00000000, 0x00000000, 0x2bddfbd0, 0x9a7ff633, 0xd6fcfdab, 0xbfebf9e6, 0xf41fdfdf, } }, - { { /* 580 */ + { { /* 583 */ 0xffffa6fd, 0xf37b4aff, 0xfef97fb7, 0x1d5cb6ff, 0xe5ff7ff6, 0x24041f7b, 0xf99ebe05, 0xdff2dbe3, } }, - { { /* 581 */ + { { /* 584 */ 0xfdff6fef, 0xcbfcd679, 0xefffebfd, 0x0000001f, 0x98000000, 0x8017e148, 0x00fe6a74, 0xfdf16d7f, } }, - { { /* 582 */ + { { /* 585 */ 0xfef3b87f, 0xf176e01f, 0x7b3fee96, 0xfffdeb8d, 0xcbb3adff, 0xe17f84ef, 0xbff04daa, 0xfe3fbf3f, } }, - { { /* 583 */ + { { /* 586 */ 0xffd7ebff, 0xcf7fffdf, 0x85edfffb, 0x07bcd73f, 0xfe0faeff, 0x76bffdaf, 0x37bbfaef, 0xa3ba7fdc, } }, - { { /* 584 */ + { { /* 587 */ 0x56f7b6ff, 0xe7df60f8, 0x4cdfff61, 0xff45b0fb, 0x3ffa7ded, 0x18fc1fff, 0xe3afffff, 0xdf83c7d3, } }, - { { /* 585 */ + { { /* 588 */ 0xef7dfb57, 0x1378efff, 0x5ff7fec0, 0x5ee334bb, 0xeff6f70d, 0x00bfd7fe, 0xf7f7f59d, 0xffe051de, } }, - { { /* 586 */ + { { /* 589 */ 0x037ffec9, 0xbfef5f01, 0x60a79ff1, 0xf1ffef1d, 0x0000000f, 0x00000000, 0x00000000, 0x00000000, } }, - { { /* 587 */ + { { /* 590 */ 0x00000000, 0x00000000, 0x00000000, 0x3c800000, 0xd91ffb4d, 0xfee37b3a, 0xdc7f3fe9, 0x0000003f, } }, - { { /* 588 */ + { { /* 591 */ 0x50000000, 0xbe07f51f, 0xf91bfc1d, 0x71ffbc1e, 0x5bbe6ff9, 0x9b1b5796, 0xfffc7fff, 0xafe7872e, } }, - { { /* 589 */ + { { /* 592 */ 0xf34febf5, 0xe725dffd, 0x5d440bdc, 0xfddd5747, 0x7790ed3f, 0x8ac87d7f, 0xf3f9fafa, 0xef4b202a, } }, - { { /* 590 */ + { { /* 593 */ 0x79cff5ff, 0x0ba5abd3, 0xfb8ff77a, 0x001f8ebd, 0x00000000, 0xfd4ef300, 0x88001a57, 0x7654aeac, } }, - { { /* 591 */ + { { /* 594 */ 0xcdff17ad, 0xf42fffb2, 0xdbff5baa, 0x00000002, 0x73c00000, 0x2e3ff9ea, 0xbbfffa8e, 0xffd376bc, } }, - { { /* 592 */ + { { /* 595 */ 0x7e72eefe, 0xe7f77ebd, 0xcefdf77f, 0x00000ff5, 0x00000000, 0xdb9ba900, 0x917fa4c7, 0x7ecef8ca, } }, - { { /* 593 */ + { { /* 596 */ 0xc7e77d7a, 0xdcaecbbd, 0x8f76fd7e, 0x7cf391d3, 0x4c2f01e5, 0xa360ed77, 0x5ef807db, 0x21811df7, } }, - { { /* 594 */ + { { /* 597 */ 0x309c6be0, 0xfade3b3a, 0xc3f57f53, 0x07ba61cd, 0x00000000, 0x00000000, 0x00000000, 0xbefe26e0, } }, - { { /* 595 */ + { { /* 598 */ 0xebb503f9, 0xe9cbe36d, 0xbfde9c2f, 0xabbf9f83, 0xffd51ff7, 0xdffeb7df, 0xffeffdae, 0xeffdfb7e, } }, - { { /* 596 */ + { { /* 599 */ 0x6ebfaaff, 0x00000000, 0x00000000, 0xb6200000, 0xbe9e7fcd, 0x58f162b3, 0xfd7bf10d, 0xbefde9f1, } }, - { { /* 597 */ + { { /* 600 */ 0x5f6dc6c3, 0x69ffff3d, 0xfbf4ffcf, 0x4ff7dcfb, 0x11372000, 0x00000015, 0x00000000, 0x00000000, } }, - { { /* 598 */ + { { /* 601 */ 0x00003000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, } }, @@ -3420,8 +3433,24 @@ 0x000e, }; +static const FcCharLeaf *leaves_ti_er[2] = { + L(322), L(323), +}; + +static const FcChar16 numbers_ti_er[2] = { + 0x0012, 0x0013, +}; + +static const FcCharLeaf *leaves_tig[2] = { + L(324), L(323), +}; + +static const FcChar16 numbers_tig[2] = { + 0x0012, 0x0013, +}; + static const FcCharLeaf *leaves_tk[1] = { - L(322), + L(325), }; static const FcChar16 numbers_tk[1] = { @@ -3429,7 +3458,7 @@ }; static const FcCharLeaf *leaves_tl[1] = { - L(323), + L(326), }; static const FcChar16 numbers_tl[1] = { @@ -3437,7 +3466,7 @@ }; static const FcCharLeaf *leaves_tn[1] = { - L(324), + L(327), }; static const FcChar16 numbers_tn[1] = { @@ -3445,7 +3474,7 @@ }; static const FcCharLeaf *leaves_tr[2] = { - L(325), L(326), + L(328), L(329), }; static const FcChar16 numbers_tr[2] = { @@ -3453,7 +3482,7 @@ }; static const FcCharLeaf *leaves_tt[1] = { - L(327), + L(330), }; static const FcChar16 numbers_tt[1] = { @@ -3461,7 +3490,7 @@ }; static const FcCharLeaf *leaves_tw[5] = { - L(328), L(329), L(330), L(331), L(332), + L(331), L(332), L(333), L(334), L(335), }; static const FcChar16 numbers_tw[5] = { @@ -3469,7 +3498,7 @@ }; static const FcCharLeaf *leaves_uk[1] = { - L(333), + L(336), }; static const FcChar16 numbers_uk[1] = { @@ -3477,7 +3506,7 @@ }; static const FcCharLeaf *leaves_uz[1] = { - L(334), + L(337), }; static const FcChar16 numbers_uz[1] = { @@ -3485,7 +3514,7 @@ }; static const FcCharLeaf *leaves_ven[2] = { - L( 15), L(335), + L( 15), L(338), }; static const FcChar16 numbers_ven[2] = { @@ -3493,7 +3522,7 @@ }; static const FcCharLeaf *leaves_vi[4] = { - L(336), L(337), L(338), L(339), + L(339), L(340), L(341), L(342), }; static const FcChar16 numbers_vi[4] = { @@ -3501,7 +3530,7 @@ }; static const FcCharLeaf *leaves_vo[1] = { - L(340), + L(343), }; static const FcChar16 numbers_vo[1] = { @@ -3509,7 +3538,7 @@ }; static const FcCharLeaf *leaves_vot[2] = { - L(341), L( 52), + L(344), L( 52), }; static const FcChar16 numbers_vot[2] = { @@ -3517,7 +3546,7 @@ }; static const FcCharLeaf *leaves_wa[1] = { - L(342), + L(345), }; static const FcChar16 numbers_wa[1] = { @@ -3525,7 +3554,7 @@ }; static const FcCharLeaf *leaves_wen[2] = { - L(294), L(343), + L(294), L(346), }; static const FcChar16 numbers_wen[2] = { @@ -3533,7 +3562,7 @@ }; static const FcCharLeaf *leaves_wo[2] = { - L(344), L(345), + L(347), L(348), }; static const FcChar16 numbers_wo[2] = { @@ -3541,7 +3570,7 @@ }; static const FcCharLeaf *leaves_yap[1] = { - L(346), + L(349), }; static const FcChar16 numbers_yap[1] = { @@ -3549,7 +3578,7 @@ }; static const FcCharLeaf *leaves_yo[4] = { - L(347), L(348), L(349), L(350), + L(350), L(351), L(352), L(353), }; static const FcChar16 numbers_yo[4] = { @@ -3557,17 +3586,17 @@ }; static const FcCharLeaf *leaves_zh_cn[82] = { - L(351), L(352), L(353), L(354), L(355), L(356), L(357), L(358), - L(359), L(360), L(361), L(362), L(363), L(364), L(365), L(366), - L(367), L(368), L(369), L(370), L(371), L(372), L(373), L(374), - L(375), L(376), L(377), L(378), L(379), L(380), L(381), L(382), - L(383), L(384), L(385), L(386), L(387), L(388), L(389), L(390), - L(391), L(392), L(393), L(394), L(395), L(396), L(397), L(398), - L(399), L(400), L(401), L(402), L(403), L(404), L(405), L(406), - L(407), L(408), L(409), L(410), L(411), L(412), L(413), L(414), - L(415), L(416), L(417), L(418), L(419), L(420), L(421), L(422), - L(423), L(424), L(425), L(426), L(427), L(428), L(429), L(430), - L(431), L(432), + L(354), L(355), L(356), L(357), L(358), L(359), L(360), L(361), + L(362), L(363), L(364), L(365), L(366), L(367), L(368), L(369), + L(370), L(371), L(372), L(373), L(374), L(375), L(376), L(377), + L(378), L(379), L(380), L(381), L(382), L(383), L(384), L(385), + L(386), L(387), L(388), L(389), L(390), L(391), L(392), L(393), + L(394), L(395), L(396), L(397), L(398), L(399), L(400), L(401), + L(402), L(403), L(404), L(405), L(406), L(407), L(408), L(409), + L(410), L(411), L(412), L(413), L(414), L(415), L(416), L(417), + L(418), L(419), L(420), L(421), L(422), L(423), L(424), L(425), + L(426), L(427), L(428), L(429), L(430), L(431), L(432), L(433), + L(434), L(435), }; static const FcChar16 numbers_zh_cn[82] = { @@ -3585,17 +3614,17 @@ }; static const FcCharLeaf *leaves_zh_hk[83] = { - L(433), L(434), L(435), L(436), L(437), L(438), L(439), L(440), - L(441), L(442), L(443), L(444), L(445), L(446), L(447), L(448), - L(449), L(450), L(451), L(452), L(453), L(454), L(455), L(456), - L(457), L(458), L(459), L(460), L(461), L(462), L(463), L(464), - L(465), L(466), L(467), L(468), L(469), L(470), L(471), L(472), - L(473), L(474), L(475), L(476), L(477), L(478), L(479), L(480), - L(481), L(482), L(483), L(484), L(485), L(486), L(487), L(488), - L(489), L(490), L(491), L(492), L(493), L(494), L(495), L(496), - L(497), L(498), L(499), L(500), L(501), L(502), L(503), L(504), - L(505), L(506), L(507), L(508), L(509), L(510), L(511), L(512), - L(513), L(514), L(515), + L(436), L(437), L(438), L(439), L(440), L(441), L(442), L(443), + L(444), L(445), L(446), L(447), L(448), L(449), L(450), L(451), + L(452), L(453), L(454), L(455), L(456), L(457), L(458), L(459), + L(460), L(461), L(462), L(463), L(464), L(465), L(466), L(467), + L(468), L(469), L(470), L(471), L(472), L(473), L(474), L(475), + L(476), L(477), L(478), L(479), L(480), L(481), L(482), L(483), + L(484), L(485), L(486), L(487), L(488), L(489), L(490), L(491), + L(492), L(493), L(494), L(495), L(496), L(497), L(498), L(499), + L(500), L(501), L(502), L(503), L(504), L(505), L(506), L(507), + L(508), L(509), L(510), L(511), L(512), L(513), L(514), L(515), + L(516), L(517), L(518), }; static const FcChar16 numbers_zh_hk[83] = { @@ -3613,17 +3642,17 @@ }; static const FcCharLeaf *leaves_zh_mo[83] = { - L(516), L(517), L(518), L(519), L(520), L(521), L(522), L(523), - L(524), L(525), L(526), L(527), L(528), L(529), L(530), L(531), - L(532), L(533), L(534), L(535), L(536), L(537), L(538), L(539), - L(540), L(541), L(542), L(543), L(544), L(545), L(546), L(547), - L(548), L(549), L(550), L(551), L(552), L(553), L(554), L(555), - L(556), L(557), L(558), L(559), L(560), L(561), L(562), L(563), - L(564), L(565), L(566), L(567), L(568), L(569), L(570), L(571), - L(572), L(573), L(574), L(575), L(576), L(577), L(578), L(579), - L(580), L(581), L(582), L(583), L(584), L(585), L(586), L(587), - L(588), L(589), L(590), L(591), L(592), L(593), L(594), L(595), - L(596), L(597), L(598), + L(519), L(520), L(521), L(522), L(523), L(524), L(525), L(526), + L(527), L(528), L(529), L(530), L(531), L(532), L(533), L(534), + L(535), L(536), L(537), L(538), L(539), L(540), L(541), L(542), + L(543), L(544), L(545), L(546), L(547), L(548), L(549), L(550), + L(551), L(552), L(553), L(554), L(555), L(556), L(557), L(558), + L(559), L(560), L(561), L(562), L(563), L(564), L(565), L(566), + L(567), L(568), L(569), L(570), L(571), L(572), L(573), L(574), + L(575), L(576), L(577), L(578), L(579), L(580), L(581), L(582), + L(583), L(584), L(585), L(586), L(587), L(588), L(589), L(590), + L(591), L(592), L(593), L(594), L(595), L(596), L(597), L(598), + L(599), L(600), L(601), }; static const FcChar16 numbers_zh_mo[83] = { @@ -3931,8 +3960,12 @@ { FC_REF_CONSTANT, 1, (FcCharLeaf **) leaves_tg, (FcChar16 *) numbers_tg } }, { (FcChar8 *) "th", { FC_REF_CONSTANT, 1, (FcCharLeaf **) leaves_th, (FcChar16 *) numbers_th } }, - { (FcChar8 *) "ti", - { FC_REF_CONSTANT, 2, (FcCharLeaf **) leaves_am, (FcChar16 *) numbers_am } }, + { (FcChar8 *) "ti-er", + { FC_REF_CONSTANT, 2, (FcCharLeaf **) leaves_ti_er, (FcChar16 *) numbers_ti_er } }, + { (FcChar8 *) "ti-et", + { FC_REF_CONSTANT, 2, (FcCharLeaf **) leaves_ti_er, (FcChar16 *) numbers_ti_er } }, + { (FcChar8 *) "tig", + { FC_REF_CONSTANT, 2, (FcCharLeaf **) leaves_tig, (FcChar16 *) numbers_tig } }, { (FcChar8 *) "tk", { FC_REF_CONSTANT, 1, (FcCharLeaf **) leaves_tk, (FcChar16 *) numbers_tk } }, { (FcChar8 *) "tl", @@ -3995,11 +4028,41 @@ { FC_REF_CONSTANT, 1, (FcCharLeaf **) leaves_fj, (FcChar16 *) numbers_fj } }, }; -#define NUM_LANG_CHAR_SET 175 +#define NUM_LANG_CHAR_SET 177 #define NUM_LANG_SET_MAP 6 static const FcChar32 fcLangCountrySets[][NUM_LANG_SET_MAP] = { - { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00003e00, }, /* zh */ + { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00030000, 0x00000000, }, /* ti */ + { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0000f800, }, /* zh */ +}; + +#define NUM_COUNTRY_SET 2 +static const FcLangCharSetRange fcLangCharSetRanges[] = { + { 0, 8 }, /* a */ + { 9, 21 }, /* b */ + { 22, 31 }, /* c */ + { 32, 34 }, /* d */ + { 35, 40 }, /* e */ + { 41, 48 }, /* f */ + { 49, 55 }, /* g */ + { 56, 63 }, /* h */ + { 64, 72 }, /* i */ + { 73, 73 }, /* j */ + { 74, 88 }, /* k */ + { 89, 94 }, /* l */ + { 95, 104 }, /* m */ + { 105, 110 }, /* n */ + { 111, 114 }, /* o */ + { 115, 116 }, /* p */ + { 117, 116 }, /* q */ + { 117, 119 }, /* r */ + { 120, 139 }, /* s */ + { 140, 155 }, /* t */ + { 156, 159 }, /* u */ + { 160, 163 }, /* v */ + { 164, 166 }, /* w */ + { 167, 167 }, /* x */ + { 168, 170 }, /* y */ + { 171, 176 }, /* z */ }; -#define NUM_COUNTRY_SET 1 diff -urN xc/extras/fontconfig/fc-lang/fclang.tmpl.h xc-fontconfig/extras/fontconfig/fc-lang/fclang.tmpl.h --- xc/extras/fontconfig/fc-lang/fclang.tmpl.h 2003-09-25 13:01:18.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/fc-lang/fclang.tmpl.h 2003-11-21 01:35:12.000000000 +0100 @@ -1,7 +1,7 @@ /* - * $XFree86: xc/extras/fontconfig/fc-lang/fclang.tmpl.h,v 1.1.1.1 2003/06/04 02:56:47 dawes Exp $ + * $RCSId: xc/lib/fontconfig/fc-lang/fclang.tmpl.h,v 1.1 2002/07/06 23:21:36 keithp Exp $ * - * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc. + * Copyright © 2002 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that diff -urN xc/extras/fontconfig/fc-list/fc-list.c xc-fontconfig/extras/fontconfig/fc-list/fc-list.c --- xc/extras/fontconfig/fc-list/fc-list.c 2003-09-25 13:01:21.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/fc-list/fc-list.c 2003-11-21 01:35:12.000000000 +0100 @@ -1,5 +1,7 @@ /* - * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc. + * $RCSId: xc/lib/fontconfig/fc-list/fc-list.c,v 1.5 2002/06/30 23:45:40 keithp Exp $ + * + * Copyright © 2002 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that @@ -19,7 +21,6 @@ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ -/* $XFree86: xc/extras/fontconfig/fc-list/fc-list.c,v 1.3 2003/09/13 21:33:00 dawes Exp $ */ #include #include @@ -32,9 +33,6 @@ #define HAVE_GETOPT_LONG 1 #endif #define HAVE_GETOPT 1 -#if defined(ISC) || defined(Lynx) -#define HAVE_OPTARG_IN_UNISTD 0 -#endif #endif #ifndef HAVE_GETOPT @@ -43,9 +41,6 @@ #ifndef HAVE_GETOPT_LONG #define HAVE_GETOPT_LONG 0 #endif -#ifndef HAVE_OPTARG_IN_UNISTD -#define HAVE_OPTARG_IN_UNISTD HAVE_GETOPT -#endif #if HAVE_GETOPT_LONG #undef _GNU_SOURCE @@ -58,7 +53,7 @@ {NULL,0,0,0}, }; #else -#if HAVE_GETOPT && !HAVE_OPTARG_IN_UNISTD +#if HAVE_GETOPT extern char *optarg; extern int optind, opterr, optopt; #endif @@ -66,25 +61,20 @@ static void usage (char *program) { -#if HAVE_GETOPT_LONG || HAVE_GETOPT - fprintf (stderr, - "usage: %s [-V?] [--version] [--help] [pattern] {element ...} \n", + fprintf (stderr, "usage: %s [-vV?] [--verbose] [--version] [--help] [pattern] {element ...} \n", program); fprintf (stderr, "List fonts matching [pattern]\n"); fprintf (stderr, "\n"); - fprintf (stderr, - " -V, --version display font config version and exit\n"); + fprintf (stderr, " -v, --verbose display status information while busy\n"); + fprintf (stderr, " -V, --version display font config version and exit\n"); fprintf (stderr, " -?, --help display this help and exit\n"); -#else - fprintf (stderr, "usage: %s [pattern] {element ...} \n", program); - fprintf (stderr, "List fonts matching [pattern]\n"); -#endif exit (1); } int main (int argc, char **argv) { + int verbose = 0; int i; FcObjectSet *os = 0; FcFontSet *fs; @@ -104,7 +94,7 @@ FC_MAJOR, FC_MINOR, FC_REVISION); exit (0); case 'v': - /* Ignore */ + verbose = 1; break; default: usage (argv[0]); diff -urN xc/extras/fontconfig/fontconfig/fcprivate.h xc-fontconfig/extras/fontconfig/fontconfig/fcprivate.h --- xc/extras/fontconfig/fontconfig/fcprivate.h 2003-06-04 18:29:39.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/fontconfig/fcprivate.h 2003-11-21 01:35:12.000000000 +0100 @@ -1,5 +1,7 @@ /* - * Copyright © 2001 Keith Packard, member of The XFree86 Project, Inc. + * $RCSId: xc/lib/fontconfig/fontconfig/fcprivate.h,v 1.5 2002/08/19 19:32:04 keithp Exp $ + * + * Copyright © 2001 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that @@ -19,7 +21,6 @@ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ -/* $XFree86: xc/extras/fontconfig/fontconfig/fcprivate.h,v 1.2 2003/06/04 16:29:39 dawes Exp $ */ #ifndef _FCPRIVATE_H_ #define _FCPRIVATE_H_ diff -urN xc/extras/fontconfig/fontconfig/fontconfig.h xc-fontconfig/extras/fontconfig/fontconfig/fontconfig.h --- xc/extras/fontconfig/fontconfig/fontconfig.h 2003-09-25 13:01:21.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/fontconfig/fontconfig.h 2003-11-21 01:35:12.000000000 +0100 @@ -1,7 +1,7 @@ /* - * $XFree86: xc/extras/fontconfig/fontconfig/fontconfig.h,v 1.1.1.1 2003/06/04 02:57:42 dawes Exp $ + * $RCSId: xc/lib/fontconfig/fontconfig/fontconfig.h,v 1.30 2002/09/26 00:17:27 keithp Exp $ * - * Copyright © 2001 Keith Packard, member of The XFree86 Project, Inc. + * Copyright © 2001 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that @@ -33,11 +33,14 @@ typedef int FcBool; /* - * Current Fontconfig version number + * Current Fontconfig version number. This same number + * must appear in the fontconfig configure.in file. Yes, + * it'a a pain to synchronize version numbers like this. */ -#define FC_MAJOR 1 -#define FC_MINOR 0 -#define FC_REVISION 2 + +#define FC_MAJOR 2 +#define FC_MINOR 2 +#define FC_REVISION 1 #define FC_VERSION ((FC_MAJOR * 10000) + (FC_MINOR * 100) + (FC_REVISION)) @@ -70,6 +73,7 @@ #define FC_VERTICAL_LAYOUT "verticallayout" /* Bool (false) */ #define FC_AUTOHINT "autohint" /* Bool (false) */ #define FC_GLOBAL_ADVANCE "globaladvance" /* Bool (true) */ +#define FC_WIDTH "width" /* Int */ #define FC_FILE "file" /* String */ #define FC_INDEX "index" /* Int */ #define FC_FT_FACE "ftface" /* FT_Face */ @@ -93,19 +97,38 @@ #define FC_CHAR_HEIGHT "charheight"/* Int */ #define FC_MATRIX "matrix" /* FcMatrix */ -#define FC_WEIGHT_LIGHT 0 -#define FC_WEIGHT_MEDIUM 100 -#define FC_WEIGHT_DEMIBOLD 180 -#define FC_WEIGHT_BOLD 200 -#define FC_WEIGHT_BLACK 210 - -#define FC_SLANT_ROMAN 0 -#define FC_SLANT_ITALIC 100 -#define FC_SLANT_OBLIQUE 110 - -#define FC_PROPORTIONAL 0 -#define FC_MONO 100 -#define FC_CHARCELL 110 +#define FC_WEIGHT_THIN 0 +#define FC_WEIGHT_EXTRALIGHT 40 +#define FC_WEIGHT_ULTRALIGHT FC_WEIGHT_EXTRALIGHT +#define FC_WEIGHT_LIGHT 50 +#define FC_WEIGHT_REGULAR 80 +#define FC_WEIGHT_NORMAL FC_WEIGHT_REGULAR +#define FC_WEIGHT_MEDIUM 100 +#define FC_WEIGHT_DEMIBOLD 180 +#define FC_WEIGHT_SEMIBOLD FC_WEIGHT_DEMIBOLD +#define FC_WEIGHT_BOLD 200 +#define FC_WEIGHT_EXTRABOLD 205 +#define FC_WEIGHT_ULTRABOLD FC_WEIGHT_EXTRABOLD +#define FC_WEIGHT_BLACK 210 +#define FC_WEIGHT_HEAVY FC_WEIGHT_BLACK + +#define FC_SLANT_ROMAN 0 +#define FC_SLANT_ITALIC 100 +#define FC_SLANT_OBLIQUE 110 + +#define FC_WIDTH_ULTRACONDENSED 50 +#define FC_WIDTH_EXTRACONDENSED 63 +#define FC_WIDTH_CONDENSED 75 +#define FC_WIDTH_SEMICONDENSED 87 +#define FC_WIDTH_NORMAL 100 +#define FC_WIDTH_SEMIEXPANDED 113 +#define FC_WIDTH_EXPANDED 125 +#define FC_WIDTH_EXTRAEXPANDED 150 +#define FC_WIDTH_ULTRAEXPANDED 200 + +#define FC_PROPORTIONAL 0 +#define FC_MONO 100 +#define FC_CHARCELL 110 /* sub-pixel order */ #define FC_RGBA_UNKNOWN 0 @@ -242,6 +265,12 @@ /* fccfg.c */ FcChar8 * +FcConfigHome (void); + +FcBool +FcConfigEnableHome (FcBool enable); + +FcChar8 * FcConfigFilename (const FcChar8 *url); FcConfig * @@ -451,6 +480,9 @@ FcLangSetCompare (const FcLangSet *lsa, const FcLangSet *lsb); FcBool +FcLangSetContains (const FcLangSet *lsa, const FcLangSet *lsb); + +FcBool FcLangSetEqual (const FcLangSet *lsa, const FcLangSet *lsb); FcChar32 @@ -694,7 +726,9 @@ FcChar8 * FcStrCopyFilename (const FcChar8 *s); -#define FcToLower(c) (('A' <= (c) && (c) <= 'Z') ? (c) - 'A' + 'a' : (c)) +#define FcIsUpper(c) (('A' <= (c) && (c) <= 'Z')) +#define FcIsLower(c) (('a' <= (c) && (c) <= 'z')) +#define FcToLower(c) (FcIsUpper(c) ? (c) - 'A' + 'a' : (c)) int FcStrCmpIgnoreCase (const FcChar8 *s1, const FcChar8 *s2); diff -urN xc/extras/fontconfig/local.def xc-fontconfig/extras/fontconfig/local.def --- xc/extras/fontconfig/local.def 2003-09-25 13:01:14.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/local.def 2003-11-21 01:35:12.000000000 +0100 @@ -41,7 +41,7 @@ #endif #if SharedLibFontconfig -#define SharedFontconfigRev 1.0 +#define SharedFontconfigRev 2.2 SharedLibReferences(FONTCONFIG,fontconfig,$(FONTCONFIGSRC),SOXLIBREV,SharedFontconfigRev) #else ProjectUnsharedLibReferences(FONTCONFIG,fontconfig,$(FONTCONFIGSRC),BuildLibDir) diff -urN xc/extras/fontconfig/src/Imakefile xc-fontconfig/extras/fontconfig/src/Imakefile --- xc/extras/fontconfig/src/Imakefile 2003-09-25 13:01:22.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/src/Imakefile 2003-11-21 01:35:12.000000000 +0100 @@ -16,7 +16,7 @@ #define DoProfileLib ProfileLibFontconfig #define HasSharedData YES #define LibName fontconfig -SOFONTCONFIGREV=1.0 +SOFONTCONFIGREV=2.2 #define SoRev SOFONTCONFIGREV #include diff -urN xc/extras/fontconfig/src/fcatomic.c xc-fontconfig/extras/fontconfig/src/fcatomic.c --- xc/extras/fontconfig/src/fcatomic.c 2003-09-25 13:01:22.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/src/fcatomic.c 2003-11-21 01:35:12.000000000 +0100 @@ -1,7 +1,7 @@ /* - * $XFree86: xc/extras/fontconfig/src/fcatomic.c,v 1.1.1.1 2003/06/04 02:57:42 dawes Exp $ + * $RCSId: xc/lib/fontconfig/src/fcatomic.c,v 1.2 2002/03/04 21:15:28 tsi Exp $ * - * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc. + * Copyright © 2002 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that @@ -30,7 +30,7 @@ * Uses only regular filesystem calls so it should * work even in the absense of functioning file locking * - * Four files: + * On Unix, four files are used: * file - the data file accessed by other apps. * new - a new version of the data file while it's being written * lck - the lock file @@ -41,6 +41,10 @@ * Attempt to link it to 'lck' * Unlink 'tmp' * If the link succeeded, the lock is held + * + * On Windows, where there are no links, no tmp file is used, and lck + * is a directory that's mkdir'ed. If the mkdir succeeds, the lock is + * held. */ #include "fcint.h" @@ -51,6 +55,10 @@ #include #include +#ifdef _WIN32 +#define mkdir(path,mode) _mkdir(path) +#endif + #define NEW_NAME ".NEW" #define LCK_NAME ".LCK" #define TMP_NAME ".TMP-XXXXXX" @@ -96,6 +104,7 @@ int ret; struct stat lck_stat; +#ifdef HAVE_LINK strcpy ((char *) atomic->tmp, (char *) atomic->file); strcat ((char *) atomic->tmp, TMP_NAME); fd = mkstemp ((char *) atomic->tmp); @@ -122,6 +131,9 @@ } ret = link ((char *) atomic->tmp, (char *) atomic->lck); (void) unlink ((char *) atomic->tmp); +#else + ret = mkdir ((char *) atomic->lck, 0600); +#endif if (ret < 0) { /* @@ -135,8 +147,13 @@ time_t now = time (0); if ((long int) (now - lck_stat.st_mtime) > 10 * 60) { +#ifdef HAVE_LINK if (unlink ((char *) atomic->lck) == 0) return FcAtomicLock (atomic); +#else + if (rmdir ((char *) atomic->lck) == 0) + return FcAtomicLock (atomic); +#endif } } return FcFalse; @@ -174,7 +191,11 @@ void FcAtomicUnlock (FcAtomic *atomic) { +#ifdef HAVE_LINK unlink ((char *) atomic->lck); +#else + rmdir ((char *) atomic->lck); +#endif } void diff -urN xc/extras/fontconfig/src/fcblanks.c xc-fontconfig/extras/fontconfig/src/fcblanks.c --- xc/extras/fontconfig/src/fcblanks.c 2003-09-25 13:01:22.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/src/fcblanks.c 2003-11-21 01:35:12.000000000 +0100 @@ -1,7 +1,7 @@ /* - * $XFree86: xc/extras/fontconfig/src/fcblanks.c,v 1.1.1.1 2003/06/04 02:57:42 dawes Exp $ + * $RCSId:$ * - * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc. + * Copyright © 2002 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that diff -urN xc/extras/fontconfig/src/fccfg.c xc-fontconfig/extras/fontconfig/src/fccfg.c --- xc/extras/fontconfig/src/fccfg.c 2003-06-04 18:29:39.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/src/fccfg.c 2003-11-21 01:35:12.000000000 +0100 @@ -1,5 +1,7 @@ /* - * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * $RCSId: xc/lib/fontconfig/src/fccfg.c,v 1.23 2002/08/31 22:17:32 keithp Exp $ + * + * Copyright © 2000 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that @@ -19,10 +21,15 @@ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ -/* $XFree86: xc/extras/fontconfig/src/fccfg.c,v 1.2 2003/06/04 16:29:39 dawes Exp $ */ #include "fcint.h" +#if defined (_WIN32) && defined (PIC) +#define STRICT +#include +#undef STRICT +#endif + FcConfig *_fcConfig; FcConfig * @@ -49,8 +56,9 @@ goto bail3; config->cache = 0; - if (!FcConfigSetCache (config, (FcChar8 *) ("~/" FC_USER_CACHE_FILE))) - goto bail4; + if (FcConfigHome()) + if (!FcConfigSetCache (config, (FcChar8 *) ("~/" FC_USER_CACHE_FILE))) + goto bail4; config->blanks = 0; @@ -132,8 +140,10 @@ while (s) { n = s->next; - FcTestDestroy (s->test); - FcEditDestroy (s->edit); + if (s->test) + FcTestDestroy (s->test); + if (s->edit) + FcEditDestroy (s->edit); s = n; } } @@ -482,11 +492,13 @@ } FcBool -FcConfigCompareValue (FcValue m, - FcOp op, - FcValue v) -{ - FcBool ret = FcFalse; +FcConfigCompareValue (const FcValue m_o, + FcOp op, + const FcValue v_o) +{ + FcValue m = m_o; + FcValue v = v_o; + FcBool ret = FcFalse; m = FcConfigPromote (m, v); v = FcConfigPromote (v, m); @@ -586,10 +598,10 @@ case FcTypeLangSet: switch (op) { case FcOpContains: - ret = FcLangSetCompare (v.u.l, m.u.l) != FcLangDifferentLang; + ret = FcLangSetContains (v.u.l, m.u.l); break; case FcOpNotContains: - ret = FcLangSetCompare (v.u.l, m.u.l) == FcLangDifferentLang; + ret = FcLangSetContains (v.u.l, m.u.l); break; case FcOpEqual: ret = FcLangSetEqual (v.u.l, m.u.l); @@ -636,6 +648,13 @@ } +#define _FcDoubleFloor(d) ((int) (d)) +#define _FcDoubleCeil(d) ((double) (int) (d) == (d) ? (int) (d) : (int) ((d) + 1)) +#define FcDoubleFloor(d) ((d) >= 0 ? _FcDoubleFloor(d) : -_FcDoubleCeil(-(d))) +#define FcDoubleCeil(d) ((d) >= 0 ? _FcDoubleCeil(d) : -_FcDoubleFloor(-(d))) +#define FcDoubleRound(d) FcDoubleFloor ((d) + 0.5) +#define FcDoubleTrunc(d) ((d) >= 0 ? _FcDoubleFloor (d) : -_FcDoubleFloor (-(d))) + static FcValue FcConfigEvaluate (FcPattern *p, FcExpr *e) { @@ -824,6 +843,70 @@ } FcValueDestroy (vl); break; + case FcOpFloor: + vl = FcConfigEvaluate (p, e->u.tree.left); + switch (vl.type) { + case FcTypeInteger: + v = vl; + break; + case FcTypeDouble: + v.type = FcTypeInteger; + v.u.i = FcDoubleFloor (vl.u.d); + break; + default: + v.type = FcTypeVoid; + break; + } + FcValueDestroy (vl); + break; + case FcOpCeil: + vl = FcConfigEvaluate (p, e->u.tree.left); + switch (vl.type) { + case FcTypeInteger: + v = vl; + break; + case FcTypeDouble: + v.type = FcTypeInteger; + v.u.i = FcDoubleCeil (vl.u.d); + break; + default: + v.type = FcTypeVoid; + break; + } + FcValueDestroy (vl); + break; + case FcOpRound: + vl = FcConfigEvaluate (p, e->u.tree.left); + switch (vl.type) { + case FcTypeInteger: + v = vl; + break; + case FcTypeDouble: + v.type = FcTypeInteger; + v.u.i = FcDoubleRound (vl.u.d); + break; + default: + v.type = FcTypeVoid; + break; + } + FcValueDestroy (vl); + break; + case FcOpTrunc: + vl = FcConfigEvaluate (p, e->u.tree.left); + switch (vl.type) { + case FcTypeInteger: + v = vl; + break; + case FcTypeDouble: + v.type = FcTypeInteger; + v.u.i = FcDoubleTrunc (vl.u.d); + break; + default: + v.type = FcTypeVoid; + break; + } + FcValueDestroy (vl); + break; default: v.type = FcTypeVoid; break; @@ -914,8 +997,16 @@ FcBool append, FcValueList *new) { - FcValueList **prev, *last; + FcValueList **prev, *last, *v; + FcValueBinding sameBinding; + if (position) + sameBinding = position->binding; + else + sameBinding = FcValueBindingWeak; + for (v = new; v; v = v->next) + if (v->binding == FcValueBindingSame) + v->binding = sameBinding; if (append) { if (position) @@ -1141,6 +1232,14 @@ !FcStrCmpIgnoreCase ((FcChar8 *) t->field, (FcChar8 *) e->field)) { + /* + * KLUDGE - the pattern may have been reallocated or + * things may have been inserted or deleted above + * this element by other edits. Go back and find + * the element again + */ + if (e != s->edit && st[i].elt) + st[i].elt = FcPatternFindElt (p, t->field); if (!st[i].elt) t = 0; break; @@ -1254,9 +1353,57 @@ } #ifndef FONTCONFIG_PATH -#define FONTCONFIG_PATH "/etc/fonts" +#define FONTCONFIG_PATH "/etc/fonts" #endif +#if defined (_WIN32) && defined (PIC) + +static FcChar8 fontconfig_path[1000] = ""; + +BOOL WINAPI +DllMain (HINSTANCE hinstDLL, + DWORD fdwReason, + LPVOID lpvReserved) +{ + FcChar8 *p; + + switch (fdwReason) { + case DLL_PROCESS_ATTACH: + if (!GetModuleFileName ((HMODULE) hinstDLL, fontconfig_path, + sizeof (fontconfig_path))) + break; + + /* If the fontconfig DLL is in a "bin" or "lib" subfolder, + * assume it's a Unix-style installation tree, and use + * "etc/fonts" in there as FONTCONFIG_PATH. Otherwise use the + * folder where the DLL is as FONTCONFIG_PATH. + */ + p = strrchr (fontconfig_path, '\\'); + if (p) + { + *p = '\0'; + p = strrchr (fontconfig_path, '\\'); + if (p && (FcStrCmpIgnoreCase (p + 1, "bin") == 0 || + FcStrCmpIgnoreCase (p + 1, "lib") == 0)) + *p = '\0'; + strcat (fontconfig_path, "\\etc\\fonts"); + } + else + fontconfig_path[0] = '\0'; + + break; + } + + return TRUE; +} + +#undef FONTCONFIG_PATH +#define FONTCONFIG_PATH fontconfig_path + +#else /* !(_WIN32 && PIC) */ + +#endif /* !(_WIN32 && PIC) */ + #ifndef FONTCONFIG_FILE #define FONTCONFIG_FILE "fonts.conf" #endif @@ -1273,9 +1420,16 @@ return 0; strcpy ((char *) path, (const char *) dir); - /* make sure there's a single separating / */ + /* make sure there's a single separator */ +#ifdef _WIN32 + if ((!path[0] || (path[strlen((char *) path)-1] != '/' && + path[strlen((char *) path)-1] != '\\')) && + (file[0] != '/' && file[0] != '\\')) + strcat ((char *) path, "\\"); +#else if ((!path[0] || path[strlen((char *) path)-1] != '/') && file[0] != '/') strcat ((char *) path, "/"); +#endif strcat ((char *) path, (char *) file); FcMemAlloc (FC_MEM_STRING, strlen ((char *) path) + 1); @@ -1302,11 +1456,7 @@ e = env; npath++; while (*e) -#ifndef __UNIXOS2__ - if (*e++ == ':') -#else - if (*e++ == ';') -#endif + if (*e++ == FC_SEARCH_PATH_SEPARATOR) npath++; } path = calloc (npath, sizeof (FcChar8 *)); @@ -1319,11 +1469,7 @@ e = env; while (*e) { -#ifndef __UNIXOS2__ - colon = (FcChar8 *) strchr ((char *) e, ':'); -#else - colon = (FcChar8 *) strchr ((char *) e, ';'); -#endif + colon = (FcChar8 *) strchr ((char *) e, FC_SEARCH_PATH_SEPARATOR); if (!colon) colon = e + strlen ((char *) e); path[i] = malloc (colon - e + 1); @@ -1339,11 +1485,7 @@ } } -#ifndef __UNIXOS2__ dir = (FcChar8 *) FONTCONFIG_PATH; -#else - dir = (FcChar8 *) __XOS2RedirRoot(FONTCONFIG_PATH); -#endif path[i] = malloc (strlen ((char *) dir) + 1); if (!path[i]) goto bail1; @@ -1368,6 +1510,33 @@ free (path); } +static FcBool _FcConfigHomeEnabled = FcTrue; + +FcChar8 * +FcConfigHome (void) +{ + if (_FcConfigHomeEnabled) + { + char *home = getenv ("HOME"); + +#ifdef _WIN32 + if (home == NULL) + home = getenv ("USERPROFILE"); +#endif + + return home; + } + return 0; +} + +FcBool +FcConfigEnableHome (FcBool enable) +{ + FcBool prev = _FcConfigHomeEnabled; + _FcConfigHomeEnabled = enable; + return prev; +} + FcChar8 * FcConfigFilename (const FcChar8 *url) { @@ -1380,14 +1549,26 @@ url = (FcChar8 *) FONTCONFIG_FILE; } file = 0; + +#ifdef _WIN32 + if (isalpha (*url) && + url[1] == ':' && + (url[2] == '/' || url[2] == '\\')) + goto absolute_path; +#endif + switch (*url) { case '~': - dir = (FcChar8 *) getenv ("HOME"); + dir = FcConfigHome (); if (dir) file = FcConfigFileExists (dir, url + 1); else file = 0; break; +#ifdef _WIN32 + case '\\': + absolute_path: +#endif case '/': file = FcConfigFileExists (0, url); break; diff -urN xc/extras/fontconfig/src/fccharset.c xc-fontconfig/extras/fontconfig/src/fccharset.c --- xc/extras/fontconfig/src/fccharset.c 2003-06-04 18:29:39.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/src/fccharset.c 2003-11-21 01:35:12.000000000 +0100 @@ -1,5 +1,7 @@ /* - * Copyright © 2001 Keith Packard, member of The XFree86 Project, Inc. + * $RCSId: xc/lib/fontconfig/src/fccharset.c,v 1.18 2002/08/22 07:36:44 keithp Exp $ + * + * Copyright © 2001 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that @@ -19,7 +21,6 @@ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ -/* $XFree86: xc/extras/fontconfig/src/fccharset.c,v 1.2 2003/06/04 16:29:39 dawes Exp $ */ #include #include "fcint.h" @@ -171,7 +172,7 @@ * if desired */ -static FcCharLeaf * +FcCharLeaf * FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4) { int pos; @@ -636,7 +637,7 @@ bi++; } } - return FcTrue; + return ai >= a->num; } /* @@ -1159,769 +1160,3 @@ return FcTrue; } - -/* - * Figure out whether the available freetype has FT_Get_Next_Char - */ - -#if FREETYPE_MAJOR > 2 -# define HAS_NEXT_CHAR -#else -# if FREETYPE_MAJOR == 2 -# if FREETYPE_MINOR > 0 -# define HAS_NEXT_CHAR -# else -# if FREETYPE_MINOR == 0 -# if FREETYPE_PATCH >= 9 -# define HAS_NEXT_CHAR -# endif -# endif -# endif -# endif -#endif - -/* - * For our purposes, this approximation is sufficient - */ -#ifndef HAS_NEXT_CHAR -#define FT_Get_First_Char(face, gi) ((*(gi) = 1), 1) -#define FT_Get_Next_Char(face, ucs4, gi) ((ucs4) >= 0xffffff ? \ - (*(gi) = 0), 0 : \ - (*(gi) = 1), (ucs4) + 1) -#warning "No FT_Get_Next_Char" -#endif - -typedef struct _FcCharEnt { - FcChar16 bmp; - unsigned char encode; -} FcCharEnt; - -struct _FcCharMap { - const FcCharEnt *ent; - int nent; -}; - -typedef struct _FcFontDecode { - FT_Encoding encoding; - const FcCharMap *map; - FcChar32 max; -} FcFontDecode; - -static const FcCharEnt AppleRomanEnt[] = { - { 0x0020, 0x20 }, /* SPACE */ - { 0x0021, 0x21 }, /* EXCLAMATION MARK */ - { 0x0022, 0x22 }, /* QUOTATION MARK */ - { 0x0023, 0x23 }, /* NUMBER SIGN */ - { 0x0024, 0x24 }, /* DOLLAR SIGN */ - { 0x0025, 0x25 }, /* PERCENT SIGN */ - { 0x0026, 0x26 }, /* AMPERSAND */ - { 0x0027, 0x27 }, /* APOSTROPHE */ - { 0x0028, 0x28 }, /* LEFT PARENTHESIS */ - { 0x0029, 0x29 }, /* RIGHT PARENTHESIS */ - { 0x002A, 0x2A }, /* ASTERISK */ - { 0x002B, 0x2B }, /* PLUS SIGN */ - { 0x002C, 0x2C }, /* COMMA */ - { 0x002D, 0x2D }, /* HYPHEN-MINUS */ - { 0x002E, 0x2E }, /* FULL STOP */ - { 0x002F, 0x2F }, /* SOLIDUS */ - { 0x0030, 0x30 }, /* DIGIT ZERO */ - { 0x0031, 0x31 }, /* DIGIT ONE */ - { 0x0032, 0x32 }, /* DIGIT TWO */ - { 0x0033, 0x33 }, /* DIGIT THREE */ - { 0x0034, 0x34 }, /* DIGIT FOUR */ - { 0x0035, 0x35 }, /* DIGIT FIVE */ - { 0x0036, 0x36 }, /* DIGIT SIX */ - { 0x0037, 0x37 }, /* DIGIT SEVEN */ - { 0x0038, 0x38 }, /* DIGIT EIGHT */ - { 0x0039, 0x39 }, /* DIGIT NINE */ - { 0x003A, 0x3A }, /* COLON */ - { 0x003B, 0x3B }, /* SEMICOLON */ - { 0x003C, 0x3C }, /* LESS-THAN SIGN */ - { 0x003D, 0x3D }, /* EQUALS SIGN */ - { 0x003E, 0x3E }, /* GREATER-THAN SIGN */ - { 0x003F, 0x3F }, /* QUESTION MARK */ - { 0x0040, 0x40 }, /* COMMERCIAL AT */ - { 0x0041, 0x41 }, /* LATIN CAPITAL LETTER A */ - { 0x0042, 0x42 }, /* LATIN CAPITAL LETTER B */ - { 0x0043, 0x43 }, /* LATIN CAPITAL LETTER C */ - { 0x0044, 0x44 }, /* LATIN CAPITAL LETTER D */ - { 0x0045, 0x45 }, /* LATIN CAPITAL LETTER E */ - { 0x0046, 0x46 }, /* LATIN CAPITAL LETTER F */ - { 0x0047, 0x47 }, /* LATIN CAPITAL LETTER G */ - { 0x0048, 0x48 }, /* LATIN CAPITAL LETTER H */ - { 0x0049, 0x49 }, /* LATIN CAPITAL LETTER I */ - { 0x004A, 0x4A }, /* LATIN CAPITAL LETTER J */ - { 0x004B, 0x4B }, /* LATIN CAPITAL LETTER K */ - { 0x004C, 0x4C }, /* LATIN CAPITAL LETTER L */ - { 0x004D, 0x4D }, /* LATIN CAPITAL LETTER M */ - { 0x004E, 0x4E }, /* LATIN CAPITAL LETTER N */ - { 0x004F, 0x4F }, /* LATIN CAPITAL LETTER O */ - { 0x0050, 0x50 }, /* LATIN CAPITAL LETTER P */ - { 0x0051, 0x51 }, /* LATIN CAPITAL LETTER Q */ - { 0x0052, 0x52 }, /* LATIN CAPITAL LETTER R */ - { 0x0053, 0x53 }, /* LATIN CAPITAL LETTER S */ - { 0x0054, 0x54 }, /* LATIN CAPITAL LETTER T */ - { 0x0055, 0x55 }, /* LATIN CAPITAL LETTER U */ - { 0x0056, 0x56 }, /* LATIN CAPITAL LETTER V */ - { 0x0057, 0x57 }, /* LATIN CAPITAL LETTER W */ - { 0x0058, 0x58 }, /* LATIN CAPITAL LETTER X */ - { 0x0059, 0x59 }, /* LATIN CAPITAL LETTER Y */ - { 0x005A, 0x5A }, /* LATIN CAPITAL LETTER Z */ - { 0x005B, 0x5B }, /* LEFT SQUARE BRACKET */ - { 0x005C, 0x5C }, /* REVERSE SOLIDUS */ - { 0x005D, 0x5D }, /* RIGHT SQUARE BRACKET */ - { 0x005E, 0x5E }, /* CIRCUMFLEX ACCENT */ - { 0x005F, 0x5F }, /* LOW LINE */ - { 0x0060, 0x60 }, /* GRAVE ACCENT */ - { 0x0061, 0x61 }, /* LATIN SMALL LETTER A */ - { 0x0062, 0x62 }, /* LATIN SMALL LETTER B */ - { 0x0063, 0x63 }, /* LATIN SMALL LETTER C */ - { 0x0064, 0x64 }, /* LATIN SMALL LETTER D */ - { 0x0065, 0x65 }, /* LATIN SMALL LETTER E */ - { 0x0066, 0x66 }, /* LATIN SMALL LETTER F */ - { 0x0067, 0x67 }, /* LATIN SMALL LETTER G */ - { 0x0068, 0x68 }, /* LATIN SMALL LETTER H */ - { 0x0069, 0x69 }, /* LATIN SMALL LETTER I */ - { 0x006A, 0x6A }, /* LATIN SMALL LETTER J */ - { 0x006B, 0x6B }, /* LATIN SMALL LETTER K */ - { 0x006C, 0x6C }, /* LATIN SMALL LETTER L */ - { 0x006D, 0x6D }, /* LATIN SMALL LETTER M */ - { 0x006E, 0x6E }, /* LATIN SMALL LETTER N */ - { 0x006F, 0x6F }, /* LATIN SMALL LETTER O */ - { 0x0070, 0x70 }, /* LATIN SMALL LETTER P */ - { 0x0071, 0x71 }, /* LATIN SMALL LETTER Q */ - { 0x0072, 0x72 }, /* LATIN SMALL LETTER R */ - { 0x0073, 0x73 }, /* LATIN SMALL LETTER S */ - { 0x0074, 0x74 }, /* LATIN SMALL LETTER T */ - { 0x0075, 0x75 }, /* LATIN SMALL LETTER U */ - { 0x0076, 0x76 }, /* LATIN SMALL LETTER V */ - { 0x0077, 0x77 }, /* LATIN SMALL LETTER W */ - { 0x0078, 0x78 }, /* LATIN SMALL LETTER X */ - { 0x0079, 0x79 }, /* LATIN SMALL LETTER Y */ - { 0x007A, 0x7A }, /* LATIN SMALL LETTER Z */ - { 0x007B, 0x7B }, /* LEFT CURLY BRACKET */ - { 0x007C, 0x7C }, /* VERTICAL LINE */ - { 0x007D, 0x7D }, /* RIGHT CURLY BRACKET */ - { 0x007E, 0x7E }, /* TILDE */ - { 0x00A0, 0xCA }, /* NO-BREAK SPACE */ - { 0x00A1, 0xC1 }, /* INVERTED EXCLAMATION MARK */ - { 0x00A2, 0xA2 }, /* CENT SIGN */ - { 0x00A3, 0xA3 }, /* POUND SIGN */ - { 0x00A5, 0xB4 }, /* YEN SIGN */ - { 0x00A7, 0xA4 }, /* SECTION SIGN */ - { 0x00A8, 0xAC }, /* DIAERESIS */ - { 0x00A9, 0xA9 }, /* COPYRIGHT SIGN */ - { 0x00AA, 0xBB }, /* FEMININE ORDINAL INDICATOR */ - { 0x00AB, 0xC7 }, /* LEFT-POINTING DOUBLE ANGLE QUOTATION MARK */ - { 0x00AC, 0xC2 }, /* NOT SIGN */ - { 0x00AE, 0xA8 }, /* REGISTERED SIGN */ - { 0x00AF, 0xF8 }, /* MACRON */ - { 0x00B0, 0xA1 }, /* DEGREE SIGN */ - { 0x00B1, 0xB1 }, /* PLUS-MINUS SIGN */ - { 0x00B4, 0xAB }, /* ACUTE ACCENT */ - { 0x00B5, 0xB5 }, /* MICRO SIGN */ - { 0x00B6, 0xA6 }, /* PILCROW SIGN */ - { 0x00B7, 0xE1 }, /* MIDDLE DOT */ - { 0x00B8, 0xFC }, /* CEDILLA */ - { 0x00BA, 0xBC }, /* MASCULINE ORDINAL INDICATOR */ - { 0x00BB, 0xC8 }, /* RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK */ - { 0x00BF, 0xC0 }, /* INVERTED QUESTION MARK */ - { 0x00C0, 0xCB }, /* LATIN CAPITAL LETTER A WITH GRAVE */ - { 0x00C1, 0xE7 }, /* LATIN CAPITAL LETTER A WITH ACUTE */ - { 0x00C2, 0xE5 }, /* LATIN CAPITAL LETTER A WITH CIRCUMFLEX */ - { 0x00C3, 0xCC }, /* LATIN CAPITAL LETTER A WITH TILDE */ - { 0x00C4, 0x80 }, /* LATIN CAPITAL LETTER A WITH DIAERESIS */ - { 0x00C5, 0x81 }, /* LATIN CAPITAL LETTER A WITH RING ABOVE */ - { 0x00C6, 0xAE }, /* LATIN CAPITAL LETTER AE */ - { 0x00C7, 0x82 }, /* LATIN CAPITAL LETTER C WITH CEDILLA */ - { 0x00C8, 0xE9 }, /* LATIN CAPITAL LETTER E WITH GRAVE */ - { 0x00C9, 0x83 }, /* LATIN CAPITAL LETTER E WITH ACUTE */ - { 0x00CA, 0xE6 }, /* LATIN CAPITAL LETTER E WITH CIRCUMFLEX */ - { 0x00CB, 0xE8 }, /* LATIN CAPITAL LETTER E WITH DIAERESIS */ - { 0x00CC, 0xED }, /* LATIN CAPITAL LETTER I WITH GRAVE */ - { 0x00CD, 0xEA }, /* LATIN CAPITAL LETTER I WITH ACUTE */ - { 0x00CE, 0xEB }, /* LATIN CAPITAL LETTER I WITH CIRCUMFLEX */ - { 0x00CF, 0xEC }, /* LATIN CAPITAL LETTER I WITH DIAERESIS */ - { 0x00D1, 0x84 }, /* LATIN CAPITAL LETTER N WITH TILDE */ - { 0x00D2, 0xF1 }, /* LATIN CAPITAL LETTER O WITH GRAVE */ - { 0x00D3, 0xEE }, /* LATIN CAPITAL LETTER O WITH ACUTE */ - { 0x00D4, 0xEF }, /* LATIN CAPITAL LETTER O WITH CIRCUMFLEX */ - { 0x00D5, 0xCD }, /* LATIN CAPITAL LETTER O WITH TILDE */ - { 0x00D6, 0x85 }, /* LATIN CAPITAL LETTER O WITH DIAERESIS */ - { 0x00D8, 0xAF }, /* LATIN CAPITAL LETTER O WITH STROKE */ - { 0x00D9, 0xF4 }, /* LATIN CAPITAL LETTER U WITH GRAVE */ - { 0x00DA, 0xF2 }, /* LATIN CAPITAL LETTER U WITH ACUTE */ - { 0x00DB, 0xF3 }, /* LATIN CAPITAL LETTER U WITH CIRCUMFLEX */ - { 0x00DC, 0x86 }, /* LATIN CAPITAL LETTER U WITH DIAERESIS */ - { 0x00DF, 0xA7 }, /* LATIN SMALL LETTER SHARP S */ - { 0x00E0, 0x88 }, /* LATIN SMALL LETTER A WITH GRAVE */ - { 0x00E1, 0x87 }, /* LATIN SMALL LETTER A WITH ACUTE */ - { 0x00E2, 0x89 }, /* LATIN SMALL LETTER A WITH CIRCUMFLEX */ - { 0x00E3, 0x8B }, /* LATIN SMALL LETTER A WITH TILDE */ - { 0x00E4, 0x8A }, /* LATIN SMALL LETTER A WITH DIAERESIS */ - { 0x00E5, 0x8C }, /* LATIN SMALL LETTER A WITH RING ABOVE */ - { 0x00E6, 0xBE }, /* LATIN SMALL LETTER AE */ - { 0x00E7, 0x8D }, /* LATIN SMALL LETTER C WITH CEDILLA */ - { 0x00E8, 0x8F }, /* LATIN SMALL LETTER E WITH GRAVE */ - { 0x00E9, 0x8E }, /* LATIN SMALL LETTER E WITH ACUTE */ - { 0x00EA, 0x90 }, /* LATIN SMALL LETTER E WITH CIRCUMFLEX */ - { 0x00EB, 0x91 }, /* LATIN SMALL LETTER E WITH DIAERESIS */ - { 0x00EC, 0x93 }, /* LATIN SMALL LETTER I WITH GRAVE */ - { 0x00ED, 0x92 }, /* LATIN SMALL LETTER I WITH ACUTE */ - { 0x00EE, 0x94 }, /* LATIN SMALL LETTER I WITH CIRCUMFLEX */ - { 0x00EF, 0x95 }, /* LATIN SMALL LETTER I WITH DIAERESIS */ - { 0x00F1, 0x96 }, /* LATIN SMALL LETTER N WITH TILDE */ - { 0x00F2, 0x98 }, /* LATIN SMALL LETTER O WITH GRAVE */ - { 0x00F3, 0x97 }, /* LATIN SMALL LETTER O WITH ACUTE */ - { 0x00F4, 0x99 }, /* LATIN SMALL LETTER O WITH CIRCUMFLEX */ - { 0x00F5, 0x9B }, /* LATIN SMALL LETTER O WITH TILDE */ - { 0x00F6, 0x9A }, /* LATIN SMALL LETTER O WITH DIAERESIS */ - { 0x00F7, 0xD6 }, /* DIVISION SIGN */ - { 0x00F8, 0xBF }, /* LATIN SMALL LETTER O WITH STROKE */ - { 0x00F9, 0x9D }, /* LATIN SMALL LETTER U WITH GRAVE */ - { 0x00FA, 0x9C }, /* LATIN SMALL LETTER U WITH ACUTE */ - { 0x00FB, 0x9E }, /* LATIN SMALL LETTER U WITH CIRCUMFLEX */ - { 0x00FC, 0x9F }, /* LATIN SMALL LETTER U WITH DIAERESIS */ - { 0x00FF, 0xD8 }, /* LATIN SMALL LETTER Y WITH DIAERESIS */ - { 0x0131, 0xF5 }, /* LATIN SMALL LETTER DOTLESS I */ - { 0x0152, 0xCE }, /* LATIN CAPITAL LIGATURE OE */ - { 0x0153, 0xCF }, /* LATIN SMALL LIGATURE OE */ - { 0x0178, 0xD9 }, /* LATIN CAPITAL LETTER Y WITH DIAERESIS */ - { 0x0192, 0xC4 }, /* LATIN SMALL LETTER F WITH HOOK */ - { 0x02C6, 0xF6 }, /* MODIFIER LETTER CIRCUMFLEX ACCENT */ - { 0x02C7, 0xFF }, /* CARON */ - { 0x02D8, 0xF9 }, /* BREVE */ - { 0x02D9, 0xFA }, /* DOT ABOVE */ - { 0x02DA, 0xFB }, /* RING ABOVE */ - { 0x02DB, 0xFE }, /* OGONEK */ - { 0x02DC, 0xF7 }, /* SMALL TILDE */ - { 0x02DD, 0xFD }, /* DOUBLE ACUTE ACCENT */ - { 0x03A9, 0xBD }, /* GREEK CAPITAL LETTER OMEGA */ - { 0x03C0, 0xB9 }, /* GREEK SMALL LETTER PI */ - { 0x2013, 0xD0 }, /* EN DASH */ - { 0x2014, 0xD1 }, /* EM DASH */ - { 0x2018, 0xD4 }, /* LEFT SINGLE QUOTATION MARK */ - { 0x2019, 0xD5 }, /* RIGHT SINGLE QUOTATION MARK */ - { 0x201A, 0xE2 }, /* SINGLE LOW-9 QUOTATION MARK */ - { 0x201C, 0xD2 }, /* LEFT DOUBLE QUOTATION MARK */ - { 0x201D, 0xD3 }, /* RIGHT DOUBLE QUOTATION MARK */ - { 0x201E, 0xE3 }, /* DOUBLE LOW-9 QUOTATION MARK */ - { 0x2020, 0xA0 }, /* DAGGER */ - { 0x2021, 0xE0 }, /* DOUBLE DAGGER */ - { 0x2022, 0xA5 }, /* BULLET */ - { 0x2026, 0xC9 }, /* HORIZONTAL ELLIPSIS */ - { 0x2030, 0xE4 }, /* PER MILLE SIGN */ - { 0x2039, 0xDC }, /* SINGLE LEFT-POINTING ANGLE QUOTATION MARK */ - { 0x203A, 0xDD }, /* SINGLE RIGHT-POINTING ANGLE QUOTATION MARK */ - { 0x2044, 0xDA }, /* FRACTION SLASH */ - { 0x20AC, 0xDB }, /* EURO SIGN */ - { 0x2122, 0xAA }, /* TRADE MARK SIGN */ - { 0x2202, 0xB6 }, /* PARTIAL DIFFERENTIAL */ - { 0x2206, 0xC6 }, /* INCREMENT */ - { 0x220F, 0xB8 }, /* N-ARY PRODUCT */ - { 0x2211, 0xB7 }, /* N-ARY SUMMATION */ - { 0x221A, 0xC3 }, /* SQUARE ROOT */ - { 0x221E, 0xB0 }, /* INFINITY */ - { 0x222B, 0xBA }, /* INTEGRAL */ - { 0x2248, 0xC5 }, /* ALMOST EQUAL TO */ - { 0x2260, 0xAD }, /* NOT EQUAL TO */ - { 0x2264, 0xB2 }, /* LESS-THAN OR EQUAL TO */ - { 0x2265, 0xB3 }, /* GREATER-THAN OR EQUAL TO */ - { 0x25CA, 0xD7 }, /* LOZENGE */ - { 0xF8FF, 0xF0 }, /* Apple logo */ - { 0xFB01, 0xDE }, /* LATIN SMALL LIGATURE FI */ - { 0xFB02, 0xDF }, /* LATIN SMALL LIGATURE FL */ -}; - -static const FcCharMap AppleRoman = { - AppleRomanEnt, - sizeof (AppleRomanEnt) / sizeof (AppleRomanEnt[0]) -}; - -static const FcCharEnt AdobeSymbolEnt[] = { - { 0x0020, 0x20 }, /* SPACE # space */ - { 0x0021, 0x21 }, /* EXCLAMATION MARK # exclam */ - { 0x0023, 0x23 }, /* NUMBER SIGN # numbersign */ - { 0x0025, 0x25 }, /* PERCENT SIGN # percent */ - { 0x0026, 0x26 }, /* AMPERSAND # ampersand */ - { 0x0028, 0x28 }, /* LEFT PARENTHESIS # parenleft */ - { 0x0029, 0x29 }, /* RIGHT PARENTHESIS # parenright */ - { 0x002B, 0x2B }, /* PLUS SIGN # plus */ - { 0x002C, 0x2C }, /* COMMA # comma */ - { 0x002E, 0x2E }, /* FULL STOP # period */ - { 0x002F, 0x2F }, /* SOLIDUS # slash */ - { 0x0030, 0x30 }, /* DIGIT ZERO # zero */ - { 0x0031, 0x31 }, /* DIGIT ONE # one */ - { 0x0032, 0x32 }, /* DIGIT TWO # two */ - { 0x0033, 0x33 }, /* DIGIT THREE # three */ - { 0x0034, 0x34 }, /* DIGIT FOUR # four */ - { 0x0035, 0x35 }, /* DIGIT FIVE # five */ - { 0x0036, 0x36 }, /* DIGIT SIX # six */ - { 0x0037, 0x37 }, /* DIGIT SEVEN # seven */ - { 0x0038, 0x38 }, /* DIGIT EIGHT # eight */ - { 0x0039, 0x39 }, /* DIGIT NINE # nine */ - { 0x003A, 0x3A }, /* COLON # colon */ - { 0x003B, 0x3B }, /* SEMICOLON # semicolon */ - { 0x003C, 0x3C }, /* LESS-THAN SIGN # less */ - { 0x003D, 0x3D }, /* EQUALS SIGN # equal */ - { 0x003E, 0x3E }, /* GREATER-THAN SIGN # greater */ - { 0x003F, 0x3F }, /* QUESTION MARK # question */ - { 0x005B, 0x5B }, /* LEFT SQUARE BRACKET # bracketleft */ - { 0x005D, 0x5D }, /* RIGHT SQUARE BRACKET # bracketright */ - { 0x005F, 0x5F }, /* LOW LINE # underscore */ - { 0x007B, 0x7B }, /* LEFT CURLY BRACKET # braceleft */ - { 0x007C, 0x7C }, /* VERTICAL LINE # bar */ - { 0x007D, 0x7D }, /* RIGHT CURLY BRACKET # braceright */ - { 0x00A0, 0x20 }, /* NO-BREAK SPACE # space */ - { 0x00AC, 0xD8 }, /* NOT SIGN # logicalnot */ - { 0x00B0, 0xB0 }, /* DEGREE SIGN # degree */ - { 0x00B1, 0xB1 }, /* PLUS-MINUS SIGN # plusminus */ - { 0x00B5, 0x6D }, /* MICRO SIGN # mu */ - { 0x00D7, 0xB4 }, /* MULTIPLICATION SIGN # multiply */ - { 0x00F7, 0xB8 }, /* DIVISION SIGN # divide */ - { 0x0192, 0xA6 }, /* LATIN SMALL LETTER F WITH HOOK # florin */ - { 0x0391, 0x41 }, /* GREEK CAPITAL LETTER ALPHA # Alpha */ - { 0x0392, 0x42 }, /* GREEK CAPITAL LETTER BETA # Beta */ - { 0x0393, 0x47 }, /* GREEK CAPITAL LETTER GAMMA # Gamma */ - { 0x0394, 0x44 }, /* GREEK CAPITAL LETTER DELTA # Delta */ - { 0x0395, 0x45 }, /* GREEK CAPITAL LETTER EPSILON # Epsilon */ - { 0x0396, 0x5A }, /* GREEK CAPITAL LETTER ZETA # Zeta */ - { 0x0397, 0x48 }, /* GREEK CAPITAL LETTER ETA # Eta */ - { 0x0398, 0x51 }, /* GREEK CAPITAL LETTER THETA # Theta */ - { 0x0399, 0x49 }, /* GREEK CAPITAL LETTER IOTA # Iota */ - { 0x039A, 0x4B }, /* GREEK CAPITAL LETTER KAPPA # Kappa */ - { 0x039B, 0x4C }, /* GREEK CAPITAL LETTER LAMDA # Lambda */ - { 0x039C, 0x4D }, /* GREEK CAPITAL LETTER MU # Mu */ - { 0x039D, 0x4E }, /* GREEK CAPITAL LETTER NU # Nu */ - { 0x039E, 0x58 }, /* GREEK CAPITAL LETTER XI # Xi */ - { 0x039F, 0x4F }, /* GREEK CAPITAL LETTER OMICRON # Omicron */ - { 0x03A0, 0x50 }, /* GREEK CAPITAL LETTER PI # Pi */ - { 0x03A1, 0x52 }, /* GREEK CAPITAL LETTER RHO # Rho */ - { 0x03A3, 0x53 }, /* GREEK CAPITAL LETTER SIGMA # Sigma */ - { 0x03A4, 0x54 }, /* GREEK CAPITAL LETTER TAU # Tau */ - { 0x03A5, 0x55 }, /* GREEK CAPITAL LETTER UPSILON # Upsilon */ - { 0x03A6, 0x46 }, /* GREEK CAPITAL LETTER PHI # Phi */ - { 0x03A7, 0x43 }, /* GREEK CAPITAL LETTER CHI # Chi */ - { 0x03A8, 0x59 }, /* GREEK CAPITAL LETTER PSI # Psi */ - { 0x03A9, 0x57 }, /* GREEK CAPITAL LETTER OMEGA # Omega */ - { 0x03B1, 0x61 }, /* GREEK SMALL LETTER ALPHA # alpha */ - { 0x03B2, 0x62 }, /* GREEK SMALL LETTER BETA # beta */ - { 0x03B3, 0x67 }, /* GREEK SMALL LETTER GAMMA # gamma */ - { 0x03B4, 0x64 }, /* GREEK SMALL LETTER DELTA # delta */ - { 0x03B5, 0x65 }, /* GREEK SMALL LETTER EPSILON # epsilon */ - { 0x03B6, 0x7A }, /* GREEK SMALL LETTER ZETA # zeta */ - { 0x03B7, 0x68 }, /* GREEK SMALL LETTER ETA # eta */ - { 0x03B8, 0x71 }, /* GREEK SMALL LETTER THETA # theta */ - { 0x03B9, 0x69 }, /* GREEK SMALL LETTER IOTA # iota */ - { 0x03BA, 0x6B }, /* GREEK SMALL LETTER KAPPA # kappa */ - { 0x03BB, 0x6C }, /* GREEK SMALL LETTER LAMDA # lambda */ - { 0x03BC, 0x6D }, /* GREEK SMALL LETTER MU # mu */ - { 0x03BD, 0x6E }, /* GREEK SMALL LETTER NU # nu */ - { 0x03BE, 0x78 }, /* GREEK SMALL LETTER XI # xi */ - { 0x03BF, 0x6F }, /* GREEK SMALL LETTER OMICRON # omicron */ - { 0x03C0, 0x70 }, /* GREEK SMALL LETTER PI # pi */ - { 0x03C1, 0x72 }, /* GREEK SMALL LETTER RHO # rho */ - { 0x03C2, 0x56 }, /* GREEK SMALL LETTER FINAL SIGMA # sigma1 */ - { 0x03C3, 0x73 }, /* GREEK SMALL LETTER SIGMA # sigma */ - { 0x03C4, 0x74 }, /* GREEK SMALL LETTER TAU # tau */ - { 0x03C5, 0x75 }, /* GREEK SMALL LETTER UPSILON # upsilon */ - { 0x03C6, 0x66 }, /* GREEK SMALL LETTER PHI # phi */ - { 0x03C7, 0x63 }, /* GREEK SMALL LETTER CHI # chi */ - { 0x03C8, 0x79 }, /* GREEK SMALL LETTER PSI # psi */ - { 0x03C9, 0x77 }, /* GREEK SMALL LETTER OMEGA # omega */ - { 0x03D1, 0x4A }, /* GREEK THETA SYMBOL # theta1 */ - { 0x03D2, 0xA1 }, /* GREEK UPSILON WITH HOOK SYMBOL # Upsilon1 */ - { 0x03D5, 0x6A }, /* GREEK PHI SYMBOL # phi1 */ - { 0x03D6, 0x76 }, /* GREEK PI SYMBOL # omega1 */ - { 0x2022, 0xB7 }, /* BULLET # bullet */ - { 0x2026, 0xBC }, /* HORIZONTAL ELLIPSIS # ellipsis */ - { 0x2032, 0xA2 }, /* PRIME # minute */ - { 0x2033, 0xB2 }, /* DOUBLE PRIME # second */ - { 0x2044, 0xA4 }, /* FRACTION SLASH # fraction */ - { 0x20AC, 0xA0 }, /* EURO SIGN # Euro */ - { 0x2111, 0xC1 }, /* BLACK-LETTER CAPITAL I # Ifraktur */ - { 0x2118, 0xC3 }, /* SCRIPT CAPITAL P # weierstrass */ - { 0x211C, 0xC2 }, /* BLACK-LETTER CAPITAL R # Rfraktur */ - { 0x2126, 0x57 }, /* OHM SIGN # Omega */ - { 0x2135, 0xC0 }, /* ALEF SYMBOL # aleph */ - { 0x2190, 0xAC }, /* LEFTWARDS ARROW # arrowleft */ - { 0x2191, 0xAD }, /* UPWARDS ARROW # arrowup */ - { 0x2192, 0xAE }, /* RIGHTWARDS ARROW # arrowright */ - { 0x2193, 0xAF }, /* DOWNWARDS ARROW # arrowdown */ - { 0x2194, 0xAB }, /* LEFT RIGHT ARROW # arrowboth */ - { 0x21B5, 0xBF }, /* DOWNWARDS ARROW WITH CORNER LEFTWARDS # carriagereturn */ - { 0x21D0, 0xDC }, /* LEFTWARDS DOUBLE ARROW # arrowdblleft */ - { 0x21D1, 0xDD }, /* UPWARDS DOUBLE ARROW # arrowdblup */ - { 0x21D2, 0xDE }, /* RIGHTWARDS DOUBLE ARROW # arrowdblright */ - { 0x21D3, 0xDF }, /* DOWNWARDS DOUBLE ARROW # arrowdbldown */ - { 0x21D4, 0xDB }, /* LEFT RIGHT DOUBLE ARROW # arrowdblboth */ - { 0x2200, 0x22 }, /* FOR ALL # universal */ - { 0x2202, 0xB6 }, /* PARTIAL DIFFERENTIAL # partialdiff */ - { 0x2203, 0x24 }, /* THERE EXISTS # existential */ - { 0x2205, 0xC6 }, /* EMPTY SET # emptyset */ - { 0x2206, 0x44 }, /* INCREMENT # Delta */ - { 0x2207, 0xD1 }, /* NABLA # gradient */ - { 0x2208, 0xCE }, /* ELEMENT OF # element */ - { 0x2209, 0xCF }, /* NOT AN ELEMENT OF # notelement */ - { 0x220B, 0x27 }, /* CONTAINS AS MEMBER # suchthat */ - { 0x220F, 0xD5 }, /* N-ARY PRODUCT # product */ - { 0x2211, 0xE5 }, /* N-ARY SUMMATION # summation */ - { 0x2212, 0x2D }, /* MINUS SIGN # minus */ - { 0x2215, 0xA4 }, /* DIVISION SLASH # fraction */ - { 0x2217, 0x2A }, /* ASTERISK OPERATOR # asteriskmath */ - { 0x221A, 0xD6 }, /* SQUARE ROOT # radical */ - { 0x221D, 0xB5 }, /* PROPORTIONAL TO # proportional */ - { 0x221E, 0xA5 }, /* INFINITY # infinity */ - { 0x2220, 0xD0 }, /* ANGLE # angle */ - { 0x2227, 0xD9 }, /* LOGICAL AND # logicaland */ - { 0x2228, 0xDA }, /* LOGICAL OR # logicalor */ - { 0x2229, 0xC7 }, /* INTERSECTION # intersection */ - { 0x222A, 0xC8 }, /* UNION # union */ - { 0x222B, 0xF2 }, /* INTEGRAL # integral */ - { 0x2234, 0x5C }, /* THEREFORE # therefore */ - { 0x223C, 0x7E }, /* TILDE OPERATOR # similar */ - { 0x2245, 0x40 }, /* APPROXIMATELY EQUAL TO # congruent */ - { 0x2248, 0xBB }, /* ALMOST EQUAL TO # approxequal */ - { 0x2260, 0xB9 }, /* NOT EQUAL TO # notequal */ - { 0x2261, 0xBA }, /* IDENTICAL TO # equivalence */ - { 0x2264, 0xA3 }, /* LESS-THAN OR EQUAL TO # lessequal */ - { 0x2265, 0xB3 }, /* GREATER-THAN OR EQUAL TO # greaterequal */ - { 0x2282, 0xCC }, /* SUBSET OF # propersubset */ - { 0x2283, 0xC9 }, /* SUPERSET OF # propersuperset */ - { 0x2284, 0xCB }, /* NOT A SUBSET OF # notsubset */ - { 0x2286, 0xCD }, /* SUBSET OF OR EQUAL TO # reflexsubset */ - { 0x2287, 0xCA }, /* SUPERSET OF OR EQUAL TO # reflexsuperset */ - { 0x2295, 0xC5 }, /* CIRCLED PLUS # circleplus */ - { 0x2297, 0xC4 }, /* CIRCLED TIMES # circlemultiply */ - { 0x22A5, 0x5E }, /* UP TACK # perpendicular */ - { 0x22C5, 0xD7 }, /* DOT OPERATOR # dotmath */ - { 0x2320, 0xF3 }, /* TOP HALF INTEGRAL # integraltp */ - { 0x2321, 0xF5 }, /* BOTTOM HALF INTEGRAL # integralbt */ - { 0x2329, 0xE1 }, /* LEFT-POINTING ANGLE BRACKET # angleleft */ - { 0x232A, 0xF1 }, /* RIGHT-POINTING ANGLE BRACKET # angleright */ - { 0x25CA, 0xE0 }, /* LOZENGE # lozenge */ - { 0x2660, 0xAA }, /* BLACK SPADE SUIT # spade */ - { 0x2663, 0xA7 }, /* BLACK CLUB SUIT # club */ - { 0x2665, 0xA9 }, /* BLACK HEART SUIT # heart */ - { 0x2666, 0xA8 }, /* BLACK DIAMOND SUIT # diamond */ - { 0xF6D9, 0xD3 }, /* COPYRIGHT SIGN SERIF # copyrightserif (CUS) */ - { 0xF6DA, 0xD2 }, /* REGISTERED SIGN SERIF # registerserif (CUS) */ - { 0xF6DB, 0xD4 }, /* TRADE MARK SIGN SERIF # trademarkserif (CUS) */ - { 0xF8E5, 0x60 }, /* RADICAL EXTENDER # radicalex (CUS) */ - { 0xF8E6, 0xBD }, /* VERTICAL ARROW EXTENDER # arrowvertex (CUS) */ - { 0xF8E7, 0xBE }, /* HORIZONTAL ARROW EXTENDER # arrowhorizex (CUS) */ - { 0xF8E8, 0xE2 }, /* REGISTERED SIGN SANS SERIF # registersans (CUS) */ - { 0xF8E9, 0xE3 }, /* COPYRIGHT SIGN SANS SERIF # copyrightsans (CUS) */ - { 0xF8EA, 0xE4 }, /* TRADE MARK SIGN SANS SERIF # trademarksans (CUS) */ - { 0xF8EB, 0xE6 }, /* LEFT PAREN TOP # parenlefttp (CUS) */ - { 0xF8EC, 0xE7 }, /* LEFT PAREN EXTENDER # parenleftex (CUS) */ - { 0xF8ED, 0xE8 }, /* LEFT PAREN BOTTOM # parenleftbt (CUS) */ - { 0xF8EE, 0xE9 }, /* LEFT SQUARE BRACKET TOP # bracketlefttp (CUS) */ - { 0xF8EF, 0xEA }, /* LEFT SQUARE BRACKET EXTENDER # bracketleftex (CUS) */ - { 0xF8F0, 0xEB }, /* LEFT SQUARE BRACKET BOTTOM # bracketleftbt (CUS) */ - { 0xF8F1, 0xEC }, /* LEFT CURLY BRACKET TOP # bracelefttp (CUS) */ - { 0xF8F2, 0xED }, /* LEFT CURLY BRACKET MID # braceleftmid (CUS) */ - { 0xF8F3, 0xEE }, /* LEFT CURLY BRACKET BOTTOM # braceleftbt (CUS) */ - { 0xF8F4, 0xEF }, /* CURLY BRACKET EXTENDER # braceex (CUS) */ - { 0xF8F5, 0xF4 }, /* INTEGRAL EXTENDER # integralex (CUS) */ - { 0xF8F6, 0xF6 }, /* RIGHT PAREN TOP # parenrighttp (CUS) */ - { 0xF8F7, 0xF7 }, /* RIGHT PAREN EXTENDER # parenrightex (CUS) */ - { 0xF8F8, 0xF8 }, /* RIGHT PAREN BOTTOM # parenrightbt (CUS) */ - { 0xF8F9, 0xF9 }, /* RIGHT SQUARE BRACKET TOP # bracketrighttp (CUS) */ - { 0xF8FA, 0xFA }, /* RIGHT SQUARE BRACKET EXTENDER # bracketrightex (CUS) */ - { 0xF8FB, 0xFB }, /* RIGHT SQUARE BRACKET BOTTOM # bracketrightbt (CUS) */ - { 0xF8FC, 0xFC }, /* RIGHT CURLY BRACKET TOP # bracerighttp (CUS) */ - { 0xF8FD, 0xFD }, /* RIGHT CURLY BRACKET MID # bracerightmid (CUS) */ - { 0xF8FE, 0xFE }, /* RIGHT CURLY BRACKET BOTTOM # bracerightbt (CUS) */ -}; - -static const FcCharMap AdobeSymbol = { - AdobeSymbolEnt, - sizeof (AdobeSymbolEnt) / sizeof (AdobeSymbolEnt[0]), -}; - -static const FcFontDecode fcFontDecoders[] = { - { ft_encoding_unicode, 0, (1 << 21) - 1 }, - { ft_encoding_symbol, &AdobeSymbol, (1 << 16) - 1 }, - { ft_encoding_apple_roman, &AppleRoman, (1 << 16) - 1 }, -}; - -#define NUM_DECODE (sizeof (fcFontDecoders) / sizeof (fcFontDecoders[0])) - -FcChar32 -FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map) -{ - int low, high, mid; - FcChar16 bmp; - - low = 0; - high = map->nent - 1; - if (ucs4 < map->ent[low].bmp || map->ent[high].bmp < ucs4) - return ~0; - while (low <= high) - { - mid = (high + low) >> 1; - bmp = map->ent[mid].bmp; - if (ucs4 == bmp) - return (FT_ULong) map->ent[mid].encode; - if (ucs4 < bmp) - high = mid - 1; - else - low = mid + 1; - } - return ~0; -} - -FcChar32 -FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map) -{ - int i; - - for (i = 0; i < map->nent; i++) - if (map->ent[i].encode == private) - return (FcChar32) map->ent[i].bmp; - return ~0; -} - -const FcCharMap * -FcFreeTypeGetPrivateMap (FT_Encoding encoding) -{ - int i; - - for (i = 0; i < NUM_DECODE; i++) - if (fcFontDecoders[i].encoding == encoding) - return fcFontDecoders[i].map; - return 0; -} - -/* - * Map a UCS4 glyph to a glyph index. Use all available encoding - * tables to try and find one that works. This information is expected - * to be cached by higher levels, so performance isn't critical - */ - -FT_UInt -FcFreeTypeCharIndex (FT_Face face, FcChar32 ucs4) -{ - int initial, offset, decode; - FT_UInt glyphindex; - FcChar32 charcode; - - initial = 0; - /* - * Find the current encoding - */ - if (face->charmap) - { - for (; initial < NUM_DECODE; initial++) - if (fcFontDecoders[initial].encoding == face->charmap->encoding) - break; - if (initial == NUM_DECODE) - initial = 0; - } - /* - * Check each encoding for the glyph, starting with the current one - */ - for (offset = 0; offset < NUM_DECODE; offset++) - { - decode = (initial + offset) % NUM_DECODE; - if (!face->charmap || face->charmap->encoding != fcFontDecoders[decode].encoding) - if (FT_Select_Charmap (face, fcFontDecoders[decode].encoding) != 0) - continue; - if (fcFontDecoders[decode].map) - { - charcode = FcFreeTypeUcs4ToPrivate (ucs4, fcFontDecoders[decode].map); - if (charcode == ~0) - continue; - } - else - charcode = ucs4; - glyphindex = FT_Get_Char_Index (face, (FT_ULong) charcode); - if (glyphindex) - return glyphindex; - } - return 0; -} - -static FcBool -FcFreeTypeCheckGlyph (FT_Face face, FcChar32 ucs4, - FT_UInt glyph, FcBlanks *blanks) -{ - FT_Int load_flags = FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING; - FT_GlyphSlot slot; - - /* - * When using scalable fonts, only report those glyphs - * which can be scaled; otherwise those fonts will - * only be available at some sizes, and never when - * transformed. Avoid this by simply reporting bitmap-only - * glyphs as missing - */ - if (face->face_flags & FT_FACE_FLAG_SCALABLE) - load_flags |= FT_LOAD_NO_BITMAP; - - if (FT_Load_Glyph (face, glyph, load_flags)) - return FcFalse; - - slot = face->glyph; - if (!glyph) - return FcFalse; - - switch (slot->format) { - case ft_glyph_format_bitmap: - /* - * Bitmaps are assumed to be reasonable; if - * this proves to be a rash assumption, this - * code can be easily modified - */ - return FcTrue; - case ft_glyph_format_outline: - /* - * Glyphs with contours are always OK - */ - if (slot->outline.n_contours != 0) - return FcTrue; - /* - * Glyphs with no contours are only OK if - * they're members of the Blanks set specified - * in the configuration. If blanks isn't set, - * then allow any glyph to be blank - */ - if (!blanks || FcBlanksIsMember (blanks, ucs4)) - return FcTrue; - /* fall through ... */ - default: - break; - } - return FcFalse; -} - -FcCharSet * -FcFreeTypeCharSet (FT_Face face, FcBlanks *blanks) -{ - FcChar32 page, off, ucs4; -#ifdef CHECK - FcChar32 font_max = 0; -#endif - FcCharSet *fcs; - FcCharLeaf *leaf; - const FcCharMap *map; - int o; - int i; - FT_UInt glyph; - - fcs = FcCharSetCreate (); - if (!fcs) - goto bail0; - - for (o = 0; o < NUM_DECODE; o++) - { - if (FT_Select_Charmap (face, fcFontDecoders[o].encoding) != 0) - continue; - map = fcFontDecoders[o].map; - if (map) - { - /* - * Non-Unicode tables are easy; there's a list of all possible - * characters - */ - for (i = 0; i < map->nent; i++) - { - ucs4 = map->ent[i].bmp; - glyph = FT_Get_Char_Index (face, map->ent[i].encode); - if (glyph && FcFreeTypeCheckGlyph (face, ucs4, glyph, blanks)) - { - leaf = FcCharSetFindLeafCreate (fcs, ucs4); - if (!leaf) - goto bail1; - leaf->map[(ucs4 & 0xff) >> 5] |= (1 << (ucs4 & 0x1f)); -#ifdef CHECK - if (ucs4 > font_max) - font_max = ucs4; -#endif - } - } - } - else - { - FT_UInt gindex; - - /* - * Find the first encoded character in the font - */ - if (FT_Get_Char_Index (face, 0)) - { - ucs4 = 0; - gindex = 1; - } - else - { - ucs4 = FT_Get_Next_Char (face, 0, &gindex); - if (!ucs4) - gindex = 0; - } - - while (gindex) - { - page = ucs4 >> 8; - leaf = 0; - while ((ucs4 >> 8) == page) - { - glyph = FT_Get_Char_Index (face, ucs4); - if (glyph && FcFreeTypeCheckGlyph (face, ucs4, - glyph, blanks)) - { - if (!leaf) - { - leaf = FcCharSetFindLeafCreate (fcs, ucs4); - if (!leaf) - goto bail1; - } - off = ucs4 & 0xff; - leaf->map[off >> 5] |= (1 << (off & 0x1f)); -#ifdef CHECK - if (ucs4 > font_max) - font_max = ucs4; -#endif - } - ucs4++; - } - ucs4 = FT_Get_Next_Char (face, ucs4 - 1, &gindex); - if (!ucs4) - gindex = 0; - } -#ifdef CHECK - for (ucs4 = 0; ucs4 < 0x10000; ucs4++) - { - FcBool FT_Has, FC_Has; - - FT_Has = FT_Get_Char_Index (face, ucs4) != 0; - FC_Has = FcCharSetHasChar (fcs, ucs4); - if (FT_Has != FC_Has) - { - printf ("0x%08x FT says %d FC says %d\n", ucs4, FT_Has, FC_Has); - } - } -#endif - } - } -#ifdef CHECK - printf ("%d glyphs %d encoded\n", (int) face->num_glyphs, FcCharSetCount (fcs)); - for (ucs4 = 0; ucs4 <= font_max; ucs4++) - { - FcBool has_char = FcFreeTypeCharIndex (face, ucs4) != 0; - FcBool has_bit = FcCharSetHasChar (fcs, ucs4); - - if (has_char && !has_bit) - printf ("Bitmap missing char 0x%x\n", ucs4); - else if (!has_char && has_bit) - printf ("Bitmap extra char 0x%x\n", ucs4); - } -#endif - return fcs; -bail1: - FcCharSetDestroy (fcs); -bail0: - return 0; -} - diff -urN xc/extras/fontconfig/src/fcdbg.c xc-fontconfig/extras/fontconfig/src/fcdbg.c --- xc/extras/fontconfig/src/fcdbg.c 2003-09-25 13:01:22.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/src/fcdbg.c 2003-11-21 01:35:12.000000000 +0100 @@ -1,7 +1,7 @@ /* - * $XFree86: xc/extras/fontconfig/src/fcdbg.c,v 1.1.1.1 2003/06/04 02:57:52 dawes Exp $ + * $RCSId: xc/lib/fontconfig/src/fcdbg.c,v 1.10 2002/08/22 18:53:22 keithp Exp $ * - * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * Copyright © 2000 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that @@ -34,10 +34,10 @@ printf (" "); break; case FcTypeInteger: - printf (" %d", v.u.i); + printf (" %d(i)", v.u.i); break; case FcTypeDouble: - printf (" %g", v.u.d); + printf (" %g(f)", v.u.d); break; case FcTypeString: printf (" \"%s\"", v.u.s); @@ -52,7 +52,8 @@ printf (" set"); break; case FcTypeLangSet: - printf (" langset"); + printf (" "); + FcLangSetPrint (v.u.l); break; case FcTypeFTFace: printf (" face"); @@ -66,12 +67,35 @@ for (; l; l = l->next) { FcValuePrint (l->value); - if (l->binding == FcValueBindingWeak) + switch (l->binding) { + case FcValueBindingWeak: printf ("(w)"); + break; + case FcValueBindingStrong: + printf ("(s)"); + break; + case FcValueBindingSame: + printf ("(=)"); + break; + } } } void +FcLangSetPrint (const FcLangSet *ls) +{ + FcStrBuf buf; + FcChar8 init_buf[1024]; + + FcStrBufInit (&buf, init_buf, sizeof (init_buf)); + if (FcNameUnparseLangSet (&buf, ls) && FcStrBufChar (&buf,'\0')) + printf ("%s", buf.buf); + else + printf ("langset (alloc error)"); + FcStrBufDestroy (&buf); +} + +void FcPatternPrint (const FcPattern *p) { int i; @@ -129,6 +153,10 @@ case FcOpNot: printf ("Not"); break; case FcOpNil: printf ("Nil"); break; case FcOpComma: printf ("Comma"); break; + case FcOpFloor: printf ("Floor"); break; + case FcOpCeil: printf ("Ceil"); break; + case FcOpRound: printf ("Round"); break; + case FcOpTrunc: printf ("Trunc"); break; case FcOpInvalid: printf ("Invalid"); break; } } @@ -136,7 +164,8 @@ void FcExprPrint (const FcExpr *expr) { - switch (expr->op) { + if (!expr) printf ("none"); + else switch (expr->op) { case FcOpInteger: printf ("%d", expr->u.ival); break; case FcOpDouble: printf ("%g", expr->u.dval); break; case FcOpString: printf ("\"%s\"", expr->u.sval); break; @@ -211,6 +240,22 @@ printf ("Not "); FcExprPrint (expr->u.tree.left); break; + case FcOpFloor: + printf ("Floor "); + FcExprPrint (expr->u.tree.left); + break; + case FcOpCeil: + printf ("Ceil "); + FcExprPrint (expr->u.tree.left); + break; + case FcOpRound: + printf ("Round "); + FcExprPrint (expr->u.tree.left); + break; + case FcOpTrunc: + printf ("Trunc "); + FcExprPrint (expr->u.tree.left); + break; case FcOpInvalid: printf ("Invalid"); break; } } diff -urN xc/extras/fontconfig/src/fcdefault.c xc-fontconfig/extras/fontconfig/src/fcdefault.c --- xc/extras/fontconfig/src/fcdefault.c 2003-09-25 13:01:22.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/src/fcdefault.c 2003-11-21 01:35:12.000000000 +0100 @@ -1,7 +1,7 @@ /* - * $XFree86: xc/extras/fontconfig/src/fcdefault.c,v 1.1.1.1 2003/06/04 02:57:52 dawes Exp $ + * $RCSId: xc/lib/fontconfig/src/fcdefault.c,v 1.2 2002/07/09 22:08:14 keithp Exp $ * - * Copyright © 2001 Keith Packard, member of The XFree86 Project, Inc. + * Copyright © 2001 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that @@ -55,6 +55,9 @@ } } + if (FcPatternGet (pattern, FC_WIDTH, 0, &v) == FcResultNoMatch) + FcPatternAddInteger (pattern, FC_WIDTH, FC_WIDTH_NORMAL); + for (i = 0; i < NUM_FC_BOOL_DEFAULTS; i++) if (FcPatternGet (pattern, FcBoolDefaults[i].field, 0, &v) == FcResultNoMatch) FcPatternAddBool (pattern, FcBoolDefaults[i].field, FcBoolDefaults[i].value); diff -urN xc/extras/fontconfig/src/fcdir.c xc-fontconfig/extras/fontconfig/src/fcdir.c --- xc/extras/fontconfig/src/fcdir.c 2003-06-04 18:29:39.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/src/fcdir.c 2003-11-21 01:35:12.000000000 +0100 @@ -1,5 +1,7 @@ /* - * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * $RCSId: xc/lib/fontconfig/src/fcdir.c,v 1.9 2002/08/31 22:17:32 keithp Exp $ + * + * Copyright © 2000 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that @@ -19,7 +21,6 @@ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ -/* $XFree86: xc/extras/fontconfig/src/fcdir.c,v 1.2 2003/06/04 16:29:39 dawes Exp $ */ #include "fcint.h" #include @@ -46,6 +47,7 @@ FcChar8 *name; FcPattern *font; FcBool ret = FcTrue; + FcBool isDir; int count = 0; FcGlobalCacheFile *cache_file; FcGlobalCacheDir *cache_dir; @@ -68,7 +70,7 @@ /* * Found a cache entry for the file */ - if (FcGlobalCacheCheckTime (&cache_file->info)) + if (FcGlobalCacheCheckTime (file, &cache_file->info)) { name = cache_file->name; need_scan = FcFalse; @@ -87,7 +89,8 @@ strlen ((const char *) file), FcFalse))) { - if (FcGlobalCacheCheckTime (&cache_dir->info)) + if (FcGlobalCacheCheckTime (cache_dir->info.file, + &cache_dir->info)) { font = 0; need_scan = FcFalse; @@ -110,11 +113,11 @@ font = FcFreeTypeQuery (file, id, blanks, &count); if (FcDebug () & FC_DBG_SCAN) printf ("done\n"); + isDir = FcFalse; if (!font && FcFileIsDir (file)) { + isDir = FcTrue; ret = FcStrSetAdd (dirs, file); - if (cache && ret) - FcGlobalCacheUpdate (cache, file, 0, FC_FONT_FILE_DIR); } /* * Update the cache @@ -150,6 +153,11 @@ #define FC_MAX_FILE_LEN 4096 +/* + * Scan 'dir', adding font files to 'set' and + * subdirectories to 'dirs' + */ + FcBool FcDirScan (FcFontSet *set, FcStrSet *dirs, @@ -170,7 +178,11 @@ * Check fonts.cache- file */ if (FcDirCacheReadDir (set, dirs, dir)) + { + if (cache) + FcGlobalCacheReferenceSubdir (cache, dir); return FcTrue; + } /* * Check ~/.fonts.cache- file @@ -188,6 +200,9 @@ strcat ((char *) file, "/"); base = file + strlen ((char *) file); + if (FcDebug () & FC_DBG_SCAN) + printf ("\tScanning dir %s\n", dir); + d = opendir ((char *) dir); if (!d) @@ -208,6 +223,10 @@ } free (file); closedir (d); + /* + * Now that the directory has been scanned, + * add the cache entry + */ if (ret && cache) FcGlobalCacheUpdate (cache, dir, 0, 0); diff -urN xc/extras/fontconfig/src/fcfs.c xc-fontconfig/extras/fontconfig/src/fcfs.c --- xc/extras/fontconfig/src/fcfs.c 2003-09-25 13:01:22.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/src/fcfs.c 2003-11-21 01:35:12.000000000 +0100 @@ -1,7 +1,7 @@ /* - * $XFree86: xc/extras/fontconfig/src/fcfs.c,v 1.1.1.1 2003/06/04 02:57:52 dawes Exp $ + * $RCSId: $ * - * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * Copyright © 2000 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that diff -urN xc/extras/fontconfig/src/fcinit.c xc-fontconfig/extras/fontconfig/src/fcinit.c --- xc/extras/fontconfig/src/fcinit.c 2003-09-25 13:01:22.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/src/fcinit.c 2003-11-21 01:35:12.000000000 +0100 @@ -1,7 +1,7 @@ /* - * $XFree86: xc/extras/fontconfig/src/fcinit.c,v 1.1.1.1 2003/06/04 02:57:52 dawes Exp $ + * $RCSId: xc/lib/fontconfig/src/fcinit.c,v 1.7 2002/08/22 07:36:44 keithp Exp $ * - * Copyright © 2001 Keith Packard, member of The XFree86 Project, Inc. + * Copyright © 2001 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that diff -urN xc/extras/fontconfig/src/fcint.h xc-fontconfig/extras/fontconfig/src/fcint.h --- xc/extras/fontconfig/src/fcint.h 2003-11-02 05:40:29.000000000 +0100 +++ xc-fontconfig/extras/fontconfig/src/fcint.h 2003-11-21 01:35:12.000000000 +0100 @@ -1,7 +1,7 @@ /* - * $XFree86: xc/extras/fontconfig/src/fcint.h,v 1.2 2003/10/22 17:15:22 tsi Exp $ + * $RCSId: xc/lib/fontconfig/src/fcint.h,v 1.27 2002/08/31 22:17:32 keithp Exp $ * - * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * Copyright © 2000 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that @@ -53,6 +53,12 @@ #define FC_FONT_FILE_INVALID ((FcChar8 *) ".") #define FC_FONT_FILE_DIR ((FcChar8 *) ".dir") +#ifdef _WIN32 +#define FC_SEARCH_PATH_SEPARATOR ';' +#else +#define FC_SEARCH_PATH_SEPARATOR ':' +#endif + #define FC_DBG_MATCH 1 #define FC_DBG_MATCHV 2 #define FC_DBG_EDIT 4 @@ -97,7 +103,7 @@ #define FC_MEM_NUM 29 typedef enum _FcValueBinding { - FcValueBindingWeak, FcValueBindingStrong + FcValueBindingWeak, FcValueBindingStrong, FcValueBindingSame } FcValueBinding; typedef struct _FcValueList { @@ -129,7 +135,8 @@ FcOpOr, FcOpAnd, FcOpEqual, FcOpNotEqual, FcOpContains, FcOpNotContains, FcOpLess, FcOpLessEqual, FcOpMore, FcOpMoreEqual, FcOpPlus, FcOpMinus, FcOpTimes, FcOpDivide, - FcOpNot, FcOpComma, FcOpInvalid + FcOpNot, FcOpComma, FcOpFloor, FcOpCeil, FcOpRound, FcOpTrunc, + FcOpInvalid } FcOp; typedef struct _FcExpr { @@ -338,12 +345,16 @@ FcGlobalCacheDestroy (FcGlobalCache *cache); FcBool -FcGlobalCacheCheckTime (FcGlobalCacheInfo *info); +FcGlobalCacheCheckTime (const FcChar8*file, FcGlobalCacheInfo *info); void FcGlobalCacheReferenced (FcGlobalCache *cache, FcGlobalCacheInfo *info); +void +FcGlobalCacheReferenceSubdir (FcGlobalCache *cache, + const FcChar8 *dir); + FcGlobalCacheDir * FcGlobalCacheDirGet (FcGlobalCache *cache, const FcChar8 *dir, @@ -421,9 +432,9 @@ FcSetName set); FcBool -FcConfigCompareValue (FcValue m, - FcOp op, - FcValue v); +FcConfigCompareValue (const FcValue m, + FcOp op, + const FcValue v); /* fccharset.c */ FcCharSet * @@ -435,20 +446,17 @@ FcCharSet * FcNameParseCharSet (FcChar8 *string); -FcChar32 -FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map); - -FcChar32 -FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map); +FcCharLeaf * +FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4); -const FcCharMap * -FcFreeTypeGetPrivateMap (FT_Encoding encoding); - /* fcdbg.c */ void FcValueListPrint (const FcValueList *l); void +FcLangSetPrint (const FcLangSet *ls); + +void FcOpPrint (FcOp op); void @@ -479,6 +487,15 @@ FcBool FcFreeTypeHasLang (FcPattern *pattern, const FcChar8 *lang); +FcChar32 +FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map); + +FcChar32 +FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map); + +const FcCharMap * +FcFreeTypeGetPrivateMap (FT_Encoding encoding); + /* fcfs.c */ /* fcgram.y */ int @@ -636,4 +653,10 @@ int FcStrCmpIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2); +FcBool +FcStrUsesHome (const FcChar8 *s); + +FcChar8 * +FcStrLastSlash (const FcChar8 *path); + #endif /* _FC_INT_H_ */ diff -urN xc/extras/fontconfig/src/fclang.c xc-fontconfig/extras/fontconfig/src/fclang.c --- xc/extras/fontconfig/src/fclang.c 2003-06-04 18:29:39.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/src/fclang.c 2003-11-21 01:35:12.000000000 +0100 @@ -1,5 +1,7 @@ /* - * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc. + * $RCSId: xc/lib/fontconfig/src/fclang.c,v 1.7 2002/08/26 23:34:31 keithp Exp $ + * + * Copyright © 2002 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that @@ -19,7 +21,6 @@ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ -/* $XFree86: xc/extras/fontconfig/src/fclang.c,v 1.2 2003/06/04 16:29:39 dawes Exp $ */ #include "fcint.h" @@ -28,6 +29,11 @@ FcCharSet charset; } FcLangCharSet; +typedef struct { + int begin; + int end; +} FcLangCharSetRange; + #include "../fc-lang/fclang.h" struct _FcLangSet { @@ -137,6 +143,37 @@ } } +/* + * Return FcTrue when s1 contains s2. + * + * s1 contains s2 if s1 equals s2 or if s1 is a + * language with a country and s2 is just a language + */ + +static FcBool +FcLangContains (const FcChar8 *s1, const FcChar8 *s2) +{ + FcChar8 c1, c2; + + for (;;) + { + c1 = *s1++; + c2 = *s2++; + + c1 = FcToLower (c1); + c2 = FcToLower (c2); + if (c1 != c2) + { + /* see if s1 has a country while s2 is mising one */ + if (c1 == '-' && c2 == '\0') + return FcTrue; + return FcFalse; + } + else if (!c1) + return FcTrue; + } +} + const FcCharSet * FcCharSetForLang (const FcChar8 *lang) { @@ -222,16 +259,48 @@ static int FcLangSetIndex (const FcChar8 *lang) { - int low, high, mid; - int cmp; + int low, high, mid = 0; + int cmp = 0; + FcChar8 firstChar = FcToLower(lang[0]); + FcChar8 secondChar = firstChar ? FcToLower(lang[1]) : '\0'; + + if (firstChar < 'a') + { + low = 0; + high = fcLangCharSetRanges[0].begin; + } + else if(firstChar > 'z') + { + low = fcLangCharSetRanges[25].begin; + high = NUM_LANG_CHAR_SET - 1; + } + else + { + low = fcLangCharSetRanges[firstChar - 'a'].begin; + high = fcLangCharSetRanges[firstChar - 'a'].end; + /* no matches */ + if (low > high) + return -low; /* next entry after where it would be */ + } - low = 0; - high = NUM_LANG_CHAR_SET - 1; while (low <= high) { mid = (high + low) >> 1; - cmp = FcStrCmpIgnoreCase (fcLangCharSets[mid].lang, lang); - if (cmp == 0) + if(fcLangCharSets[mid].lang[0] != firstChar) + cmp = FcStrCmpIgnoreCase(fcLangCharSets[mid].lang, lang); + else + { /* fast path for resolving 2-letter languages (by far the most common) after + * finding the first char (probably already true because of the hash table) */ + cmp = fcLangCharSets[mid].lang[1] - secondChar; + if (cmp == 0 && + (fcLangCharSets[mid].lang[2] != '\0' || + lang[2] != '\0')) + { + cmp = FcStrCmpIgnoreCase(fcLangCharSets[mid].lang+2, + lang+2); + } + } + if (cmp == 0) return mid; if (cmp < 0) low = mid + 1; @@ -411,32 +480,28 @@ FcLangSet * FcNameParseLangSet (const FcChar8 *string) { - FcChar8 lang[32]; - const FcChar8 *end, *next; + FcChar8 lang[32],c; + int i; FcLangSet *ls; ls = FcLangSetCreate (); if (!ls) goto bail0; - while (string && *string) + for(;;) { - end = (FcChar8 *) strchr ((char *) string, '|'); - if (!end) + for(i = 0; i < 31;i++) { - end = string + strlen ((char *) string); - next = end; + c = *string++; + if(c == '\0' || c == '|') + break; /* end of this code */ + lang[i] = c; } - else - next = end + 1; - if (end - string < sizeof (lang) - 1) - { - strncpy ((char *) lang, (char *) string, end - string); - lang[end-string] = '\0'; - if (!FcLangSetAdd (ls, lang)) - goto bail1; - } - string = next; + lang[i] = '\0'; + if (!FcLangSetAdd (ls, lang)) + goto bail1; + if(c == '\0') + break; } return ls; bail1: @@ -481,7 +546,7 @@ if (!first) if (!FcStrBufChar (buf, '|')) return FcFalse; - if (!FcStrBufString (buf, extra)); + if (!FcStrBufString (buf, extra)) return FcFalse; first = FcFalse; } @@ -505,3 +570,113 @@ return FcStrSetEqual (lsa->extra, lsb->extra); return FcFalse; } + +static FcBool +FcLangSetContainsLang (const FcLangSet *ls, const FcChar8 *lang) +{ + int id; + int i; + + id = FcLangSetIndex (lang); + if (id < 0) + id = -id - 1; + else if (FcLangSetBitGet (ls, id)) + return FcTrue; + /* + * search up and down among equal languages for a match + */ + for (i = id - 1; i >= 0; i--) + { + if (FcLangCompare (fcLangCharSets[i].lang, lang) == FcLangDifferentLang) + break; + if (FcLangSetBitGet (ls, i) && + FcLangContains (fcLangCharSets[i].lang, lang)) + return FcTrue; + } + for (i = id; i < NUM_LANG_CHAR_SET; i++) + { + if (FcLangCompare (fcLangCharSets[i].lang, lang) == FcLangDifferentLang) + break; + if (FcLangSetBitGet (ls, i) && + FcLangContains (fcLangCharSets[i].lang, lang)) + return FcTrue; + } + if (ls->extra) + { + FcStrList *list = FcStrListCreate (ls->extra); + FcChar8 *extra; + + if (list) + { + while ((extra = FcStrListNext (list))) + { + if (FcLangContains (extra, lang)) + break; + } + FcStrListDone (list); + if (extra) + return FcTrue; + } + } + return FcFalse; +} + +/* + * return FcTrue if lsa contains every language in lsb + */ +FcBool +FcLangSetContains (const FcLangSet *lsa, const FcLangSet *lsb) +{ + int i, j; + FcChar32 missing; + + if (FcDebug() & FC_DBG_MATCHV) + { + printf ("FcLangSet "); FcLangSetPrint (lsa); + printf (" contains "); FcLangSetPrint (lsb); + printf ("\n"); + } + /* + * check bitmaps for missing language support + */ + for (i = 0; i < NUM_LANG_SET_MAP; i++) + { + missing = lsb->map[i] & ~lsa->map[i]; + if (missing) + { + for (j = 0; j < 32; j++) + if (missing & (1 << j)) + { + if (!FcLangSetContainsLang (lsa, + fcLangCharSets[i*32 + j].lang)) + { + if (FcDebug() & FC_DBG_MATCHV) + printf ("\tMissing bitmap %s\n", fcLangCharSets[i*32+j].lang); + return FcFalse; + } + } + } + } + if (lsb->extra) + { + FcStrList *list = FcStrListCreate (lsb->extra); + FcChar8 *extra; + + if (list) + { + while ((extra = FcStrListNext (list))) + { + if (!FcLangSetContainsLang (lsa, extra)) + { + if (FcDebug() & FC_DBG_MATCHV) + printf ("\tMissing string %s\n", extra); + break; + } + } + FcStrListDone (list); + if (extra) + return FcFalse; + } + } + return FcTrue; +} diff -urN xc/extras/fontconfig/src/fclist.c xc-fontconfig/extras/fontconfig/src/fclist.c --- xc/extras/fontconfig/src/fclist.c 2003-09-25 13:01:22.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/src/fclist.c 2003-11-21 01:35:12.000000000 +0100 @@ -1,7 +1,7 @@ /* - * $XFree86: xc/extras/fontconfig/src/fclist.c,v 1.1.1.1 2003/06/04 02:58:01 dawes Exp $ + * $RCSId: xc/lib/fontconfig/src/fclist.c,v 1.11tsi Exp $ * - * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * Copyright © 2000 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that @@ -128,7 +128,7 @@ for (v1 = v1orig; v1; v1 = v1->next) for (v2 = v2orig; v2; v2 = v2->next) - if (FcConfigCompareValue (v2->value, FcOpContains, v1->value)) + if (FcConfigCompareValue (v1->value, FcOpContains, v2->value)) return FcTrue; return FcFalse; } diff -urN xc/extras/fontconfig/src/fcmatch.c xc-fontconfig/extras/fontconfig/src/fcmatch.c --- xc/extras/fontconfig/src/fcmatch.c 2003-09-25 13:01:22.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/src/fcmatch.c 2003-11-21 01:35:12.000000000 +0100 @@ -1,7 +1,7 @@ /* - * $XFree86: xc/extras/fontconfig/src/fcmatch.c,v 1.1.1.1 2003/06/04 02:58:01 dawes Exp $ + * $RCSId: xc/lib/fontconfig/src/fcmatch.c,v 1.20 2002/08/31 22:17:32 keithp Exp $ * - * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * Copyright © 2000 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that @@ -28,13 +28,31 @@ #include static double -FcCompareInteger (char *object, FcValue value1, FcValue value2) +FcCompareNumber (char *object, FcValue value1, FcValue value2) { - int v; + double v1, v2, v; - if (value2.type != FcTypeInteger || value1.type != FcTypeInteger) + switch (value1.type) { + case FcTypeInteger: + v1 = (double) value1.u.i; + break; + case FcTypeDouble: + v1 = value1.u.d; + break; + default: return -1.0; - v = value2.u.i - value1.u.i; + } + switch (value2.type) { + case FcTypeInteger: + v2 = (double) value2.u.i; + break; + case FcTypeDouble: + v2 = value2.u.d; + break; + default: + return -1.0; + } + v = v2 - v1; if (v < 0) v = -v; return (double) v; @@ -173,7 +191,7 @@ { FC_LANG, FcCompareLang, 3, 3 }, #define MATCH_LANG 3 - { FC_SPACING, FcCompareInteger, 5, 5 }, + { FC_SPACING, FcCompareNumber, 5, 5 }, #define MATCH_SPACING 4 { FC_PIXEL_SIZE, FcCompareSize, 6, 6 }, @@ -182,26 +200,29 @@ { FC_STYLE, FcCompareString, 7, 7 }, #define MATCH_STYLE 6 - { FC_SLANT, FcCompareInteger, 8, 8 }, + { FC_SLANT, FcCompareNumber, 8, 8 }, #define MATCH_SLANT 7 - { FC_WEIGHT, FcCompareInteger, 9, 9 }, + { FC_WEIGHT, FcCompareNumber, 9, 9 }, #define MATCH_WEIGHT 8 - { FC_ANTIALIAS, FcCompareBool, 10, 10 }, -#define MATCH_ANTIALIAS 9 + { FC_WIDTH, FcCompareNumber, 10, 10 }, +#define MATCH_WIDTH 9 + + { FC_ANTIALIAS, FcCompareBool, 11, 11 }, +#define MATCH_ANTIALIAS 10 - { FC_RASTERIZER, FcCompareString, 11, 11 }, -#define MATCH_RASTERIZER 10 + { FC_RASTERIZER, FcCompareString, 12, 12 }, +#define MATCH_RASTERIZER 11 - { FC_OUTLINE, FcCompareBool, 12, 12 }, -#define MATCH_OUTLINE 11 + { FC_OUTLINE, FcCompareBool, 13, 13 }, +#define MATCH_OUTLINE 12 - { FC_FONTVERSION, FcCompareInteger, 13, 13 }, -#define MATCH_FONTVERSION 12 + { FC_FONTVERSION, FcCompareNumber, 14, 14 }, +#define MATCH_FONTVERSION 13 }; -#define NUM_MATCH_VALUES 14 +#define NUM_MATCH_VALUES 15 static FcBool FcCompareValueList (const char *object, @@ -255,7 +276,13 @@ case 'p': i = MATCH_PIXEL_SIZE; break; case 'w': - i = MATCH_WEIGHT; break; + switch (FcToLower (object[1])) { + case 'i': + i = MATCH_WIDTH; break; + case 'e': + i = MATCH_WEIGHT; break; + } + break; case 'r': i = MATCH_RASTERIZER; break; case 'o': diff -urN xc/extras/fontconfig/src/fcmatrix.c xc-fontconfig/extras/fontconfig/src/fcmatrix.c --- xc/extras/fontconfig/src/fcmatrix.c 2003-09-25 13:01:22.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/src/fcmatrix.c 2003-11-21 01:35:12.000000000 +0100 @@ -1,5 +1,5 @@ /* - * $XFree86: xc/extras/fontconfig/src/fcmatrix.c,v 1.1.1.1 2003/06/04 02:58:01 dawes Exp $ + * $RCSId: $ * * Copyright © 2000 Tuomas J. Lukka * diff -urN xc/extras/fontconfig/src/fcname.c xc-fontconfig/extras/fontconfig/src/fcname.c --- xc/extras/fontconfig/src/fcname.c 2003-09-25 13:01:22.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/src/fcname.c 2003-11-21 01:35:12.000000000 +0100 @@ -1,7 +1,7 @@ /* - * $XFree86: xc/extras/fontconfig/src/fcname.c,v 1.1.1.1 2003/06/04 02:58:01 dawes Exp $ + * $RCSId: xc/lib/fontconfig/src/fcname.c,v 1.15 2002/09/26 00:17:28 keithp Exp $ * - * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * Copyright © 2000 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that @@ -33,6 +33,7 @@ { FC_STYLE, FcTypeString, }, { FC_SLANT, FcTypeInteger, }, { FC_WEIGHT, FcTypeInteger, }, + { FC_WIDTH, FcTypeInteger, }, { FC_SIZE, FcTypeDouble, }, { FC_ASPECT, FcTypeDouble, }, { FC_PIXEL_SIZE, FcTypeDouble, }, @@ -137,16 +138,33 @@ } static const FcConstant _FcBaseConstants[] = { + { (FcChar8 *) "thin", "weight", FC_WEIGHT_THIN, }, + { (FcChar8 *) "extralight", "weight", FC_WEIGHT_EXTRALIGHT, }, + { (FcChar8 *) "ultralight", "weight", FC_WEIGHT_EXTRALIGHT, }, { (FcChar8 *) "light", "weight", FC_WEIGHT_LIGHT, }, + { (FcChar8 *) "regular", "weight", FC_WEIGHT_REGULAR, }, { (FcChar8 *) "medium", "weight", FC_WEIGHT_MEDIUM, }, { (FcChar8 *) "demibold", "weight", FC_WEIGHT_DEMIBOLD, }, + { (FcChar8 *) "semibold", "weight", FC_WEIGHT_DEMIBOLD, }, { (FcChar8 *) "bold", "weight", FC_WEIGHT_BOLD, }, + { (FcChar8 *) "extrabold", "weight", FC_WEIGHT_EXTRABOLD, }, + { (FcChar8 *) "ultrabold", "weight", FC_WEIGHT_EXTRABOLD, }, { (FcChar8 *) "black", "weight", FC_WEIGHT_BLACK, }, { (FcChar8 *) "roman", "slant", FC_SLANT_ROMAN, }, { (FcChar8 *) "italic", "slant", FC_SLANT_ITALIC, }, { (FcChar8 *) "oblique", "slant", FC_SLANT_OBLIQUE, }, + { (FcChar8 *) "ultracondensed", "width", FC_WIDTH_ULTRACONDENSED }, + { (FcChar8 *) "extracondensed", "width", FC_WIDTH_EXTRACONDENSED }, + { (FcChar8 *) "condensed", "width", FC_WIDTH_CONDENSED }, + { (FcChar8 *) "semicondensed", "width", FC_WIDTH_SEMICONDENSED }, + { (FcChar8 *) "normal", "width", FC_WIDTH_NORMAL }, + { (FcChar8 *) "semiexpanded", "width", FC_WIDTH_SEMIEXPANDED }, + { (FcChar8 *) "expanded", "width", FC_WIDTH_EXPANDED }, + { (FcChar8 *) "extraexpanded", "width", FC_WIDTH_EXTRAEXPANDED }, + { (FcChar8 *) "ultraexpanded", "width", FC_WIDTH_ULTRAEXPANDED }, + { (FcChar8 *) "proportional", "spacing", FC_PROPORTIONAL, }, { (FcChar8 *) "mono", "spacing", FC_MONO, }, { (FcChar8 *) "charcell", "spacing", FC_CHARCELL, }, @@ -218,7 +236,7 @@ { const FcConstantList *l; int i; - + for (l = _FcConstants; l; l = l->next) { for (i = 0; i < l->nconsts; i++) @@ -247,8 +265,7 @@ char c0, c1; c0 = *v; - if (isupper (c0)) - c0 = tolower (c0); + c0 = FcToLower (c0); if (c0 == 't' || c0 == 'y' || c0 == '1') { *result = FcTrue; @@ -262,8 +279,7 @@ if (c0 == 'o') { c1 = v[1]; - if (isupper (c1)) - c1 = tolower (c1); + c1 = FcToLower (c1); if (c1 == 'n') { *result = FcTrue; diff -urN xc/extras/fontconfig/src/fcpat.c xc-fontconfig/extras/fontconfig/src/fcpat.c --- xc/extras/fontconfig/src/fcpat.c 2003-06-04 18:29:39.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/src/fcpat.c 2003-11-21 01:35:12.000000000 +0100 @@ -1,5 +1,7 @@ /* - * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * $RCSId: xc/lib/fontconfig/src/fcpat.c,v 1.18 2002/09/18 17:11:46 tsi Exp $ + * + * Copyright © 2000 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that @@ -19,7 +21,6 @@ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ -/* $XFree86: xc/extras/fontconfig/src/fcpat.c,v 1.2 2003/06/04 16:29:39 dawes Exp $ */ #include #include @@ -753,11 +754,14 @@ FcPatternDel (FcPattern *p, const char *object) { FcPatternElt *e; + int i; e = FcPatternFindElt (p, object); if (!e) return FcFalse; + i = e - p->elts; + /* destroy value */ FcValueListDestroy (e->values); diff -urN xc/extras/fontconfig/src/fcxml.c xc-fontconfig/extras/fontconfig/src/fcxml.c --- xc/extras/fontconfig/src/fcxml.c 2003-06-04 18:29:39.000000000 +0200 +++ xc-fontconfig/extras/fontconfig/src/fcxml.c 2003-11-21 01:35:12.000000000 +0100 @@ -1,5 +1,7 @@ /* - * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc. + * $RCSId: xc/lib/fontconfig/src/fcxml.c,v 1.21 2002/08/22 18:53:22 keithp Exp $ + * + * Copyright © 2002 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that @@ -19,7 +21,6 @@ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ -/* $XFree86: xc/extras/fontconfig/src/fcxml.c,v 1.2 2003/06/04 16:29:39 dawes Exp $ */ #include #include "fcint.h" @@ -34,6 +35,12 @@ #include #endif +#ifdef _WIN32 +#define STRICT +#include +#undef STRICT +#endif + FcTest * FcTestCreate (FcMatchKind kind, FcQual qual, @@ -196,6 +203,8 @@ void FcExprDestroy (FcExpr *e) { + if (!e) + return; switch (e->op) { case FcOpInteger: break; @@ -244,6 +253,10 @@ FcExprDestroy (e->u.tree.right); /* fall through */ case FcOpNot: + case FcOpFloor: + case FcOpCeil: + case FcOpRound: + case FcOpTrunc: FcExprDestroy (e->u.tree.left); break; case FcOpNil: @@ -330,6 +343,10 @@ FcElementDivide, FcElementNot, FcElementIf, + FcElementFloor, + FcElementCeil, + FcElementRound, + FcElementTrunc, FcElementUnknown } FcElement; @@ -382,8 +399,12 @@ { "divide", FcElementDivide }, { "not", FcElementNot }, { "if", FcElementIf }, + { "floor", FcElementFloor }, + { "ceil", FcElementCeil }, + { "round", FcElementRound }, + { "trunc", FcElementTrunc }, - { 0, FcElementUnknown } + { 0, 0 } }; int i; @@ -702,6 +723,7 @@ static FcChar8 ** FcConfigSaveAttr (const XML_Char **attr) { + int n; int slen; int i; FcChar8 **new; @@ -712,6 +734,7 @@ slen = 0; for (i = 0; attr[i]; i++) slen += strlen (attr[i]) + 1; + n = i; new = malloc ((i + 1) * sizeof (FcChar8 *) + slen); if (!new) return 0; @@ -1283,8 +1306,17 @@ return expr; } +/* + * This builds a tree of binary operations. Note + * that every operator is defined so that if only + * a single operand is contained, the value of the + * whole expression is the value of the operand. + * + * This code reduces in that case to returning that + * operand. + */ static FcExpr * -FcPopExprs (FcConfigParse *parse, FcOp op) +FcPopBinary (FcConfigParse *parse, FcOp op) { FcExpr *left, *expr = 0, *new; @@ -1309,9 +1341,39 @@ } static void -FcParseExpr (FcConfigParse *parse, FcOp op) +FcParseBinary (FcConfigParse *parse, FcOp op) { - FcExpr *expr = FcPopExprs (parse, op); + FcExpr *expr = FcPopBinary (parse, op); + if (expr) + FcVStackPushExpr (parse, FcVStackExpr, expr); +} + +/* + * This builds a a unary operator, it consumes only + * a single operand + */ + +static FcExpr * +FcPopUnary (FcConfigParse *parse, FcOp op) +{ + FcExpr *operand, *new = 0; + + if ((operand = FcPopExpr (parse))) + { + new = FcExprCreateOp (operand, op, 0); + if (!new) + { + FcExprDestroy (operand); + FcConfigMessage (parse, FcSevereError, "out of memory"); + } + } + return new; +} + +static void +FcParseUnary (FcConfigParse *parse, FcOp op) +{ + FcExpr *expr = FcPopUnary (parse, op); if (expr) FcVStackPushExpr (parse, FcVStackExpr, expr); } @@ -1440,7 +1502,7 @@ return; } } - expr = FcPopExprs (parse, FcOpComma); + expr = FcPopBinary (parse, FcOpComma); if (!expr) { FcConfigMessage (parse, FcSevereWarning, "missing test expression"); @@ -1510,13 +1572,15 @@ binding = FcValueBindingWeak; else if (!strcmp ((char *) binding_string, "strong")) binding = FcValueBindingStrong; + else if (!strcmp ((char *) binding_string, "same")) + binding = FcValueBindingSame; else { FcConfigMessage (parse, FcSevereWarning, "invalid edit binding \"%s\"", binding_string); return; } } - expr = FcPopExprs (parse, FcOpComma); + expr = FcPopBinary (parse, FcOpComma); edit = FcEditCreate ((char *) FcStrCopy (name), mode, expr, binding); if (!edit) { @@ -1595,8 +1659,35 @@ FcConfigMessage (parse, FcSevereError, "out of memory"); break; } - if (!FcConfigAddDir (parse->config, data)) - FcConfigMessage (parse, FcSevereError, "out of memory"); +#ifdef _WIN32 + if (strcmp (data, "WINDOWSFONTDIR") == 0) + { + int rc; + FcStrFree (data); + data = malloc (1000); + if (!data) + { + FcConfigMessage (parse, FcSevereError, "out of memory"); + break; + } + FcMemAlloc (FC_MEM_STRING, 1000); + rc = GetWindowsDirectory (data, 800); + if (rc == 0 || rc > 800) + { + FcConfigMessage (parse, FcSevereError, "GetWindowsDirectory failed"); + FcStrFree (data); + break; + } + if (data [strlen (data) - 1] != '\\') + strcat (data, "\\"); + strcat (data, "fonts"); + } +#endif + if (!FcStrUsesHome (data) || FcConfigHome ()) + { + if (!FcConfigAddDir (parse->config, data)) + FcConfigMessage (parse, FcSevereError, "out of memory"); + } FcStrFree (data); break; case FcElementCache: @@ -1606,8 +1697,11 @@ FcConfigMessage (parse, FcSevereError, "out of memory"); break; } - if (!FcConfigSetCache (parse->config, data)) - FcConfigMessage (parse, FcSevereError, "out of memory"); + if (!FcStrUsesHome (data) || FcConfigHome ()) + { + if (!FcConfigSetCache (parse->config, data)) + FcConfigMessage (parse, FcSevereError, "out of memory"); + } FcStrFree (data); break; case FcElementInclude: @@ -1675,52 +1769,64 @@ FcParseString (parse, FcVStackConstant); break; case FcElementOr: - FcParseExpr (parse, FcOpOr); + FcParseBinary (parse, FcOpOr); break; case FcElementAnd: - FcParseExpr (parse, FcOpAnd); + FcParseBinary (parse, FcOpAnd); break; case FcElementEq: - FcParseExpr (parse, FcOpEqual); + FcParseBinary (parse, FcOpEqual); break; case FcElementNotEq: - FcParseExpr (parse, FcOpNotEqual); + FcParseBinary (parse, FcOpNotEqual); break; case FcElementLess: - FcParseExpr (parse, FcOpLess); + FcParseBinary (parse, FcOpLess); break; case FcElementLessEq: - FcParseExpr (parse, FcOpLessEqual); + FcParseBinary (parse, FcOpLessEqual); break; case FcElementMore: - FcParseExpr (parse, FcOpMore); + FcParseBinary (parse, FcOpMore); break; case FcElementMoreEq: - FcParseExpr (parse, FcOpMoreEqual); + FcParseBinary (parse, FcOpMoreEqual); break; case FcElementContains: - FcParseExpr (parse, FcOpContains); + FcParseBinary (parse, FcOpContains); break; case FcElementNotContains: - FcParseExpr (parse, FcOpNotContains); + FcParseBinary (parse, FcOpNotContains); break; case FcElementPlus: - FcParseExpr (parse, FcOpPlus); + FcParseBinary (parse, FcOpPlus); break; case FcElementMinus: - FcParseExpr (parse, FcOpMinus); + FcParseBinary (parse, FcOpMinus); break; case FcElementTimes: - FcParseExpr (parse, FcOpTimes); + FcParseBinary (parse, FcOpTimes); break; case FcElementDivide: - FcParseExpr (parse, FcOpDivide); + FcParseBinary (parse, FcOpDivide); break; case FcElementNot: - FcParseExpr (parse, FcOpNot); + FcParseUnary (parse, FcOpNot); break; case FcElementIf: - FcParseExpr (parse, FcOpQuest); + FcParseBinary (parse, FcOpQuest); + break; + case FcElementFloor: + FcParseUnary (parse, FcOpFloor); + break; + case FcElementCeil: + FcParseUnary (parse, FcOpCeil); + break; + case FcElementRound: + FcParseUnary (parse, FcOpRound); + break; + case FcElementTrunc: + FcParseUnary (parse, FcOpTrunc); break; case FcElementUnknown: break; --- xc/lib/fontconfig/Imakefile 2004-01-07 09:50:05.000000000 +0100 +++ xc-fontconfig/lib/fontconfig/Imakefile 2004-01-07 09:55:24.000000000 +0100 @@ -47,7 +47,7 @@ InstallManPage(fontconfig,$(LIBMANDIR)) DependTarget() -FONTCONFIG_VERSION=2.1.0 +FONTCONFIG_VERSION=2.2.1 #ifndef FontconfigFontsConfDir #if NothingOutsideProjectRoot