source: trunk/poppler/fontconfig-2.3.2-os2/src/fcint.h @ 2

Last change on this file since 2 was 2, checked in by Eugene Romanenko, 15 years ago

First import

File size: 17.7 KB
Line 
1/*
2 * $RCSId: xc/lib/fontconfig/src/fcint.h,v 1.27 2002/08/31 22:17:32 keithp Exp $
3 *
4 * Copyright © 2000 Keith Packard
5 *
6 * Permission to use, copy, modify, distribute, and sell this software and its
7 * documentation for any purpose is hereby granted without fee, provided that
8 * the above copyright notice appear in all copies and that both that
9 * copyright notice and this permission notice appear in supporting
10 * documentation, and that the name of Keith Packard not be used in
11 * advertising or publicity pertaining to distribution of the software without
12 * specific, written prior permission.  Keith Packard makes no
13 * representations about the suitability of this software for any purpose.  It
14 * is provided "as is" without express or implied warranty.
15 *
16 * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
17 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
18 * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
19 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
20 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
21 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
22 * PERFORMANCE OF THIS SOFTWARE.
23 */
24
25#ifndef _FCINT_H_
26#define _FCINT_H_
27
28#include <stdlib.h>
29#include <stdio.h>
30#include <string.h>
31#include <ctype.h>
32#include <errno.h>
33#include <unistd.h>
34#include <sys/types.h>
35#include <sys/stat.h>
36#include <time.h>
37#include <fontconfig/fontconfig.h>
38#include <fontconfig/fcprivate.h>
39#include <fontconfig/fcfreetype.h>
40#ifdef HAVE_CONFIG_H
41#include <config.h>
42#endif
43
44#define HAVE_FT_GET_BDF_PROPERTY 1
45#define HAVE_FT_GET_PS_FONT_INFO 1
46#define HAVE_FT_GET_NEXT_CHAR 1
47
48#ifdef __OS2__
49// Don't print anything on OS/2
50// You may ask: why?
51// Well, I compile FontConfig into a DLL and when that DLL is loaded
52// and unloaded multiple times into a process, it leaked process memory.
53// Removing the printf()'s cured it, so, well, here is a dirty hack to
54// remove all FontConfig printf()'s.
55#define setbuf(...)
56#define printf(...)
57#endif
58
59typedef struct _FcSymbolic {
60    const char  *name;
61    int         value;
62} FcSymbolic;
63
64#ifndef FC_CONFIG_PATH
65#define FC_CONFIG_PATH "fonts.conf"
66#endif
67
68#define FC_FONT_FILE_INVALID    ((FcChar8 *) ".")
69#define FC_FONT_FILE_DIR        ((FcChar8 *) ".dir")
70
71#if defined(_WIN32) || defined(__OS2__)
72#define FC_SEARCH_PATH_SEPARATOR ';'
73#else
74#define FC_SEARCH_PATH_SEPARATOR ':'
75#endif
76
77#define FC_DBG_MATCH    1
78#define FC_DBG_MATCHV   2
79#define FC_DBG_EDIT     4
80#define FC_DBG_FONTSET  8
81#define FC_DBG_CACHE    16
82#define FC_DBG_CACHEV   32
83#define FC_DBG_PARSE    64
84#define FC_DBG_SCAN     128
85#define FC_DBG_SCANV    256
86#define FC_DBG_MEMORY   512
87#define FC_DBG_CONFIG   1024
88
89#define FC_MEM_CHARSET      0
90#define FC_MEM_CHARLEAF     1
91#define FC_MEM_FONTSET      2
92#define FC_MEM_FONTPTR      3
93#define FC_MEM_OBJECTSET    4
94#define FC_MEM_OBJECTPTR    5
95#define FC_MEM_MATRIX       6
96#define FC_MEM_PATTERN      7
97#define FC_MEM_PATELT       8
98#define FC_MEM_VALLIST      9
99#define FC_MEM_SUBSTATE     10
100#define FC_MEM_STRING       11
101#define FC_MEM_LISTBUCK     12
102#define FC_MEM_STRSET       13
103#define FC_MEM_STRLIST      14
104#define FC_MEM_CONFIG       15
105#define FC_MEM_LANGSET      16
106#define FC_MEM_ATOMIC       17
107#define FC_MEM_BLANKS       18
108#define FC_MEM_CACHE        19
109#define FC_MEM_STRBUF       20
110#define FC_MEM_SUBST        21
111#define FC_MEM_OBJECTTYPE   22
112#define FC_MEM_CONSTANT     23
113#define FC_MEM_TEST         24
114#define FC_MEM_EXPR         25
115#define FC_MEM_VSTACK       26
116#define FC_MEM_ATTR         27
117#define FC_MEM_PSTACK       28
118#define FC_MEM_STATICSTR    29
119
120#define FC_MEM_NUM          30
121
122typedef enum _FcValueBinding {
123    FcValueBindingWeak, FcValueBindingStrong, FcValueBindingSame
124} FcValueBinding;
125
126typedef struct _FcValueList {
127    struct _FcValueList    *next;
128    FcValue                 value;
129    FcValueBinding          binding;
130} FcValueList;
131
132typedef struct _FcPatternElt {
133    const char      *object;
134    FcValueList     *values;
135} FcPatternElt;
136
137
138struct _FcPattern {
139    int             num;
140    int             size;
141    FcPatternElt    *elts;
142    int             ref;
143};
144
145typedef enum _FcOp {
146    FcOpInteger, FcOpDouble, FcOpString, FcOpMatrix, FcOpBool, FcOpCharSet, 
147    FcOpNil,
148    FcOpField, FcOpConst,
149    FcOpAssign, FcOpAssignReplace, 
150    FcOpPrependFirst, FcOpPrepend, FcOpAppend, FcOpAppendLast,
151    FcOpQuest,
152    FcOpOr, FcOpAnd, FcOpEqual, FcOpNotEqual, 
153    FcOpContains, FcOpListing, FcOpNotContains,
154    FcOpLess, FcOpLessEqual, FcOpMore, FcOpMoreEqual,
155    FcOpPlus, FcOpMinus, FcOpTimes, FcOpDivide,
156    FcOpNot, FcOpComma, FcOpFloor, FcOpCeil, FcOpRound, FcOpTrunc,
157    FcOpInvalid
158} FcOp;
159
160typedef struct _FcExpr {
161    FcOp   op;
162    union {
163        int         ival;
164        double      dval;
165        FcChar8     *sval;
166        FcMatrix    *mval;
167        FcBool      bval;
168        FcCharSet   *cval;
169        char        *field;
170        FcChar8     *constant;
171        struct {
172            struct _FcExpr *left, *right;
173        } tree;
174    } u;
175} FcExpr;
176
177typedef enum _FcQual {
178    FcQualAny, FcQualAll, FcQualFirst, FcQualNotFirst
179} FcQual;
180
181#define FcMatchDefault  ((FcMatchKind) -1)
182
183typedef struct _FcTest {
184    struct _FcTest      *next;
185    FcMatchKind         kind;
186    FcQual              qual;
187    const char          *field;
188    FcOp                op;
189    FcExpr              *expr;
190} FcTest;
191
192typedef struct _FcEdit {
193    struct _FcEdit *next;
194    const char      *field;
195    FcOp            op;
196    FcExpr          *expr;
197    FcValueBinding  binding;
198} FcEdit;
199
200typedef struct _FcSubst {
201    struct _FcSubst     *next;
202    FcTest              *test;
203    FcEdit              *edit;
204} FcSubst;
205
206typedef struct _FcCharLeaf {
207    FcChar32    map[256/32];
208} FcCharLeaf;
209
210#define FC_REF_CONSTANT     -1
211
212struct _FcCharSet {
213    int             ref;        /* reference count */
214    int             num;        /* size of leaves and numbers arrays */
215    FcCharLeaf      **leaves;
216    FcChar16        *numbers;
217};
218
219struct _FcStrSet {
220    int             ref;        /* reference count */
221    int             num;
222    int             size;
223    FcChar8         **strs;
224};
225
226struct _FcStrList {
227    FcStrSet        *set;
228    int             n;
229};
230
231typedef struct _FcStrBuf {
232    FcChar8 *buf;
233    FcBool  allocated;
234    FcBool  failed;
235    int     len;
236    int     size;
237} FcStrBuf;
238
239/*
240 * To map adobe glyph names to unicode values, a precomputed hash
241 * table is used
242 */
243
244typedef struct _FcGlyphName {
245    FcChar32    ucs;            /* unicode value */
246    FcChar8     name[1];        /* name extends beyond struct */
247} FcGlyphName;
248
249/*
250 * To perform case-insensitive string comparisons, a table
251 * is used which holds three different kinds of folding data.
252 *
253 * The first is a range of upper case values mapping to a range
254 * of their lower case equivalents.  Within each range, the offset
255 * between upper and lower case is constant.
256 *
257 * The second is a range of upper case values which are interleaved
258 * with their lower case equivalents.
259 *
260 * The third is a set of raw unicode values mapping to a list
261 * of unicode values for comparison purposes.  This allows conversion
262 * of ß to "ss" so that SS, ss and ß all match.  A separate array
263 * holds the list of unicode values for each entry.
264 *
265 * These are packed into a single table.  Using a binary search,
266 * the appropriate entry can be located.
267 */
268
269#define FC_CASE_FOLD_RANGE          0
270#define FC_CASE_FOLD_EVEN_ODD       1
271#define FC_CASE_FOLD_FULL           2
272
273typedef struct _FcCaseFold {
274    FcChar32    upper;
275    FcChar16    method : 2;
276    FcChar16    count : 14;
277    short       offset;     /* lower - upper for RANGE, table id for FULL */
278} FcCaseFold;
279
280#define FC_MAX_FILE_LEN     4096
281
282/*
283 * The per-user ~/.fonts.cache-<version> file is loaded into
284 * this data structure.  Each directory gets a substructure
285 * which is validated by comparing the directory timestamp with
286 * that saved in the cache.  When valid, the entire directory cache
287 * can be immediately loaded without reading the directory.  Otherwise,
288 * the files are checked individually; updated files are loaded into the
289 * cache which is then rewritten to the users home directory
290 */
291
292#define FC_GLOBAL_CACHE_DIR_HASH_SIZE       37
293#define FC_GLOBAL_CACHE_FILE_HASH_SIZE      67
294
295typedef struct _FcGlobalCacheInfo {
296    unsigned int                hash;
297    FcChar8                     *file;
298    time_t                      time;
299    FcBool                      referenced;
300} FcGlobalCacheInfo;
301
302typedef struct _FcGlobalCacheFile {
303    struct _FcGlobalCacheFile   *next;
304    FcGlobalCacheInfo           info;
305    int                         id;
306    FcChar8                     *name;
307} FcGlobalCacheFile;
308
309typedef struct _FcGlobalCacheDir FcGlobalCacheDir;
310
311typedef struct _FcGlobalCacheSubdir {
312    struct _FcGlobalCacheSubdir *next;
313    FcGlobalCacheDir            *ent;
314} FcGlobalCacheSubdir;
315
316struct _FcGlobalCacheDir {
317    struct _FcGlobalCacheDir    *next;
318    FcGlobalCacheInfo           info;
319    int                         len;
320    FcGlobalCacheFile           *ents[FC_GLOBAL_CACHE_FILE_HASH_SIZE];
321    FcGlobalCacheSubdir         *subdirs;
322};
323
324typedef struct _FcGlobalCache {
325    FcGlobalCacheDir            *ents[FC_GLOBAL_CACHE_DIR_HASH_SIZE];
326    FcBool                      updated;
327    FcBool                      broken;
328    int                         entries;
329    int                         referenced;
330} FcGlobalCache;
331
332struct _FcAtomic {
333    FcChar8     *file;          /* original file name */
334    FcChar8     *new;           /* temp file name -- write data here */
335    FcChar8     *lck;           /* lockfile name (used for locking) */
336    FcChar8     *tmp;           /* tmpfile name (used for locking) */
337};
338
339struct _FcBlanks {
340    int         nblank;
341    int         sblank;
342    FcChar32    *blanks;
343};
344
345struct _FcConfig {
346    /*
347     * File names loaded from the configuration -- saved here as the
348     * cache file must be consulted before the directories are scanned,
349     * and those directives may occur in any order
350     */
351    FcStrSet    *configDirs;        /* directories to scan for fonts */
352    FcChar8     *cache;             /* name of per-user cache file */
353    /*
354     * Set of allowed blank chars -- used to
355     * trim fonts of bogus glyphs
356     */
357    FcBlanks    *blanks;
358    /*
359     * List of directories containing fonts,
360     * built by recursively scanning the set
361     * of configured directories
362     */
363    FcStrSet    *fontDirs;
364    /*
365     * Names of all of the configuration files used
366     * to create this configuration
367     */
368    FcStrSet    *configFiles;       /* config files loaded */
369    /*
370     * Substitution instructions for patterns and fonts;
371     * maxObjects is used to allocate appropriate intermediate storage
372     * while performing a whole set of substitutions
373     */
374    FcSubst     *substPattern;      /* substitutions for patterns */
375    FcSubst     *substFont;         /* substitutions for fonts */
376    int         maxObjects;         /* maximum number of tests in all substs */
377    /*
378     * List of patterns used to control font file selection
379     */
380    FcStrSet    *acceptGlobs;
381    FcStrSet    *rejectGlobs;
382    FcFontSet   *acceptPatterns;
383    FcFontSet   *rejectPatterns;
384    /*
385     * The set of fonts loaded from the listed directories; the
386     * order within the set does not determine the font selection,
387     * except in the case of identical matches in which case earlier fonts
388     * match preferrentially
389     */
390    FcFontSet   *fonts[FcSetApplication + 1];
391    /*
392     * Fontconfig can periodically rescan the system configuration
393     * and font directories.  This rescanning occurs when font
394     * listing requests are made, but no more often than rescanInterval
395     * seconds apart.
396     */
397    time_t      rescanTime;         /* last time information was scanned */
398    int         rescanInterval;     /* interval between scans */
399};
400 
401extern FcConfig *_fcConfig;
402
403typedef struct _FcCharMap FcCharMap;
404
405/* fcblanks.c */
406
407/* fccache.c */
408
409FcGlobalCache *
410FcGlobalCacheCreate (void);
411
412void
413FcGlobalCacheDestroy (FcGlobalCache *cache);
414
415FcBool
416FcGlobalCacheCheckTime (const FcChar8*file, FcGlobalCacheInfo *info);
417
418void
419FcGlobalCacheReferenced (FcGlobalCache      *cache,
420                         FcGlobalCacheInfo  *info);
421
422void
423FcGlobalCacheReferenceSubdir (FcGlobalCache *cache,
424                              const FcChar8 *dir);
425
426FcGlobalCacheDir *
427FcGlobalCacheDirGet (FcGlobalCache  *cache,
428                     const FcChar8  *dir,
429                     int            len,
430                     FcBool         create_missing);
431
432FcBool
433FcGlobalCacheScanDir (FcFontSet         *set,
434                      FcStrSet          *dirs,
435                      FcGlobalCache     *cache,
436                      const FcChar8     *dir,
437                      FcConfig          *config);
438
439FcGlobalCacheFile *
440FcGlobalCacheFileGet (FcGlobalCache *cache,
441                      const FcChar8 *file,
442                      int           id,
443                      int           *count);
444
445
446void
447FcGlobalCacheLoad (FcGlobalCache    *cache,
448                   const FcChar8    *cache_file);
449
450FcBool
451FcGlobalCacheUpdate (FcGlobalCache  *cache,
452                     const FcChar8  *file,
453                     int            id,
454                     const FcChar8  *name);
455
456FcBool
457FcGlobalCacheSave (FcGlobalCache    *cache,
458                   const FcChar8    *cache_file);
459
460FcBool
461FcDirCacheReadDir (FcFontSet        *set, 
462                   FcStrSet         *dirs,
463                   const FcChar8    *dir,
464                   FcConfig         *config);
465
466FcBool
467FcDirCacheWriteDir (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir);
468   
469/* fccfg.c */
470
471FcBool
472FcConfigAddConfigDir (FcConfig      *config,
473                      const FcChar8 *d);
474
475FcBool
476FcConfigAddFontDir (FcConfig        *config,
477                    const FcChar8   *d);
478
479FcBool
480FcConfigAddDir (FcConfig        *config,
481                const FcChar8   *d);
482
483FcBool
484FcConfigAddConfigFile (FcConfig         *config,
485                       const FcChar8    *f);
486
487FcBool
488FcConfigSetCache (FcConfig      *config,
489                  const FcChar8 *c);
490
491FcBool
492FcConfigAddBlank (FcConfig      *config,
493                  FcChar32      blank);
494
495FcBool
496FcConfigAddEdit (FcConfig       *config,
497                 FcTest         *test,
498                 FcEdit         *edit,
499                 FcMatchKind    kind);
500
501void
502FcConfigSetFonts (FcConfig      *config,
503                  FcFontSet     *fonts,
504                  FcSetName     set);
505
506FcBool
507FcConfigCompareValue (const FcValue m,
508                      FcOp          op,
509                      const FcValue v);
510
511FcBool
512FcConfigGlobAdd (FcConfig       *config,
513                 const FcChar8  *glob,
514                 FcBool         accept);
515
516FcBool
517FcConfigAcceptFilename (FcConfig        *config,
518                        const FcChar8   *filename);
519
520FcBool
521FcConfigPatternsAdd (FcConfig   *config,
522                     FcPattern  *pattern,
523                     FcBool     accept);
524
525FcBool
526FcConfigAcceptFont (FcConfig        *config,
527                    const FcPattern *font);
528
529/* fccharset.c */
530FcCharSet *
531FcCharSetFreeze (FcCharSet *cs);
532
533void
534FcCharSetThawAll (void);
535
536FcBool
537FcNameUnparseCharSet (FcStrBuf *buf, const FcCharSet *c);
538
539FcCharSet *
540FcNameParseCharSet (FcChar8 *string);
541
542FcCharLeaf *
543FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4);
544
545/* fcdbg.c */
546void
547FcValueListPrint (const FcValueList *l);
548
549void
550FcLangSetPrint (const FcLangSet *ls);
551
552void
553FcOpPrint (FcOp op);
554
555void
556FcTestPrint (const FcTest *test);
557
558void
559FcExprPrint (const FcExpr *expr);
560
561void
562FcEditPrint (const FcEdit *edit);
563
564void
565FcSubstPrint (const FcSubst *subst);
566
567int
568FcDebug (void);
569
570/* fcdir.c */
571
572FcBool
573FcFileIsDir (const FcChar8 *file);
574
575FcBool
576FcFileScanConfig (FcFontSet     *set,
577                  FcStrSet      *dirs,
578                  FcFileCache   *cache,
579                  FcBlanks      *blanks,
580                  const FcChar8 *file,
581                  FcBool        force,
582                  FcConfig      *config);
583
584FcBool
585FcDirScanConfig (FcFontSet      *set,
586                 FcStrSet       *dirs,
587                 FcFileCache    *cache,
588                 FcBlanks       *blanks,
589                 const FcChar8  *dir,
590                 FcBool         force,
591                 FcConfig       *config);
592
593/* fcfont.c */
594int
595FcFontDebug (void);
596   
597/* fcfreetype.c */
598FcBool
599FcFreeTypeIsExclusiveLang (const FcChar8  *lang);
600
601FcBool
602FcFreeTypeHasLang (FcPattern *pattern, const FcChar8 *lang);
603
604FcChar32
605FcFreeTypeUcs4ToPrivate (FcChar32 ucs4, const FcCharMap *map);
606
607FcChar32
608FcFreeTypePrivateToUcs4 (FcChar32 private, const FcCharMap *map);
609
610const FcCharMap *
611FcFreeTypeGetPrivateMap (FT_Encoding encoding);
612   
613/* fcfs.c */
614/* fcgram.y */
615int
616FcConfigparse (void);
617
618int
619FcConfigwrap (void);
620   
621void
622FcConfigerror (char *fmt, ...);
623   
624char *
625FcConfigSaveField (const char *field);
626
627void
628FcTestDestroy (FcTest *test);
629
630FcExpr *
631FcExprCreateInteger (int i);
632
633FcExpr *
634FcExprCreateDouble (double d);
635
636FcExpr *
637FcExprCreateString (const FcChar8 *s);
638
639FcExpr *
640FcExprCreateMatrix (const FcMatrix *m);
641
642FcExpr *
643FcExprCreateBool (FcBool b);
644
645FcExpr *
646FcExprCreateNil (void);
647
648FcExpr *
649FcExprCreateField (const char *field);
650
651FcExpr *
652FcExprCreateConst (const FcChar8 *constant);
653
654FcExpr *
655FcExprCreateOp (FcExpr *left, FcOp op, FcExpr *right);
656
657void
658FcExprDestroy (FcExpr *e);
659
660void
661FcEditDestroy (FcEdit *e);
662
663/* fcinit.c */
664
665void
666FcMemReport (void);
667
668void
669FcMemAlloc (int kind, int size);
670
671void
672FcMemFree (int kind, int size);
673
674/* fclang.c */
675FcLangSet *
676FcFreeTypeLangSet (const FcCharSet  *charset, 
677                   const FcChar8    *exclusiveLang);
678
679FcLangResult
680FcLangCompare (const FcChar8 *s1, const FcChar8 *s2);
681   
682const FcCharSet *
683FcCharSetForLang (const FcChar8 *lang);
684
685FcLangSet *
686FcLangSetPromote (const FcChar8 *lang);
687
688FcLangSet *
689FcNameParseLangSet (const FcChar8 *string);
690
691FcBool
692FcNameUnparseLangSet (FcStrBuf *buf, const FcLangSet *ls);
693
694/* fclist.c */
695
696FcBool
697FcListPatternMatchAny (const FcPattern *p,
698                       const FcPattern *font);
699
700/* fcmatch.c */
701
702/* fcname.c */
703
704FcBool
705FcNameBool (const FcChar8 *v, FcBool *result);
706
707/* fcpat.c */
708void
709FcValueListDestroy (FcValueList *l);
710   
711FcPatternElt *
712FcPatternFindElt (const FcPattern *p, const char *object);
713
714FcPatternElt *
715FcPatternInsertElt (FcPattern *p, const char *object);
716
717FcBool
718FcPatternAddWithBinding  (FcPattern         *p,
719                          const char        *object,
720                          FcValue           value,
721                          FcValueBinding    binding,
722                          FcBool            append);
723
724FcPattern *
725FcPatternFreeze (FcPattern *p);
726
727void
728FcPatternThawAll (void);
729
730FcBool
731FcPatternAppend (FcPattern *p, FcPattern *s);
732
733const char *
734FcObjectStaticName (const char *name);
735
736void
737FcObjectStaticNameListInit();
738
739void
740FcObjectStaticNameListFini();
741
742
743/* fcrender.c */
744
745/* fcmatrix.c */
746
747extern const FcMatrix    FcIdentityMatrix;
748
749void
750FcMatrixFree (FcMatrix *mat);
751
752/* fcstr.c */
753FcChar8 *
754FcStrPlus (const FcChar8 *s1, const FcChar8 *s2);
755   
756void
757FcStrFree (FcChar8 *s);
758
759void
760FcStrBufInit (FcStrBuf *buf, FcChar8 *init, int size);
761
762void
763FcStrBufDestroy (FcStrBuf *buf);
764
765FcChar8 *
766FcStrBufDone (FcStrBuf *buf);
767
768FcBool
769FcStrBufChar (FcStrBuf *buf, FcChar8 c);
770
771FcBool
772FcStrBufString (FcStrBuf *buf, const FcChar8 *s);
773
774FcBool
775FcStrBufData (FcStrBuf *buf, const FcChar8 *s, int len);
776
777int
778FcStrCmpIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
779
780const FcChar8 *
781FcStrContainsIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2);
782
783const FcChar8 *
784FcStrContainsIgnoreCase (const FcChar8 *s1, const FcChar8 *s2);
785
786FcBool
787FcStrUsesHome (const FcChar8 *s);
788
789FcChar8 *
790FcStrLastSlash (const FcChar8  *path);
791
792FcChar32
793FcStrHashIgnoreCase (const FcChar8 *s);
794
795#endif /* _FC_INT_H_ */
Note: See TracBrowser for help on using the repository browser.