diff options
Diffstat (limited to 'pango/mini-xft')
26 files changed, 9208 insertions, 0 deletions
diff --git a/pango/mini-xft/Makefile.am b/pango/mini-xft/Makefile.am new file mode 100644 index 00000000..b8dfe6fe --- /dev/null +++ b/pango/mini-xft/Makefile.am @@ -0,0 +1,53 @@ +## Process this file with automake to produce Makefile.in + +INCLUDES = \ + -DSYSCONFDIR=\"$(sysconfdir)\" \ + -DLIBDIR=\"$(libdir)\" \ + $(FREETYPE_CFLAGS) \ + -I$(top_srcdir) + +LDADDS = @STRIP_BEGIN@ \ + @GLIB_LIBS@ \ + -lm \ +@STRIP_END@ + +noinst_LTLIBRARIES = libmini-xft.la + +minixftgram.c: minixftgram.y + $(YACC) -d minixftgram.y + sed 's/yy/MiniXftConfig/g' y.tab.c | sed 's/__REALLY_YY__/yy/' > minixftgram.c && $(RM) y.tab.c + sed 's/yy/MiniXftConfig/g' y.tab.h | sed 's/__REALLY_YY__/yy/' > minixftgram.h && $(RM) y.tab.h + +minixftlex.c: minixftlex.l + $(LEX) minixftlex.l + sed 's/yy/MiniXftConfig/g' lex.yy.c | sed 's/__REALLY_YY__/yy/' > minixftlex.c && $(RM) lex.yy.c + +libmini_xft_la_SOURCES = \ + Xemu.h \ + MiniXft.h \ + MiniXftFreetype.h \ + minixftgram.h \ + minixftint.h \ + minixftgram.c \ + minixftlex.c \ + minixftdbg.c \ + minixftfont.c \ + minixftfs.c \ + minixftlist.c \ + minixftname.c \ + minixftcache.c \ + minixftdir.c \ + minixftfreetype.c \ + minixftmatch.c \ + minixftpat.c \ + minixftcfg.c \ + minixftdpy.c \ + minixftinit.c \ + minixftmatrix.c \ + minixftstr.c + +EXTRA_DIST = \ + minixftgram.y \ + minixftlex.l \ + README + diff --git a/pango/mini-xft/MiniXft.h b/pango/mini-xft/MiniXft.h new file mode 100644 index 00000000..31cfb1cf --- /dev/null +++ b/pango/mini-xft/MiniXft.h @@ -0,0 +1,340 @@ +/* + * $XFree86: xc/lib/MiniXft/MiniXft.h,v 1.19 2001/04/29 03:21:17 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _XFT_H_ +#define _XFT_H_ + +#include "Xemu.h" + +#include <stdarg.h> + +typedef unsigned char MiniXftChar8; +typedef unsigned short MiniXftChar16; +typedef unsigned int MiniXftChar32; + +#define XFT_FAMILY "family" /* String */ +#define XFT_STYLE "style" /* String */ +#define XFT_SLANT "slant" /* Int */ +#define XFT_WEIGHT "weight" /* Int */ +#define XFT_SIZE "size" /* Double */ +#define XFT_PIXEL_SIZE "pixelsize" /* Double */ +#define XFT_ENCODING "encoding" /* String */ +#define XFT_SPACING "spacing" /* Int */ +#define XFT_FOUNDRY "foundry" /* String */ +#define XFT_CORE "core" /* Bool */ +#define XFT_ANTIALIAS "antialias" /* Bool */ +#define XFT_XLFD "xlfd" /* String */ +#define XFT_FILE "file" /* String */ +#define XFT_INDEX "index" /* Int */ +#define XFT_RASTERIZER "rasterizer"/* String */ +#define XFT_OUTLINE "outline" /* Bool */ +#define XFT_SCALABLE "scalable" /* Bool */ +#define XFT_RGBA "rgba" /* Int */ + +/* defaults from resources */ +#define XFT_SCALE "scale" /* double */ +#define XFT_RENDER "render" /* Bool */ +#define XFT_MINSPACE "minspace" /* Bool use minimum line spacing */ +#define XFT_DPI "dpi" /* double */ + +/* specific to FreeType rasterizer */ +#define XFT_CHAR_WIDTH "charwidth" /* Int */ +#define XFT_CHAR_HEIGHT "charheight"/* Int */ +#define XFT_MATRIX "matrix" /* MiniXftMatrix */ + +#define XFT_WEIGHT_LIGHT 0 +#define XFT_WEIGHT_MEDIUM 100 +#define XFT_WEIGHT_DEMIBOLD 180 +#define XFT_WEIGHT_BOLD 200 +#define XFT_WEIGHT_BLACK 210 + +#define XFT_SLANT_ROMAN 0 +#define XFT_SLANT_ITALIC 100 +#define XFT_SLANT_OBLIQUE 110 + +#define XFT_PROPORTIONAL 0 +#define XFT_MONO 100 +#define XFT_CHARCELL 110 + +#define XFT_RGBA_NONE 0 +#define XFT_RGBA_RGB 1 +#define XFT_RGBA_BGR 2 +#define XFT_RGBA_VRGB 3 +#define XFT_RGBA_VBGR 4 + +typedef enum _MiniXftType { + MiniXftTypeVoid, + MiniXftTypeInteger, + MiniXftTypeDouble, + MiniXftTypeString, + MiniXftTypeBool, + MiniXftTypeMatrix +} MiniXftType; + +typedef struct _MiniXftMatrix { + double xx, xy, yx, yy; +} MiniXftMatrix; + +#define MiniXftMatrixInit(m) ((m)->xx = (m)->yy = 1, \ + (m)->xy = (m)->yx = 0) + +typedef enum _MiniXftResult { + MiniXftResultMatch, MiniXftResultNoMatch, MiniXftResultTypeMismatch, MiniXftResultNoId +} MiniXftResult; + +typedef struct _MiniXftValue { + MiniXftType type; + union { + char *s; + int i; + Bool b; + double d; + MiniXftMatrix *m; + } u; +} MiniXftValue; + +typedef struct _MiniXftValueList { + struct _MiniXftValueList *next; + MiniXftValue value; +} MiniXftValueList; + +typedef struct _MiniXftPatternElt { + const char *object; + MiniXftValueList *values; +} MiniXftPatternElt; + +typedef struct _MiniXftPattern { + int num; + int size; + MiniXftPatternElt *elts; +} MiniXftPattern; + +typedef struct _MiniXftFontSet { + int nfont; + int sfont; + MiniXftPattern **fonts; +} MiniXftFontSet; + +typedef struct _MiniXftObjectSet { + int nobject; + int sobject; + const char **objects; +} MiniXftObjectSet; + +_XFUNCPROTOBEGIN + +/* xftcfg.c */ +Bool +MiniXftConfigSubstitute (MiniXftPattern *p); + +/* xftdbg.c */ +void +MiniXftValuePrint (MiniXftValue v); + +void +MiniXftValueListPrint (MiniXftValueList *l); + +void +MiniXftPatternPrint (MiniXftPattern *p); + +void +MiniXftFontSetPrint (MiniXftFontSet *s); + +/* xftdir.c */ +/* xftdpy.c */ +void +MiniXftSetDPI (double dpi); + +Bool +MiniXftDefaultHasRender (Display *dpy); + +Bool +MiniXftDefaultSet (Display *dpy, MiniXftPattern *defaults); + +void +MiniXftDefaultSubstitute (Display *dpy, int screen, MiniXftPattern *pattern); + +/* xftfont.c */ +MiniXftPattern * +MiniXftFontMatch (Display *dpy, int screen, MiniXftPattern *pattern, MiniXftResult *result); + +/* xftfreetype.c */ +/* xftfs.c */ + +MiniXftFontSet * +MiniXftFontSetCreate (void); + +void +MiniXftFontSetDestroy (MiniXftFontSet *s); + +Bool +MiniXftFontSetAdd (MiniXftFontSet *s, MiniXftPattern *font); + +/* xftglyphs.c */ +/* see MiniXftFreetype.h */ + +/* xftgram.y */ + +/* xftinit.c */ +extern MiniXftFontSet *_MiniXftFontSet; + +Bool +MiniXftInit (char *config); + +/* xftlex.l */ + +/* xftlist.c */ +MiniXftObjectSet * +MiniXftObjectSetCreate (void); + +Bool +MiniXftObjectSetAdd (MiniXftObjectSet *os, const char *object); + +void +MiniXftObjectSetDestroy (MiniXftObjectSet *os); + +MiniXftObjectSet * +MiniXftObjectSetVaBuild (const char *first, va_list va); + +MiniXftObjectSet * +MiniXftObjectSetBuild (const char *first, ...); + +MiniXftFontSet * +MiniXftListFontSets (MiniXftFontSet **sets, + int nsets, + MiniXftPattern *p, + MiniXftObjectSet *os); + +MiniXftFontSet * +MiniXftListFontsPatternObjects (Display *dpy, + int screen, + MiniXftPattern *pattern, + MiniXftObjectSet *os); + +MiniXftFontSet * +MiniXftListFonts (Display *dpy, + int screen, + ...); + +/* xftmatch.c */ +MiniXftPattern * +MiniXftFontSetMatch (MiniXftFontSet **sets, + int nsets, + MiniXftPattern *p, + MiniXftResult *result); + +/* xftmatrix.c */ +int +MiniXftMatrixEqual (const MiniXftMatrix *mat1, const MiniXftMatrix *mat2); + +void +MiniXftMatrixMultiply (MiniXftMatrix *result, MiniXftMatrix *a, MiniXftMatrix *b); + +void +MiniXftMatrixRotate (MiniXftMatrix *m, double c, double s); + +void +MiniXftMatrixScale (MiniXftMatrix *m, double sx, double sy); + +void +MiniXftMatrixShear (MiniXftMatrix *m, double sh, double sv); + +/* xftname.c */ +MiniXftPattern * +MiniXftNameParse (const char *name); + +Bool +MiniXftNameUnparse (MiniXftPattern *pat, char *dest, int len); + +/* xftpat.c */ +MiniXftPattern * +MiniXftPatternCreate (void); + +MiniXftPattern * +MiniXftPatternDuplicate (MiniXftPattern *p); + +void +MiniXftValueDestroy (MiniXftValue v); + +void +MiniXftValueListDestroy (MiniXftValueList *l); + +void +MiniXftPatternDestroy (MiniXftPattern *p); + +MiniXftPatternElt * +MiniXftPatternFind (MiniXftPattern *p, const char *object, Bool insert); + +Bool +MiniXftPatternAdd (MiniXftPattern *p, const char *object, MiniXftValue value, Bool append); + +MiniXftResult +MiniXftPatternGet (MiniXftPattern *p, const char *object, int id, MiniXftValue *v); + +Bool +MiniXftPatternDel (MiniXftPattern *p, const char *object); + +Bool +MiniXftPatternAddInteger (MiniXftPattern *p, const char *object, int i); + +Bool +MiniXftPatternAddDouble (MiniXftPattern *p, const char *object, double d); + +Bool +MiniXftPatternAddString (MiniXftPattern *p, const char *object, const char *s); + +Bool +MiniXftPatternAddMatrix (MiniXftPattern *p, const char *object, const MiniXftMatrix *s); + +Bool +MiniXftPatternAddBool (MiniXftPattern *p, const char *object, Bool b); + +MiniXftResult +MiniXftPatternGetInteger (MiniXftPattern *p, const char *object, int n, int *i); + +MiniXftResult +MiniXftPatternGetDouble (MiniXftPattern *p, const char *object, int n, double *d); + +MiniXftResult +MiniXftPatternGetString (MiniXftPattern *p, const char *object, int n, char **s); + +MiniXftResult +MiniXftPatternGetMatrix (MiniXftPattern *p, const char *object, int n, MiniXftMatrix **s); + +MiniXftResult +MiniXftPatternGetBool (MiniXftPattern *p, const char *object, int n, Bool *b); + +MiniXftPattern * +MiniXftPatternVaBuild (MiniXftPattern *orig, va_list va); + +MiniXftPattern * +MiniXftPatternBuild (MiniXftPattern *orig, ...); + +/* xftrender.c */ +/* see MiniXftFreetype.h */ + +/* xftstr.c */ +_XFUNCPROTOEND + +#endif /* _XFT_H_ */ diff --git a/pango/mini-xft/MiniXftFreetype.h b/pango/mini-xft/MiniXftFreetype.h new file mode 100644 index 00000000..a69c6a47 --- /dev/null +++ b/pango/mini-xft/MiniXftFreetype.h @@ -0,0 +1,54 @@ +/* + * $XFree86: xc/lib/MiniXft/MiniXftFreetype.h,v 1.15 2001/03/31 23:07:29 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _XFTFREETYPE_H_ +#define _XFTFREETYPE_H_ + +#include "MiniXft.h" +#include <freetype/freetype.h> + +extern FT_Library _MiniXftFTlibrary; + +_XFUNCPROTOBEGIN + +/* xftdir.c */ +Bool +MiniXftDirScan (MiniXftFontSet *set, const char *dir, Bool force); + +Bool +MiniXftDirSave (MiniXftFontSet *set, const char *dir); + +/* xftfreetype.c */ +MiniXftPattern * +MiniXftFreeTypeQuery (const char *file, int id, int *count); + +Bool +MiniXftInitFtLibrary(void); + +_XFUNCPROTOEND + +#endif /* _XFTFREETYPE_H_ */ + + + diff --git a/pango/mini-xft/README b/pango/mini-xft/README new file mode 100644 index 00000000..11ea3392 --- /dev/null +++ b/pango/mini-xft/README @@ -0,0 +1,14 @@ +This is a copy of the libXft library from the XFree86 cvs server, with +all the X specific parts removed. It is used by pangoft2 to locate +fonts and to handle font aliases in exactly the same way as Xft does. + +In order to not have symbols collide, the following sed scripts were run +on the code: + +for file in xftgram.y xftlex.l xftdir.c xftcache.c xftdpy.c xftfs.c xftname.c xftcfg.c xftfont.c xftinit.c xftlist.c xftpat.c xftdbg.c xftfreetype.c xftmatrix.c xftmatch.c xftstr.c xftgram.h xftint.h ; do + sed s#Xft#MiniXft#g $file | sed s#/X11/MiniXftConfig#/X11/XftConfig#g | sed s/xftint.h/minixftint.h/g | sed s/xftgram.h/minixftgram.h/g> mini-xft/mini$file; +done + +for file in XftFreetype.h Xft.h; do + sed s/Xft/MiniXft/g $file > mini-xft/Mini$file; +done diff --git a/pango/mini-xft/Xemu.h b/pango/mini-xft/Xemu.h new file mode 100644 index 00000000..17d0fd67 --- /dev/null +++ b/pango/mini-xft/Xemu.h @@ -0,0 +1,15 @@ +#ifndef XEMU_H +#define XEMU_H + +#include <glib.h> + +#define _XFUNCPROTOBEGIN G_BEGIN_DECLS +#define _XFUNCPROTOEND G_END_DECLS + +typedef gboolean Bool; +typedef int Display; + +#define False FALSE +#define True TRUE + +#endif /* XEMU_H */ diff --git a/pango/mini-xft/minixftcache.c b/pango/mini-xft/minixftcache.c new file mode 100644 index 00000000..54ec1fd5 --- /dev/null +++ b/pango/mini-xft/minixftcache.c @@ -0,0 +1,608 @@ +/* + * $XFree86: xc/lib/MiniXft/xftcache.c,v 1.2 2001/06/11 22:53:30 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> +#include <string.h> +#include <ctype.h> +#include <errno.h> +#include <sys/types.h> +#include <sys/stat.h> +#include "minixftint.h" + +typedef struct _MiniXftFileCacheEnt { + struct _MiniXftFileCacheEnt *next; + unsigned int hash; + char *file; + int id; + time_t time; + char *name; + Bool referenced; +} MiniXftFileCacheEnt; + +#define HASH_SIZE 509 + +typedef struct _MiniXftFileCache { + MiniXftFileCacheEnt *ents[HASH_SIZE]; + Bool updated; + int entries; + int referenced; +} MiniXftFileCache; + +static MiniXftFileCache _MiniXftFileCache; + +static unsigned int +_MiniXftFileCacheHash (char *string) +{ + unsigned int h = 0; + char c; + + while ((c = *string++)) + h = (h << 1) ^ c; + return h; +} + +char * +MiniXftFileCacheFind (char *file, int id, int *count) +{ + MiniXftFileCache *cache; + unsigned int hash; + char *match; + MiniXftFileCacheEnt *c, *name; + int maxid; + struct stat statb; + + cache = &_MiniXftFileCache; + match = file; + + hash = _MiniXftFileCacheHash (match); + name = 0; + maxid = -1; + for (c = cache->ents[hash % HASH_SIZE]; c; c = c->next) + { + if (c->hash == hash && !strcmp (match, c->file)) + { + if (c->id > maxid) + maxid = c->id; + if (c->id == id) + { + if (stat (file, &statb) < 0) + { + if (_MiniXftFontDebug () & XFT_DBG_CACHE) + printf (" file missing\n"); + return 0; + } + if (statb.st_mtime != c->time) + { + if (_MiniXftFontDebug () & XFT_DBG_CACHE) + printf (" timestamp mismatch (was %d is %d)\n", + (int) c->time, (int) statb.st_mtime); + return 0; + } + if (!c->referenced) + { + cache->referenced++; + c->referenced = True; + } + name = c; + } + } + } + if (!name) + return 0; + *count = maxid + 1; + return name->name; +} + +/* + * Cache file syntax is quite simple: + * + * "file_name" id time "font_name" \n + */ + +static Bool +_MiniXftFileCacheReadString (FILE *f, char *dest, int len) +{ + int c; + Bool escape; + + while ((c = getc (f)) != EOF) + if (c == '"') + break; + if (c == EOF) + return False; + if (len == 0) + return False; + + escape = False; + while ((c = getc (f)) != EOF) + { + if (!escape) + { + switch (c) { + case '"': + *dest++ = '\0'; + return True; + case '\\': + escape = True; + continue; + } + } + if (--len <= 1) + return False; + *dest++ = c; + escape = False; + } + return False; +} + +static Bool +_MiniXftFileCacheReadUlong (FILE *f, unsigned long *dest) +{ + unsigned long t; + int c; + + while ((c = getc (f)) != EOF) + { + if (!isspace (c)) + break; + } + if (c == EOF) + return False; + t = 0; + for (;;) + { + if (c == EOF || isspace (c)) + break; + if (!isdigit (c)) + return False; + t = t * 10 + (c - '0'); + c = getc (f); + } + *dest = t; + return True; +} + +static Bool +_MiniXftFileCacheReadInt (FILE *f, int *dest) +{ + unsigned long t; + Bool ret; + + ret = _MiniXftFileCacheReadUlong (f, &t); + if (ret) + *dest = (int) t; + return ret; +} + +static Bool +_MiniXftFileCacheReadTime (FILE *f, time_t *dest) +{ + unsigned long t; + Bool ret; + + ret = _MiniXftFileCacheReadUlong (f, &t); + if (ret) + *dest = (time_t) t; + return ret; +} + +static Bool +_MiniXftFileCacheAdd (MiniXftFileCache *cache, + char *file, + int id, + time_t time, + char *name, + Bool replace) +{ + MiniXftFileCacheEnt *c; + MiniXftFileCacheEnt **prev, *old; + unsigned int hash; + + if (_MiniXftFontDebug () & XFT_DBG_CACHE) + { + printf ("%s face %s/%d as %s\n", replace ? "Replace" : "Add", + file, id, name); + } + hash = _MiniXftFileCacheHash (file); + for (prev = &cache->ents[hash % HASH_SIZE]; + (old = *prev); + prev = &(*prev)->next) + { + if (old->hash == hash && old->id == id && !strcmp (old->file, file)) + break; + } + if (*prev) + { + if (!replace) + return False; + + old = *prev; + if (old->referenced) + cache->referenced--; + *prev = old->next; + free (old); + cache->entries--; + } + + c = malloc (sizeof (MiniXftFileCacheEnt) + + strlen (file) + 1 + + strlen (name) + 1); + if (!c) + return False; + c->next = *prev; + *prev = c; + c->hash = hash; + c->file = (char *) (c + 1); + c->id = id; + c->name = c->file + strlen (file) + 1; + strcpy (c->file, file); + c->time = time; + c->referenced = replace; + strcpy (c->name, name); + cache->entries++; + return True; +} + +void +MiniXftFileCacheDispose (void) +{ + MiniXftFileCache *cache; + MiniXftFileCacheEnt *c, *next; + int h; + + cache = &_MiniXftFileCache; + + for (h = 0; h < HASH_SIZE; h++) + { + for (c = cache->ents[h]; c; c = next) + { + next = c->next; + free (c); + } + cache->ents[h] = 0; + } + cache->entries = 0; + cache->referenced = 0; + cache->updated = False; +} + +void +MiniXftFileCacheLoad (char *cache_file) +{ + MiniXftFileCache *cache; + FILE *f; + char file[8192]; + int id; + time_t time; + char name[8192]; + + f = fopen (cache_file, "r"); + if (!f) + return; + + cache = &_MiniXftFileCache; + + cache->updated = False; + while (_MiniXftFileCacheReadString (f, file, sizeof (file)) && + _MiniXftFileCacheReadInt (f, &id) && + _MiniXftFileCacheReadTime (f, &time) && + _MiniXftFileCacheReadString (f, name, sizeof (name))) + { + (void) _MiniXftFileCacheAdd (cache, file, id, time, name, False); + } + fclose (f); +} + +Bool +MiniXftFileCacheUpdate (char *file, int id, char *name) +{ + MiniXftFileCache *cache; + char *match; + struct stat statb; + Bool ret; + + cache = &_MiniXftFileCache; + match = file; + + if (stat (file, &statb) < 0) + return False; + ret = _MiniXftFileCacheAdd (cache, match, id, + statb.st_mtime, name, True); + if (ret) + cache->updated = True; + return ret; +} + +static Bool +_MiniXftFileCacheWriteString (FILE *f, char *string) +{ + char c; + + if (putc ('"', f) == EOF) + return False; + while ((c = *string++)) + { + switch (c) { + case '"': + case '\\': + if (putc ('\\', f) == EOF) + return False; + /* fall through */ + default: + if (putc (c, f) == EOF) + return False; + } + } + if (putc ('"', f) == EOF) + return False; + return True; +} + +static Bool +_MiniXftFileCacheWriteUlong (FILE *f, unsigned long t) +{ + int pow; + unsigned long temp, digit; + + temp = t; + pow = 1; + while (temp >= 10) + { + temp /= 10; + pow *= 10; + } + temp = t; + while (pow) + { + digit = temp / pow; + if (putc ((char) digit + '0', f) == EOF) + return False; + temp = temp - pow * digit; + pow = pow / 10; + } + return True; +} + +static Bool +_MiniXftFileCacheWriteInt (FILE *f, int i) +{ + return _MiniXftFileCacheWriteUlong (f, (unsigned long) i); +} + +static Bool +_MiniXftFileCacheWriteTime (FILE *f, time_t t) +{ + return _MiniXftFileCacheWriteUlong (f, (unsigned long) t); +} + +Bool +MiniXftFileCacheSave (char *cache_file) +{ + MiniXftFileCache *cache; + char *lck; + char *tmp; + FILE *f; + int h; + MiniXftFileCacheEnt *c; + + cache = &_MiniXftFileCache; + + if (!cache->updated && cache->referenced == cache->entries) + return True; + + lck = malloc (strlen (cache_file)*2 + 4); + if (!lck) + goto bail0; + tmp = lck + strlen (cache_file) + 2; + strcpy (lck, cache_file); + strcat (lck, "L"); + strcpy (tmp, cache_file); + strcat (tmp, "T"); + if (link (lck, cache_file) < 0 && errno != ENOENT) + goto bail1; + if (access (tmp, F_OK) == 0) + goto bail2; + f = fopen (tmp, "w"); + if (!f) + goto bail2; + + for (h = 0; h < HASH_SIZE; h++) + { + for (c = cache->ents[h]; c; c = c->next) + { + if (!c->referenced) + continue; + if (!_MiniXftFileCacheWriteString (f, c->file)) + goto bail4; + if (putc (' ', f) == EOF) + goto bail4; + if (!_MiniXftFileCacheWriteInt (f, c->id)) + goto bail4; + if (putc (' ', f) == EOF) + goto bail4; + if (!_MiniXftFileCacheWriteTime (f, c->time)) + goto bail4; + if (putc (' ', f) == EOF) + goto bail4; + if (!_MiniXftFileCacheWriteString (f, c->name)) + goto bail4; + if (putc ('\n', f) == EOF) + goto bail4; + } + } + + if (fclose (f) == EOF) + goto bail3; + + if (rename (tmp, cache_file) < 0) + goto bail3; + + unlink (lck); + cache->updated = False; + return True; + +bail4: + fclose (f); +bail3: + unlink (tmp); +bail2: + unlink (lck); +bail1: + free (lck); +bail0: + return False; +} + +Bool +MiniXftFileCacheReadDir (MiniXftFontSet *set, const char *cache_file) +{ + MiniXftPattern *font; + FILE *f; + char *path; + char *base; + char file[8192]; + int id; + char name[8192]; + Bool ret = False; + + if (_MiniXftFontDebug () & XFT_DBG_CACHE) + { + printf ("MiniXftFileCacheReadDir cache_file \"%s\"\n", cache_file); + } + + f = fopen (cache_file, "r"); + if (!f) + { + if (_MiniXftFontDebug () & XFT_DBG_CACHE) + { + printf (" no cache file\n"); + } + goto bail0; + } + + base = strrchr (cache_file, '/'); + if (!base) + goto bail1; + base++; + path = malloc (base - cache_file + 8192 + 1); + if (!path) + goto bail1; + memcpy (path, cache_file, base - cache_file); + base = path + (base - cache_file); + + while (_MiniXftFileCacheReadString (f, file, sizeof (file)) && + _MiniXftFileCacheReadInt (f, &id) && + _MiniXftFileCacheReadString (f, name, sizeof (name))) + { + font = MiniXftNameParse (name); + if (font) + { + strcpy (base, file); + if (_MiniXftFontDebug () & XFT_DBG_CACHEV) + { + printf (" dir cache file \"%s\"\n", file); + } + MiniXftPatternAddString (font, XFT_FILE, path); + if (!MiniXftFontSetAdd (set, font)) + goto bail2; + } + } + if (_MiniXftFontDebug () & XFT_DBG_CACHE) + { + printf (" cache loaded\n"); + } + + ret = True; +bail2: + free (path); +bail1: + fclose (f); +bail0: + return ret; +} + +Bool +MiniXftFileCacheWriteDir (MiniXftFontSet *set, const char *cache_file) +{ + MiniXftPattern *font; + FILE *f; + char name[8192]; + char *file, *base; + int n; + int id; + + if (_MiniXftFontDebug () & XFT_DBG_CACHE) + printf ("MiniXftFileCacheWriteDir cache_file \"%s\"\n", cache_file); + + f = fopen (cache_file, "w"); + if (!f) + { + if (_MiniXftFontDebug () & XFT_DBG_CACHE) + printf (" can't create \"%s\"\n", cache_file); + goto bail0; + } + for (n = 0; n < set->nfont; n++) + { + font = set->fonts[n]; + if (MiniXftPatternGetString (font, XFT_FILE, 0, &file) != MiniXftResultMatch) + goto bail1; + base = strrchr (file, '/'); + if (base) + base = base + 1; + else + base = file; + if (MiniXftPatternGetInteger (font, XFT_INDEX, 0, &id) != MiniXftResultMatch) + goto bail1; + if (!MiniXftNameUnparse (font, name, sizeof (name))) + goto bail1; + if (_MiniXftFontDebug () & XFT_DBG_CACHEV) + printf (" write file \"%s\"\n", base); + if (!_MiniXftFileCacheWriteString (f, base)) + goto bail1; + if (putc (' ', f) == EOF) + goto bail1; + if (!_MiniXftFileCacheWriteInt (f, id)) + goto bail1; + if (putc (' ', f) == EOF) + goto bail1; + if (!_MiniXftFileCacheWriteString (f, name)) + goto bail1; + if (putc ('\n', f) == EOF) + goto bail1; + } + if (fclose (f) == EOF) + goto bail0; + + if (_MiniXftFontDebug () & XFT_DBG_CACHE) + printf (" cache written\n"); + return True; + +bail1: + fclose (f); +bail0: + unlink (cache_file); + return False; +} diff --git a/pango/mini-xft/minixftcfg.c b/pango/mini-xft/minixftcfg.c new file mode 100644 index 00000000..ffc7e4e0 --- /dev/null +++ b/pango/mini-xft/minixftcfg.c @@ -0,0 +1,665 @@ +/* + * $XFree86: xc/lib/MiniXft/xftcfg.c,v 1.9 2001/03/31 01:57:20 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include <stdlib.h> +#include <string.h> +#include <stdio.h> +#include "minixftint.h" + +static char *MiniXftConfigDefaultDirs[] = { + "/usr/X11R6/lib/X11/fonts/Type1", + 0 +}; + +char **MiniXftConfigDirs = MiniXftConfigDefaultDirs; +static int MiniXftConfigNdirs; + +char MiniXftConfigDefaultCache[] = "~/.xftcache"; +char *MiniXftConfigCache = 0; + +static MiniXftSubst *MiniXftSubsts; +/* #define XFT_DEBUG_EDIT */ + +Bool +MiniXftConfigAddDir (char *d) +{ + char **dirs; + char *dir; + char *h; + + if (*d == '~') + { + h = getenv ("HOME"); + if (!h) + return False; + dir = (char *) malloc (strlen (h) + strlen (d)); + if (!dir) + return False; + strcpy (dir, h); + strcat (dir, d+1); + } + else + { + dir = (char *) malloc (strlen (d) + 1); + if (!dir) + return False; + strcpy (dir, d); + } + dirs = (char **) malloc ((MiniXftConfigNdirs + 2) * sizeof (char *)); + if (!dirs) + { + free (dir); + return False; + } + if (MiniXftConfigNdirs) + { + memcpy (dirs, MiniXftConfigDirs, MiniXftConfigNdirs * sizeof (char *)); + } + dirs[MiniXftConfigNdirs] = dir; + MiniXftConfigNdirs++; + dirs[MiniXftConfigNdirs] = 0; + if (MiniXftConfigDirs != MiniXftConfigDefaultDirs) + free (MiniXftConfigDirs); + MiniXftConfigDirs = dirs; + return True; +} + +Bool +MiniXftConfigSetCache (char *c) +{ + char *new; + char *h; + + if (*c == '~') + { + h = getenv ("HOME"); + if (!h) + return False; + new = (char *) malloc (strlen (h) + strlen (c)); + if (!new) + return False; + strcpy (new, h); + strcat (new, c+1); + } + else + { + new = _MiniXftSaveString (c); + } + if (MiniXftConfigCache) + free (MiniXftConfigCache); + MiniXftConfigCache = new; + return True; +} + +char * +MiniXftConfigGetCache (void) +{ + if (!MiniXftConfigCache) + MiniXftConfigSetCache (MiniXftConfigDefaultCache); + return MiniXftConfigCache; +} + +static int MiniXftSubstsMaxObjects; + +Bool +MiniXftConfigAddEdit (MiniXftTest *test, MiniXftEdit *edit) +{ + MiniXftSubst *subst, **prev; + MiniXftTest *t; + int num; + + subst = (MiniXftSubst *) malloc (sizeof (MiniXftSubst)); + if (!subst) + return False; + for (prev = &MiniXftSubsts; *prev; prev = &(*prev)->next); + *prev = subst; + subst->next = 0; + subst->test = test; + subst->edit = edit; +#ifdef XFT_DEBUG_EDIT + printf ("Add Subst "); + MiniXftSubstPrint (subst); +#endif + num = 0; + for (t = test; t; t = t->next) + num++; + if (MiniXftSubstsMaxObjects < num) + MiniXftSubstsMaxObjects = num; + return True; +} + +typedef struct _MiniXftSubState { + MiniXftPatternElt *elt; + MiniXftValueList *value; +} MiniXftSubState; + +static MiniXftMatrix MiniXftIdentityMatrix = { 1, 0, 0, 1 }; + +static MiniXftValue +_MiniXftConfigPromote (MiniXftValue v, MiniXftValue u) +{ + if (v.type == MiniXftTypeInteger) + { + v.type = MiniXftTypeDouble; + v.u.d = (double) v.u.i; + } + if (v.type == MiniXftTypeVoid && u.type == MiniXftTypeMatrix) + { + v.u.m = &MiniXftIdentityMatrix; + v.type = MiniXftTypeMatrix; + } + return v; +} + +Bool +_MiniXftConfigCompareValue (MiniXftValue m, + MiniXftOp op, + MiniXftValue v) +{ + Bool ret; + + if (m.type == MiniXftTypeVoid) + return True; + m = _MiniXftConfigPromote (m, v); + v = _MiniXftConfigPromote (v, m); + if (m.type == v.type) + { + ret = False; + switch (m.type) { + case MiniXftTypeDouble: + switch (op) { + case MiniXftOpEqual: + ret = m.u.d == v.u.d; + break; + case MiniXftOpNotEqual: + ret = m.u.d != v.u.d; + break; + case MiniXftOpLess: + ret = m.u.d < v.u.d; + break; + case MiniXftOpLessEqual: + ret = m.u.d <= v.u.d; + break; + case MiniXftOpMore: + ret = m.u.d > v.u.d; + break; + case MiniXftOpMoreEqual: + ret = m.u.d >= v.u.d; + break; + default: + break; + } + break; + case MiniXftTypeBool: + switch (op) { + case MiniXftOpEqual: + ret = m.u.b == v.u.b; + break; + case MiniXftOpNotEqual: + ret = m.u.b != v.u.b; + break; + default: + break; + } + break; + case MiniXftTypeString: + switch (op) { + case MiniXftOpEqual: + ret = _MiniXftStrCmpIgnoreCase (m.u.s, v.u.s) == 0; + break; + case MiniXftOpNotEqual: + ret = _MiniXftStrCmpIgnoreCase (m.u.s, v.u.s) != 0; + break; + default: + break; + } + break; + default: + break; + } + } + else + { + if (op == MiniXftOpNotEqual) + ret = True; + else + ret = False; + } + return ret; +} + +static MiniXftValueList * +_MiniXftConfigMatchValueList (MiniXftTest *t, + MiniXftValueList *v) +{ + MiniXftValueList *ret = 0; + + for (; v; v = v->next) + { + if (_MiniXftConfigCompareValue (v->value, t->op, t->value)) + { + if (!ret) + ret = v; + } + else + { + if (t->qual == MiniXftQualAll) + { + ret = 0; + break; + } + } + } + return ret; +} + +static MiniXftValue +_MiniXftConfigEvaluate (MiniXftPattern *p, MiniXftExpr *e) +{ + MiniXftValue v, vl, vr; + MiniXftResult r; + + switch (e->op) { + case MiniXftOpInteger: + v.type = MiniXftTypeInteger; + v.u.i = e->u.ival; + break; + case MiniXftOpDouble: + v.type = MiniXftTypeDouble; + v.u.d = e->u.dval; + break; + case MiniXftOpString: + v.type = MiniXftTypeString; + v.u.s = e->u.sval; + break; + case MiniXftOpMatrix: + v.type = MiniXftTypeMatrix; + v.u.m = e->u.mval; + break; + case MiniXftOpBool: + v.type = MiniXftTypeBool; + v.u.b = e->u.bval; + break; + case MiniXftOpField: + r = MiniXftPatternGet (p, e->u.field, 0, &v); + if (r != MiniXftResultMatch) + v.type = MiniXftTypeVoid; + break; + case MiniXftOpQuest: + vl = _MiniXftConfigEvaluate (p, e->u.tree.left); + if (vl.type == MiniXftTypeBool) + { + if (vl.u.b) + v = _MiniXftConfigEvaluate (p, e->u.tree.right->u.tree.left); + else + v = _MiniXftConfigEvaluate (p, e->u.tree.right->u.tree.right); + } + else + v.type = MiniXftTypeVoid; + break; + case MiniXftOpOr: + case MiniXftOpAnd: + case MiniXftOpEqual: + case MiniXftOpNotEqual: + case MiniXftOpLess: + case MiniXftOpLessEqual: + case MiniXftOpMore: + case MiniXftOpMoreEqual: + case MiniXftOpPlus: + case MiniXftOpMinus: + case MiniXftOpTimes: + case MiniXftOpDivide: + vl = _MiniXftConfigEvaluate (p, e->u.tree.left); + vr = _MiniXftConfigEvaluate (p, e->u.tree.right); + vl = _MiniXftConfigPromote (vl, vr); + vr = _MiniXftConfigPromote (vr, vl); + if (vl.type == vr.type) + { + switch (vl.type) { + case MiniXftTypeDouble: + switch (e->op) { + case MiniXftOpPlus: + v.type = MiniXftTypeDouble; + v.u.d = vl.u.d + vr.u.d; + break; + case MiniXftOpMinus: + v.type = MiniXftTypeDouble; + v.u.d = vl.u.d - vr.u.d; + break; + case MiniXftOpTimes: + v.type = MiniXftTypeDouble; + v.u.d = vl.u.d * vr.u.d; + break; + case MiniXftOpDivide: + v.type = MiniXftTypeDouble; + v.u.d = vl.u.d / vr.u.d; + break; + case MiniXftOpEqual: + v.type = MiniXftTypeBool; + v.u.b = vl.u.d == vr.u.d; + break; + case MiniXftOpNotEqual: + v.type = MiniXftTypeBool; + v.u.b = vl.u.d != vr.u.d; + break; + case MiniXftOpLess: + v.type = MiniXftTypeBool; + v.u.b = vl.u.d < vr.u.d; + break; + case MiniXftOpLessEqual: + v.type = MiniXftTypeBool; + v.u.b = vl.u.d <= vr.u.d; + break; + case MiniXftOpMore: + v.type = MiniXftTypeBool; + v.u.b = vl.u.d > vr.u.d; + break; + case MiniXftOpMoreEqual: + v.type = MiniXftTypeBool; + v.u.b = vl.u.d >= vr.u.d; + break; + default: + v.type = MiniXftTypeVoid; + break; + } + if (v.type == MiniXftTypeDouble && + v.u.d == (double) (int) v.u.d) + { + v.type = MiniXftTypeInteger; + v.u.i = (int) v.u.d; + } + break; + case MiniXftTypeBool: + switch (e->op) { + case MiniXftOpOr: + v.type = MiniXftTypeBool; + v.u.b = vl.u.b || vr.u.b; + break; + case MiniXftOpAnd: + v.type = MiniXftTypeBool; + v.u.b = vl.u.b && vr.u.b; + break; + case MiniXftOpEqual: + v.type = MiniXftTypeBool; + v.u.b = vl.u.b == vr.u.b; + break; + case MiniXftOpNotEqual: + v.type = MiniXftTypeBool; + v.u.b = vl.u.b != vr.u.b; + break; + default: + v.type = MiniXftTypeVoid; + break; + } + break; + case MiniXftTypeString: + switch (e->op) { + case MiniXftOpEqual: + v.type = MiniXftTypeBool; + v.u.b = _MiniXftStrCmpIgnoreCase (vl.u.s, vr.u.s) == 0; + break; + case MiniXftOpNotEqual: + v.type = MiniXftTypeBool; + v.u.b = _MiniXftStrCmpIgnoreCase (vl.u.s, vr.u.s) != 0; + break; + case MiniXftOpPlus: + v.type = MiniXftTypeString; + v.u.s = malloc (strlen (vl.u.s) + strlen (vr.u.s) + 1); + if (v.u.s) + { + strcpy (v.u.s, vl.u.s); + strcat (v.u.s, vr.u.s); + } + else + v.type = MiniXftTypeVoid; + break; + default: + v.type = MiniXftTypeVoid; + break; + } + case MiniXftTypeMatrix: + switch (e->op) { + case MiniXftOpEqual: + v.type = MiniXftTypeBool; + v.u.b = MiniXftMatrixEqual (vl.u.m, vr.u.m) == 0; + break; + case MiniXftOpNotEqual: + v.type = MiniXftTypeBool; + v.u.b = MiniXftMatrixEqual (vl.u.m, vr.u.m) != 0; + break; + case MiniXftOpTimes: + v.type = MiniXftTypeMatrix; + v.u.m = malloc (sizeof (MiniXftMatrix)); + MiniXftMatrixMultiply (v.u.m, vl.u.m, vr.u.m); + break; + default: + v.type = MiniXftTypeVoid; + break; + } + break; + default: + v.type = MiniXftTypeVoid; + break; + } + } + else + v.type = MiniXftTypeVoid; + break; + case MiniXftOpNot: + vl = _MiniXftConfigEvaluate (p, e->u.tree.left); + switch (vl.type) { + case MiniXftTypeBool: + v.type = MiniXftTypeBool; + v.u.b = !vl.u.b; + break; + default: + v.type = MiniXftTypeVoid; + break; + } + break; + default: + v.type = MiniXftTypeVoid; + break; + } + return v; +} + +static Bool +_MiniXftConfigAdd (MiniXftValueList **head, + MiniXftValueList *position, + Bool append, + MiniXftValue value) +{ + MiniXftValueList *new, **prev; + + new = (MiniXftValueList *) malloc (sizeof (MiniXftValueList)); + if (!new) + goto bail0; + + if (value.type == MiniXftTypeString) + { + value.u.s = _MiniXftSaveString (value.u.s); + if (!value.u.s) + goto bail1; + + } + new->value = value; + new->next = 0; + + if (append) + { + prev = &position->next; + } + else + { + for (prev = head; *prev; prev = &(*prev)->next) + { + if (*prev == position) + break; + } +#ifdef XFT_DEBUG + if (!*prev) + printf ("position not on list\n"); +#endif + } + +#ifdef XFT_DEBUG_EDIT + printf ("%s list before ", append ? "Append" : "Prepend"); + MiniXftValueListPrint (*head); + printf ("\n"); +#endif + + new->next = *prev; + *prev = new; + +#ifdef XFT_DEBUG_EDIT + printf ("%s list after ", append ? "Append" : "Prepend"); + MiniXftValueListPrint (*head); + printf ("\n"); +#endif + + return True; + +bail1: + free (new); +bail0: + return False; +} + +static void +_MiniXftConfigDel (MiniXftValueList **head, + MiniXftValueList *position) +{ + MiniXftValueList **prev; + + for (prev = head; *prev; prev = &(*prev)->next) + { + if (*prev == position) + { + *prev = position->next; + position->next = 0; + MiniXftValueListDestroy (position); + break; + } + } +} + +Bool +MiniXftConfigSubstitute (MiniXftPattern *p) +{ + MiniXftSubst *s; + MiniXftSubState *st; + int i; + MiniXftTest *t; + MiniXftEdit *e; + MiniXftValue v; + + st = (MiniXftSubState *) malloc (MiniXftSubstsMaxObjects * sizeof (MiniXftSubState)); + if (!st && MiniXftSubstsMaxObjects) + return False; + +#ifdef XFT_DEBUG_EDIT + printf ("MiniXftConfigSubstitute "); + MiniXftPatternPrint (p); +#endif + for (s = MiniXftSubsts; s; s = s->next) + { + for (t = s->test, i = 0; t; t = t->next, i++) + { +#ifdef XFT_DEBUG_EDIT + printf ("MiniXftConfigSubstitute test "); + MiniXftTestPrint (t); +#endif + st[i].elt = MiniXftPatternFind (p, t->field, False); + if (!st[i].elt) + { + if (t->qual == MiniXftQualAll) + continue; + else + break; + } + st[i].value = _MiniXftConfigMatchValueList (t, st[i].elt->values); + if (!st[i].value) + break; + } + if (t) + { +#ifdef XFT_DEBUG_EDIT + printf ("No match\n"); +#endif + continue; + } +#ifdef XFT_DEBUG_EDIT + printf ("Substitute "); + MiniXftSubstPrint (s); +#endif + for (e = s->edit; e; e = e->next) + { + v = _MiniXftConfigEvaluate (p, e->expr); + if (v.type == MiniXftTypeVoid) + continue; + for (t = s->test, i = 0; t; t = t->next, i++) + if (!_MiniXftStrCmpIgnoreCase (t->field, e->field)) + break; + switch (e->op) { + case MiniXftOpAssign: + if (t) + { + _MiniXftConfigAdd (&st[i].elt->values, st[i].value, True, v); + _MiniXftConfigDel (&st[i].elt->values, st[i].value); + } + else + { + MiniXftPatternDel (p, e->field); + MiniXftPatternAdd (p, e->field, v, True); + } + break; + case MiniXftOpPrepend: + if (t) + _MiniXftConfigAdd (&st[i].elt->values, st[i].value, False, v); + else + MiniXftPatternAdd (p, e->field, v, False); + break; + case MiniXftOpAppend: + if (t) + _MiniXftConfigAdd (&st[i].elt->values, st[i].value, True, v); + else + MiniXftPatternAdd (p, e->field, v, True); + break; + default: + break; + } + } +#ifdef XFT_DEBUG_EDIT + printf ("MiniXftConfigSubstitute edit"); + MiniXftPatternPrint (p); +#endif + } + free (st); +#ifdef XFT_DEBUG_EDIT + printf ("MiniXftConfigSubstitute done"); + MiniXftPatternPrint (p); +#endif + return True; +} diff --git a/pango/mini-xft/minixftdbg.c b/pango/mini-xft/minixftdbg.c new file mode 100644 index 00000000..1912d8f5 --- /dev/null +++ b/pango/mini-xft/minixftdbg.c @@ -0,0 +1,230 @@ +/* + * $XFree86: xc/lib/MiniXft/xftdbg.c,v 1.3 2001/03/31 01:57:20 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "minixftint.h" +#include <stdio.h> + +void +MiniXftValuePrint (MiniXftValue v) +{ + switch (v.type) { + case MiniXftTypeVoid: + printf (" <void>"); + break; + case MiniXftTypeInteger: + printf (" %d", v.u.i); + break; + case MiniXftTypeDouble: + printf (" %g", v.u.d); + break; + case MiniXftTypeString: + printf (" \"%s\"", v.u.s); + break; + case MiniXftTypeBool: + printf (" %s", v.u.b ? "True" : "False"); + break; + case MiniXftTypeMatrix: + printf (" (%f %f; %f %f)", v.u.m->xx, v.u.m->xy, v.u.m->yx, v.u.m->yy); + break; + } +} + +void +MiniXftValueListPrint (MiniXftValueList *l) +{ + for (; l; l = l->next) + MiniXftValuePrint (l->value); +} + +void +MiniXftPatternPrint (MiniXftPattern *p) +{ + int i; + MiniXftPatternElt *e; + + printf ("Pattern %d of %d\n", p->num, p->size); + for (i = 0; i < p->num; i++) + { + e = &p->elts[i]; + printf ("\t%s:", e->object); + MiniXftValueListPrint (e->values); + printf ("\n"); + } + printf ("\n"); +} + +void +MiniXftOpPrint (MiniXftOp op) +{ + switch (op) { + case MiniXftOpInteger: printf ("Integer"); break; + case MiniXftOpDouble: printf ("Double"); break; + case MiniXftOpString: printf ("String"); break; + case MiniXftOpMatrix: printf ("Matrix"); break; + case MiniXftOpBool: printf ("Bool"); break; + case MiniXftOpField: printf ("Field"); break; + case MiniXftOpAssign: printf ("Assign"); break; + case MiniXftOpPrepend: printf ("Prepend"); break; + case MiniXftOpAppend: printf ("Append"); break; + case MiniXftOpQuest: printf ("Quest"); break; + case MiniXftOpOr: printf ("Or"); break; + case MiniXftOpAnd: printf ("And"); break; + case MiniXftOpEqual: printf ("Equal"); break; + case MiniXftOpNotEqual: printf ("NotEqual"); break; + case MiniXftOpLess: printf ("Less"); break; + case MiniXftOpLessEqual: printf ("LessEqual"); break; + case MiniXftOpMore: printf ("More"); break; + case MiniXftOpMoreEqual: printf ("MoreEqual"); break; + case MiniXftOpPlus: printf ("Plus"); break; + case MiniXftOpMinus: printf ("Minus"); break; + case MiniXftOpTimes: printf ("Times"); break; + case MiniXftOpDivide: printf ("Divide"); break; + case MiniXftOpNot: printf ("Not"); break; + case MiniXftOpNil: printf ("Nil"); break; + } +} + +void +MiniXftTestPrint (MiniXftTest *test) +{ + switch (test->qual) { + case MiniXftQualAny: + printf ("any "); + break; + case MiniXftQualAll: + printf ("all "); + break; + } + printf ("%s ", test->field); + MiniXftOpPrint (test->op); + printf (" "); + MiniXftValuePrint (test->value); + printf ("\n"); +} + +void +MiniXftExprPrint (MiniXftExpr *expr) +{ + switch (expr->op) { + case MiniXftOpInteger: printf ("%d", expr->u.ival); break; + case MiniXftOpDouble: printf ("%g", expr->u.dval); break; + case MiniXftOpString: printf ("\"%s\"", expr->u.sval); break; + case MiniXftOpMatrix: printf ("[%g %g %g %g]", + expr->u.mval->xx, + expr->u.mval->xy, + expr->u.mval->yx, + expr->u.mval->yy); + case MiniXftOpBool: printf ("%s", expr->u.bval ? "true" : "false"); break; + case MiniXftOpField: printf ("%s", expr->u.field); break; + case MiniXftOpQuest: + MiniXftExprPrint (expr->u.tree.left); + printf (" quest "); + MiniXftExprPrint (expr->u.tree.right->u.tree.left); + printf (" colon "); + MiniXftExprPrint (expr->u.tree.right->u.tree.right); + break; + case MiniXftOpOr: + case MiniXftOpAnd: + case MiniXftOpEqual: + case MiniXftOpNotEqual: + case MiniXftOpLess: + case MiniXftOpLessEqual: + case MiniXftOpMore: + case MiniXftOpMoreEqual: + case MiniXftOpPlus: + case MiniXftOpMinus: + case MiniXftOpTimes: + case MiniXftOpDivide: + MiniXftExprPrint (expr->u.tree.left); + printf (" "); + switch (expr->op) { + case MiniXftOpOr: printf ("Or"); break; + case MiniXftOpAnd: printf ("And"); break; + case MiniXftOpEqual: printf ("Equal"); break; + case MiniXftOpNotEqual: printf ("NotEqual"); break; + case MiniXftOpLess: printf ("Less"); break; + case MiniXftOpLessEqual: printf ("LessEqual"); break; + case MiniXftOpMore: printf ("More"); break; + case MiniXftOpMoreEqual: printf ("MoreEqual"); break; + case MiniXftOpPlus: printf ("Plus"); break; + case MiniXftOpMinus: printf ("Minus"); break; + case MiniXftOpTimes: printf ("Times"); break; + case MiniXftOpDivide: printf ("Divide"); break; + default: break; + } + printf (" "); + MiniXftExprPrint (expr->u.tree.right); + break; + case MiniXftOpNot: + printf ("Not "); + MiniXftExprPrint (expr->u.tree.left); + break; + default: + break; + } +} + +void +MiniXftEditPrint (MiniXftEdit *edit) +{ + printf ("Edit %s ", edit->field); + MiniXftOpPrint (edit->op); + printf (" "); + MiniXftExprPrint (edit->expr); +} + +void +MiniXftSubstPrint (MiniXftSubst *subst) +{ + MiniXftEdit *e; + MiniXftTest *t; + + printf ("match\n"); + for (t = subst->test; t; t = t->next) + { + printf ("\t"); + MiniXftTestPrint (t); + } + printf ("edit\n"); + for (e = subst->edit; e; e = e->next) + { + printf ("\t"); + MiniXftEditPrint (e); + printf (";\n"); + } + printf ("\n"); +} + +void +MiniXftFontSetPrint (MiniXftFontSet *s) +{ + int i; + + printf ("FontSet %d of %d\n", s->nfont, s->sfont); + for (i = 0; i < s->nfont; i++) + { + printf ("Font %d ", i); + MiniXftPatternPrint (s->fonts[i]); + } +} diff --git a/pango/mini-xft/minixftdir.c b/pango/mini-xft/minixftdir.c new file mode 100644 index 00000000..c6eacb10 --- /dev/null +++ b/pango/mini-xft/minixftdir.c @@ -0,0 +1,136 @@ +/* + * $XFree86: xc/lib/MiniXft/xftdir.c,v 1.3 2001/05/16 10:32:54 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/types.h> +#include <dirent.h> +#include <stdlib.h> +#include <string.h> +#include "minixftint.h" + +Bool +MiniXftDirScan (MiniXftFontSet *set, const char *dir, Bool force) +{ + DIR *d; + struct dirent *e; + char *file; + char *base; + MiniXftPattern *font; + char *name; + int count; + Bool ret = True; + int id; + + file = (char *) malloc (strlen (dir) + 1 + 256 + 1); + if (!file) + return False; + + strcpy (file, dir); + strcat (file, "/"); + base = file + strlen (file); + if (!force) + { + strcpy (base, "MiniXftCache"); + + if (MiniXftFileCacheReadDir (set, file)) + { + free (file); + return True; + } + } + + d = opendir (dir); + if (!d) + { + free (file); + return False; + } + while (ret && (e = readdir (d))) + { + if (e->d_name[0] != '.') + { + id = 0; + strcpy (base, e->d_name); + do + { + if (!force) + name = MiniXftFileCacheFind (file, id, &count); + else + name = 0; + if (name) + { + font = MiniXftNameParse (name); + if (font) + MiniXftPatternAddString (font, XFT_FILE, file); + } + else + { + font = MiniXftFreeTypeQuery (file, id, &count); + if (font && !force) + { + char unparse[8192]; + + if (MiniXftNameUnparse (font, unparse, sizeof (unparse))) + { + (void) MiniXftFileCacheUpdate (file, id, unparse); + } + } + } + if (font) + { + if (!MiniXftFontSetAdd (set, font)) + { + MiniXftPatternDestroy (font); + font = 0; + ret = False; + } + } + id++; + } while (font && ret && id < count); + } + } + free (file); + closedir (d); + return ret; +} + +Bool +MiniXftDirSave (MiniXftFontSet *set, const char *dir) +{ + char *file; + char *base; + Bool ret; + + file = (char *) malloc (strlen (dir) + 1 + 256 + 1); + if (!file) + return False; + + strcpy (file, dir); + strcat (file, "/"); + base = file + strlen (file); + strcpy (base, "MiniXftCache"); + ret = MiniXftFileCacheWriteDir (set, file); + free (file); + return ret; +} + diff --git a/pango/mini-xft/minixftdpy.c b/pango/mini-xft/minixftdpy.c new file mode 100644 index 00000000..6dbf061f --- /dev/null +++ b/pango/mini-xft/minixftdpy.c @@ -0,0 +1,321 @@ +/* + * $XFree86: xc/lib/MiniXft/xftdpy.c,v 1.7 2001/04/29 03:21:17 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include <stdio.h> +#include <stdlib.h> +#include <ctype.h> +#include "minixftint.h" + +MiniXftDisplayInfo *_MiniXftDisplayInfo; + +static MiniXftDisplayInfo * +_MiniXftDisplayInfoGet (Display *dpy) +{ + MiniXftDisplayInfo *info, **prev; + + for (prev = &_MiniXftDisplayInfo; (info = *prev); prev = &(*prev)->next) + { + if (info->display == dpy) + { + /* + * MRU the list + */ + if (prev != &_MiniXftDisplayInfo) + { + *prev = info->next; + info->next = _MiniXftDisplayInfo; + _MiniXftDisplayInfo = info; + } + return info; + } + } + info = (MiniXftDisplayInfo *) malloc (sizeof (MiniXftDisplayInfo)); + if (!info) + goto bail0; + + info->display = dpy; + info->defaults = 0; + + info->next = _MiniXftDisplayInfo; + _MiniXftDisplayInfo = info; + return info; + +bail0: + if (_MiniXftFontDebug () & XFT_DBG_RENDER) + { + printf ("MiniXftDisplayInfoGet failed to initialize, MiniXft unhappy\n"); + } + return 0; +} + +Bool +MiniXftDefaultHasRender (Display *dpy) +{ + return True; +} + +Bool +MiniXftDefaultSet (Display *dpy, MiniXftPattern *defaults) +{ + MiniXftDisplayInfo *info = _MiniXftDisplayInfoGet (dpy); + + if (!info) + return False; + if (info->defaults) + MiniXftPatternDestroy (info->defaults); + info->defaults = defaults; + return True; +} + +int +MiniXftDefaultParseBool (char *v) +{ + char c0, c1; + + c0 = *v; + if (isupper (c0)) + c0 = tolower (c0); + if (c0 == 't' || c0 == 'y' || c0 == '1') + return 1; + if (c0 == 'f' || c0 == 'n' || c0 == '0') + return 0; + if (c0 == 'o') + { + c1 = v[1]; + if (isupper (c1)) + c1 = tolower (c1); + if (c1 == 'n') + return 1; + if (c1 == 'f') + return 0; + } + return -1; +} + +static Bool +_MiniXftDefaultInitBool (Display *dpy, MiniXftPattern *pat, char *option) +{ + return True; +} + +static Bool +_MiniXftDefaultInitDouble (Display *dpy, MiniXftPattern *pat, char *option) +{ + return True; +} + +static Bool +_MiniXftDefaultInitInteger (Display *dpy, MiniXftPattern *pat, char *option) +{ + return True; +} + +static MiniXftPattern * +_MiniXftDefaultInit (Display *dpy) +{ + MiniXftPattern *pat; + + pat = MiniXftPatternCreate (); + if (!pat) + goto bail0; + + if (!_MiniXftDefaultInitBool (dpy, pat, XFT_CORE)) + goto bail1; + if (!_MiniXftDefaultInitDouble (dpy, pat, XFT_SCALE)) + goto bail1; + if (!_MiniXftDefaultInitDouble (dpy, pat, XFT_DPI)) + goto bail1; + if (!_MiniXftDefaultInitBool (dpy, pat, XFT_RENDER)) + goto bail1; + if (!_MiniXftDefaultInitInteger (dpy, pat, XFT_RGBA)) + goto bail1; + if (!_MiniXftDefaultInitBool (dpy, pat, XFT_ANTIALIAS)) + goto bail1; + if (!_MiniXftDefaultInitBool (dpy, pat, XFT_MINSPACE)) + goto bail1; + + return pat; + +bail1: + MiniXftPatternDestroy (pat); +bail0: + return 0; +} + +static MiniXftResult +_MiniXftDefaultGet (Display *dpy, const char *object, int screen, MiniXftValue *v) +{ + MiniXftDisplayInfo *info = _MiniXftDisplayInfoGet (dpy); + MiniXftResult r; + + if (!info) + return MiniXftResultNoMatch; + + if (!info->defaults) + { + info->defaults = _MiniXftDefaultInit (dpy); + if (!info->defaults) + return MiniXftResultNoMatch; + } + r = MiniXftPatternGet (info->defaults, object, screen, v); + if (r == MiniXftResultNoId && screen > 0) + r = MiniXftPatternGet (info->defaults, object, 0, v); + return r; +} + +Bool +MiniXftDefaultGetBool (Display *dpy, const char *object, int screen, Bool def) +{ + MiniXftResult r; + MiniXftValue v; + + r = _MiniXftDefaultGet (dpy, object, screen, &v); + if (r != MiniXftResultMatch || v.type != MiniXftTypeBool) + return def; + return v.u.b; +} + +int +MiniXftDefaultGetInteger (Display *dpy, const char *object, int screen, int def) +{ + MiniXftResult r; + MiniXftValue v; + + r = _MiniXftDefaultGet (dpy, object, screen, &v); + if (r != MiniXftResultMatch || v.type != MiniXftTypeInteger) + return def; + return v.u.i; +} + +double +MiniXftDefaultGetDouble (Display *dpy, const char *object, int screen, double def) +{ + MiniXftResult r; + MiniXftValue v; + + r = _MiniXftDefaultGet (dpy, object, screen, &v); + if (r != MiniXftResultMatch || v.type != MiniXftTypeDouble) + return def; + return v.u.d; +} + +MiniXftFontSet * +MiniXftDisplayGetFontSet (Display *dpy) +{ + return 0; +} + +static double default_dpi = 0.0; + +void +MiniXftSetDPI (double dpi) +{ + default_dpi = dpi; +} + +void +MiniXftDefaultSubstitute (Display *dpy, int screen, MiniXftPattern *pattern) +{ + MiniXftValue v; + double size; + double scale; + + if (MiniXftPatternGet (pattern, XFT_STYLE, 0, &v) == MiniXftResultNoMatch) + { + if (MiniXftPatternGet (pattern, XFT_WEIGHT, 0, &v) == MiniXftResultNoMatch ) + { + MiniXftPatternAddInteger (pattern, XFT_WEIGHT, XFT_WEIGHT_MEDIUM); + } + if (MiniXftPatternGet (pattern, XFT_SLANT, 0, &v) == MiniXftResultNoMatch) + { + MiniXftPatternAddInteger (pattern, XFT_SLANT, XFT_SLANT_ROMAN); + } + } + if (MiniXftPatternGet (pattern, XFT_ENCODING, 0, &v) == MiniXftResultNoMatch) + MiniXftPatternAddString (pattern, XFT_ENCODING, "iso8859-1"); + if (MiniXftPatternGet (pattern, XFT_RENDER, 0, &v) == MiniXftResultNoMatch) + { + MiniXftPatternAddBool (pattern, XFT_RENDER, + MiniXftDefaultGetBool (dpy, XFT_RENDER, screen, + MiniXftDefaultHasRender (dpy))); + } + if (MiniXftPatternGet (pattern, XFT_CORE, 0, &v) == MiniXftResultNoMatch) + { + MiniXftPatternAddBool (pattern, XFT_CORE, + MiniXftDefaultGetBool (dpy, XFT_CORE, screen, + !MiniXftDefaultHasRender (dpy))); + } + if (MiniXftPatternGet (pattern, XFT_ANTIALIAS, 0, &v) == MiniXftResultNoMatch) + { + MiniXftPatternAddBool (pattern, XFT_ANTIALIAS, + MiniXftDefaultGetBool (dpy, XFT_ANTIALIAS, screen, + True)); + } + if (MiniXftPatternGet (pattern, XFT_RGBA, 0, &v) == MiniXftResultNoMatch) + { + MiniXftPatternAddInteger (pattern, XFT_RGBA, + MiniXftDefaultGetInteger (dpy, XFT_RGBA, screen, + XFT_RGBA_NONE)); + } + if (MiniXftPatternGet (pattern, XFT_MINSPACE, 0, &v) == MiniXftResultNoMatch) + { + MiniXftPatternAddBool (pattern, XFT_MINSPACE, + MiniXftDefaultGetBool (dpy, XFT_MINSPACE, screen, + False)); + } + if (MiniXftPatternGet (pattern, XFT_PIXEL_SIZE, 0, &v) == MiniXftResultNoMatch) + { + double dpi; + + if (MiniXftPatternGet (pattern, XFT_SIZE, 0, &v) != MiniXftResultMatch) + { + size = 12.0; + MiniXftPatternAddDouble (pattern, XFT_SIZE, size); + } + else + { + switch (v.type) { + case MiniXftTypeInteger: + size = (double) v.u.i; + break; + case MiniXftTypeDouble: + size = v.u.d; + break; + default: + size = 12.0; + break; + } + } + scale = MiniXftDefaultGetDouble (dpy, XFT_SCALE, screen, 1.0); + size *= scale; + if (default_dpi > 0.0) + dpi = default_dpi; + else + dpi = 72.0; + dpi = MiniXftDefaultGetDouble (dpy, XFT_DPI, screen, dpi); + size = size * dpi / 72.0; + MiniXftPatternAddDouble (pattern, XFT_PIXEL_SIZE, size); + } +} + diff --git a/pango/mini-xft/minixftfont.c b/pango/mini-xft/minixftfont.c new file mode 100644 index 00000000..46665c43 --- /dev/null +++ b/pango/mini-xft/minixftfont.c @@ -0,0 +1,111 @@ +/* + * $XFree86: xc/lib/MiniXft/xftfont.c,v 1.8 2000/12/20 00:20:48 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include <stdio.h> +#include <stdlib.h> +#include "minixftint.h" + +MiniXftPattern * +MiniXftFontMatch (Display *dpy, int screen, MiniXftPattern *pattern, MiniXftResult *result) +{ + MiniXftPattern *new; + MiniXftPattern *match; + MiniXftFontSet *sets[2]; + int nsets; + Bool render, core; + + if (!MiniXftInit (0)) + return 0; + + new = MiniXftPatternDuplicate (pattern); + if (!new) + return 0; + + if (_MiniXftFontDebug () & XFT_DBG_OPENV) + { + printf ("MiniXftFontMatch pattern "); + MiniXftPatternPrint (new); + } + MiniXftConfigSubstitute (new); + if (_MiniXftFontDebug () & XFT_DBG_OPENV) + { + printf ("MiniXftFontMatch after MiniXftConfig substitutions "); + MiniXftPatternPrint (new); + } + MiniXftDefaultSubstitute (dpy, screen, new); + if (_MiniXftFontDebug () & XFT_DBG_OPENV) + { + printf ("MiniXftFontMatch after X resource substitutions "); + MiniXftPatternPrint (new); + } + nsets = 0; + + render = True; + core = False; + (void) MiniXftPatternGetBool (new, XFT_RENDER, 0, &render); + (void) MiniXftPatternGetBool (new, XFT_CORE, 0, &core); + if (_MiniXftFontDebug () & XFT_DBG_OPENV) + { + printf ("MiniXftFontMatch: use core fonts \"%s\", use render fonts \"%s\"\n", + core ? "True" : "False", render ? "True" : "False"); + } + + if (render) + { + if (MiniXftInitFtLibrary ()) + { + sets[nsets] = _MiniXftFontSet; + if (sets[nsets]) + nsets++; + } + } + + match = MiniXftFontSetMatch (sets, nsets, new, result); + MiniXftPatternDestroy (new); + return match; +} + +int +_MiniXftFontDebug (void) +{ + static int initialized; + static int debug; + + if (!initialized) + { + char *e; + + initialized = 1; + e = getenv ("XFT_DEBUG"); + if (e) + { + printf ("XFT_DEBUG=%s\n", e); + debug = atoi (e); + if (debug <= 0) + debug = 1; + } + } + return debug; +} + diff --git a/pango/mini-xft/minixftfreetype.c b/pango/mini-xft/minixftfreetype.c new file mode 100644 index 00000000..7b92abd4 --- /dev/null +++ b/pango/mini-xft/minixftfreetype.c @@ -0,0 +1,190 @@ +/* + * $XFree86: xc/lib/MiniXft/xftfreetype.c,v 1.14 2001/09/21 19:54:53 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include "minixftint.h" + +FT_Library _MiniXftFTlibrary; + +typedef struct _MiniXftFtEncoding { + const char *name; + FT_Encoding encoding; +} MiniXftFtEncoding; + +static MiniXftFtEncoding xftFtEncoding[] = { + { "iso10646-1", ft_encoding_unicode, }, + { "iso8859-1", ft_encoding_unicode, }, + { "apple-roman", ft_encoding_apple_roman }, + { "adobe-fontspecific", ft_encoding_symbol, }, + { "glyphs-fontspecific",ft_encoding_none, }, +}; + +#define NUM_FT_ENCODINGS (sizeof xftFtEncoding / sizeof xftFtEncoding[0]) + +#define FT_Matrix_Equal(a,b) ((a)->xx == (b)->xx && \ + (a)->yy == (b)->yy && \ + (a)->xy == (b)->xy && \ + (a)->yx == (b)->yx) + +MiniXftPattern * +MiniXftFreeTypeQuery (const char *file, int id, int *count) +{ + FT_Face face; + MiniXftPattern *pat; + int slant; + int weight; + int i, j; + + if (FT_New_Face (_MiniXftFTlibrary, file, id, &face)) + return 0; + + *count = face->num_faces; + + pat = MiniXftPatternCreate (); + if (!pat) + goto bail0; + + + if (!MiniXftPatternAddBool (pat, XFT_CORE, False)) + goto bail1; + + if (!MiniXftPatternAddBool (pat, XFT_OUTLINE, + (face->face_flags & FT_FACE_FLAG_SCALABLE) != 0)) + goto bail1; + + if (!MiniXftPatternAddBool (pat, XFT_SCALABLE, + (face->face_flags & FT_FACE_FLAG_SCALABLE) != 0)) + goto bail1; + + + slant = XFT_SLANT_ROMAN; + if (face->style_flags & FT_STYLE_FLAG_ITALIC) + slant = XFT_SLANT_ITALIC; + + if (!MiniXftPatternAddInteger (pat, XFT_SLANT, slant)) + goto bail1; + + weight = XFT_WEIGHT_MEDIUM; + if (face->style_flags & FT_STYLE_FLAG_BOLD) + weight = XFT_WEIGHT_BOLD; + + if (!MiniXftPatternAddInteger (pat, XFT_WEIGHT, weight)) + goto bail1; + + if (!MiniXftPatternAddString (pat, XFT_FAMILY, face->family_name)) + goto bail1; + + if (!MiniXftPatternAddString (pat, XFT_STYLE, face->style_name)) + goto bail1; + + if (!MiniXftPatternAddString (pat, XFT_FILE, file)) + goto bail1; + + if (!MiniXftPatternAddInteger (pat, XFT_INDEX, id)) + goto bail1; + +#if 0 + if ((face->face_flags & FT_FACE_FLAG_FIXED_WIDTH) != 0) + if (!MiniXftPatternAddInteger (pat, XFT_SPACING, XFT_MONO)) + goto bail1; +#endif + + if (!(face->face_flags & FT_FACE_FLAG_SCALABLE)) + { + for (i = 0; i < face->num_fixed_sizes; i++) + if (!MiniXftPatternAddDouble (pat, XFT_PIXEL_SIZE, + (double) face->available_sizes[i].height)) + goto bail1; + } + + for (i = 0; i < face->num_charmaps; i++) + { +#if 0 + printf ("face %s encoding %d %c%c%c%c\n", + face->family_name, i, + face->charmaps[i]->encoding >> 24, + face->charmaps[i]->encoding >> 16, + face->charmaps[i]->encoding >> 8, + face->charmaps[i]->encoding >> 0); +#endif + for (j = 0; j < NUM_FT_ENCODINGS; j++) + { + if (face->charmaps[i]->encoding == xftFtEncoding[j].encoding) + { + if (!MiniXftPatternAddString (pat, XFT_ENCODING, + xftFtEncoding[j].name)) + goto bail1; + } + } + } + + if (!MiniXftPatternAddString (pat, XFT_ENCODING, + "glyphs-fontspecific")) + goto bail1; + + + FT_Done_Face (face); + return pat; + +bail1: + MiniXftPatternDestroy (pat); +bail0: + FT_Done_Face (face); + return 0; +} + +/* #define XFT_DEBUG_FONTSET */ +Bool +MiniXftInitFtLibrary (void) +{ + char **d; + char *cache; + + if (_MiniXftFTlibrary) + return True; + if (FT_Init_FreeType (&_MiniXftFTlibrary)) + return False; + _MiniXftFontSet = MiniXftFontSetCreate (); + if (!_MiniXftFontSet) + return False; + cache = MiniXftConfigGetCache (); + if (cache) + MiniXftFileCacheLoad (cache); + for (d = MiniXftConfigDirs; d && *d; d++) + { +#ifdef XFT_DEBUG_FONTSET + printf ("scan dir %s\n", *d); +#endif + MiniXftDirScan (_MiniXftFontSet, *d, False); + } +#ifdef XFT_DEBUG_FONTSET + MiniXftFontSetPrint (_MiniXftFontSet); +#endif + if (cache) + MiniXftFileCacheSave (cache); + MiniXftFileCacheDispose (); + return True; +} diff --git a/pango/mini-xft/minixftfs.c b/pango/mini-xft/minixftfs.c new file mode 100644 index 00000000..74c1f444 --- /dev/null +++ b/pango/mini-xft/minixftfs.c @@ -0,0 +1,74 @@ +/* + * $XFree86: xc/lib/MiniXft/xftfs.c,v 1.1 2000/11/29 08:39:22 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include <stdlib.h> +#include "minixftint.h" + +MiniXftFontSet * +MiniXftFontSetCreate (void) +{ + MiniXftFontSet *s; + + s = (MiniXftFontSet *) malloc (sizeof (MiniXftFontSet)); + if (!s) + return 0; + s->nfont = 0; + s->sfont = 0; + s->fonts = 0; + return s; +} + +void +MiniXftFontSetDestroy (MiniXftFontSet *s) +{ + int i; + + for (i = 0; i < s->nfont; i++) + MiniXftPatternDestroy (s->fonts[i]); + if (s->fonts) + free (s->fonts); + free (s); +} + +Bool +MiniXftFontSetAdd (MiniXftFontSet *s, MiniXftPattern *font) +{ + MiniXftPattern **f; + int sfont; + + if (s->nfont == s->sfont) + { + sfont = s->sfont + 32; + if (s->fonts) + f = (MiniXftPattern **) realloc (s->fonts, sfont * sizeof (MiniXftPattern *)); + else + f = (MiniXftPattern **) malloc (sfont * sizeof (MiniXftPattern *)); + if (!f) + return False; + s->sfont = sfont; + s->fonts = f; + } + s->fonts[s->nfont++] = font; + return True; +} diff --git a/pango/mini-xft/minixftgram.c b/pango/mini-xft/minixftgram.c new file mode 100644 index 00000000..d4798f54 --- /dev/null +++ b/pango/mini-xft/minixftgram.c @@ -0,0 +1,1498 @@ + +/* A Bison parser, made from minixftgram.y + by GNU Bison version 1.28 */ + +#define YYBISON 1 /* Identify Bison output. */ + +#define INTEGER 257 +#define DOUBLE 258 +#define STRING 259 +#define NAME 260 +#define ANY 261 +#define ALL 262 +#define DIR 263 +#define CACHE 264 +#define INCLUDE 265 +#define INCLUDEIF 266 +#define MATCH 267 +#define EDIT 268 +#define TOK_TRUE 269 +#define TOK_FALSE 270 +#define TOK_NIL 271 +#define EQUAL 272 +#define SEMI 273 +#define OS 274 +#define CS 275 +#define QUEST 276 +#define COLON 277 +#define OROR 278 +#define ANDAND 279 +#define EQEQ 280 +#define NOTEQ 281 +#define LESS 282 +#define LESSEQ 283 +#define MORE 284 +#define MOREEQ 285 +#define PLUS 286 +#define MINUS 287 +#define TIMES 288 +#define DIVIDE 289 +#define NOT 290 + +#line 25 "minixftgram.y" + + +#include <stdlib.h> +#include <stdio.h> +#include "minixftint.h" + +static MiniXftMatrix matrix; + + +#line 35 "minixftgram.y" +typedef union { + int ival; + double dval; + char *sval; + MiniXftExpr *eval; + MiniXftPattern *pval; + MiniXftValue vval; + MiniXftEdit *Eval; + MiniXftOp oval; + MiniXftQual qval; + MiniXftTest *tval; +} YYSTYPE; +#include <stdio.h> + +#ifndef __cplusplus +#ifndef __STDC__ +#define const +#endif +#endif + + + +#define YYFINAL 95 +#define YYFLAG -32768 +#define YYNTBASE 37 + +#define YYTRANSLATE(x) ((unsigned)(x) <= 290 ? MiniXftConfigtranslate[x] : 51) + +static const char MiniXftConfigtranslate[] = { 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 1, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 35, 36 +}; + +#if YYDEBUG != 0 +static const short MiniXftConfigprhs[] = { 0, + 0, 3, 4, 7, 10, 13, 16, 21, 24, 25, + 30, 32, 34, 35, 37, 39, 41, 43, 45, 47, + 49, 51, 53, 55, 57, 59, 61, 63, 65, 72, + 74, 76, 79, 80, 85, 87, 90, 93, 95, 97, + 99, 101, 103, 105, 107, 109, 113, 117, 121, 125, + 129, 133, 137, 141, 145, 149, 153, 157, 160 +}; + +static const short MiniXftConfigrhs[] = { 37, + 38, 0, 0, 9, 5, 0, 10, 5, 0, 11, + 5, 0, 12, 5, 0, 13, 39, 14, 47, 0, + 40, 39, 0, 0, 41, 42, 43, 44, 0, 7, + 0, 8, 0, 0, 6, 0, 18, 0, 26, 0, + 27, 0, 28, 0, 29, 0, 30, 0, 31, 0, + 3, 0, 4, 0, 5, 0, 15, 0, 16, 0, + 17, 0, 45, 0, 20, 46, 46, 46, 46, 21, + 0, 3, 0, 4, 0, 48, 47, 0, 0, 42, + 49, 50, 19, 0, 18, 0, 32, 18, 0, 18, + 32, 0, 3, 0, 4, 0, 5, 0, 15, 0, + 16, 0, 17, 0, 45, 0, 6, 0, 50, 24, + 50, 0, 50, 25, 50, 0, 50, 26, 50, 0, + 50, 27, 50, 0, 50, 28, 50, 0, 50, 29, + 50, 0, 50, 30, 50, 0, 50, 31, 50, 0, + 50, 32, 50, 0, 50, 33, 50, 0, 50, 34, + 50, 0, 50, 35, 50, 0, 36, 50, 0, 50, + 22, 50, 23, 50, 0 +}; + +#endif + +#if YYDEBUG != 0 +static const short MiniXftConfigrline[] = { 0, + 77, 78, 80, 82, 84, 86, 88, 91, 93, 96, + 99, 101, 103, 106, 111, 113, 115, 117, 119, 121, + 123, 126, 131, 136, 141, 146, 151, 155, 161, 168, + 170, 172, 174, 177, 180, 182, 184, 187, 189, 191, + 193, 195, 197, 199, 201, 203, 205, 207, 209, 211, + 213, 215, 217, 219, 221, 223, 225, 227, 229 +}; +#endif + + +#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) + +static const char * const MiniXftConfigtname[] = { "$","error","$undefined.","INTEGER", +"DOUBLE","STRING","NAME","ANY","ALL","DIR","CACHE","INCLUDE","INCLUDEIF","MATCH", +"EDIT","TOK_TRUE","TOK_FALSE","TOK_NIL","EQUAL","SEMI","OS","CS","QUEST","COLON", +"OROR","ANDAND","EQEQ","NOTEQ","LESS","LESSEQ","MORE","MOREEQ","PLUS","MINUS", +"TIMES","DIVIDE","NOT","configs","config","tests","test","qual","field","compare", +"value","matrix","number","edits","edit","eqop","expr", NULL +}; +#endif + +static const short MiniXftConfigr1[] = { 0, + 37, 37, 38, 38, 38, 38, 38, 39, 39, 40, + 41, 41, 41, 42, 43, 43, 43, 43, 43, 43, + 43, 44, 44, 44, 44, 44, 44, 44, 45, 46, + 46, 47, 47, 48, 49, 49, 49, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, 50 +}; + +static const short MiniXftConfigr2[] = { 0, + 2, 0, 2, 2, 2, 2, 4, 2, 0, 4, + 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 6, 1, + 1, 2, 0, 4, 1, 2, 2, 1, 1, 1, + 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 2, 5 +}; + +static const short MiniXftConfigdefact[] = { 2, + 0, 0, 0, 0, 0, 9, 1, 3, 4, 5, + 6, 11, 12, 0, 9, 0, 33, 8, 14, 0, + 0, 7, 33, 15, 16, 17, 18, 19, 20, 21, + 0, 35, 0, 0, 32, 22, 23, 24, 25, 26, + 27, 0, 10, 28, 37, 36, 38, 39, 40, 45, + 41, 42, 43, 0, 44, 0, 30, 31, 0, 58, + 34, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 0, 0, + 0, 59, 29, 0, 0 +}; + +static const short MiniXftConfigdefgoto[] = { 1, + 7, 14, 15, 16, 21, 31, 43, 55, 59, 22, + 23, 34, 56 +}; + +static const short MiniXftConfigpact[] = {-32768, + 39, 32, 52, 94, 95, -1,-32768,-32768,-32768,-32768, +-32768,-32768,-32768, 15, -1, 79, 79,-32768,-32768, 80, + 8,-32768, 79,-32768,-32768,-32768,-32768,-32768,-32768,-32768, + 27, 69, 84, 18,-32768,-32768,-32768,-32768,-32768,-32768, +-32768, 24,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768,-32768,-32768, 18,-32768, 34,-32768,-32768, 24,-32768, +-32768, 18, 18, 18, 18, 18, 18, 18, 18, 18, + 18, 18, 18, 18, 24, 48, 87, 97, 105, 105, + -31, -31, -31, -31, 11, 11,-32768,-32768, 24, 18, + 82, 62,-32768, 104,-32768 +}; + +static const short MiniXftConfigpgoto[] = {-32768, +-32768, 90,-32768,-32768, 125,-32768,-32768, 111, -34, 120, +-32768,-32768, -54 +}; + + +#define YYLAST 143 + + +static const short MiniXftConfigtable[] = { 60, + 71, 72, 73, 74, -13, 12, 13, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 47, 48, 49, 50, 75, 32, 57, 58, 17, 36, + 37, 38, 51, 52, 53, 92, 8, 42, 94, 33, + 89, 39, 40, 41, 73, 74, 42, 2, 3, 4, + 5, 6, 61, 54, 91, 62, 9, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 62, + 90, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 62, 19, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 24, 10, 11, + 45, 46, 93, 95, 18, 25, 26, 27, 28, 29, + 30, 64, 65, 66, 67, 68, 69, 70, 71, 72, + 73, 74, 65, 66, 67, 68, 69, 70, 71, 72, + 73, 74, 67, 68, 69, 70, 71, 72, 73, 74, + 20, 44, 35 +}; + +static const short MiniXftConfigcheck[] = { 54, + 32, 33, 34, 35, 6, 7, 8, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 3, 4, 5, 6, 59, 18, 3, 4, 14, 3, + 4, 5, 15, 16, 17, 90, 5, 20, 0, 32, + 75, 15, 16, 17, 34, 35, 20, 9, 10, 11, + 12, 13, 19, 36, 89, 22, 5, 24, 25, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 35, 22, + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 22, 6, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 18, 5, 5, + 32, 18, 21, 0, 15, 26, 27, 28, 29, 30, + 31, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 28, 29, 30, 31, 32, 33, 34, 35, + 16, 31, 23 +}; +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ +#line 3 "/usr/lib/bison.simple" +/* This file comes from bison-1.28. */ + +/* Skeleton output parser for bison, + Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* This is the parser code that is written into each bison parser + when the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +#ifndef YYSTACK_USE_ALLOCA +#ifdef alloca +#define YYSTACK_USE_ALLOCA +#else /* alloca not defined */ +#ifdef __GNUC__ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#else /* not GNU C. */ +#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386)) +#define YYSTACK_USE_ALLOCA +#include <alloca.h> +#else /* not sparc */ +/* We think this test detects Watcom and Microsoft C. */ +/* This used to test MSDOS, but that is a bad idea + since that symbol is in the user namespace. */ +#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__) +#if 0 /* No need for malloc.h, which pollutes the namespace; + instead, just don't use alloca. */ +#include <malloc.h> +#endif +#else /* not MSDOS, or __TURBOC__ */ +#if defined(_AIX) +/* I don't know what this was needed for, but it pollutes the namespace. + So I turned it off. rms, 2 May 1997. */ +/* #include <malloc.h> */ + #pragma alloca +#define YYSTACK_USE_ALLOCA +#else /* not MSDOS, or __TURBOC__, or _AIX */ +#if 0 +#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up, + and on HPUX 10. Eventually we can turn this on. */ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#endif /* __hpux */ +#endif +#endif /* not _AIX */ +#endif /* not MSDOS, or __TURBOC__ */ +#endif /* not sparc */ +#endif /* not GNU C */ +#endif /* alloca not defined */ +#endif /* YYSTACK_USE_ALLOCA not defined */ + +#ifdef YYSTACK_USE_ALLOCA +#define YYSTACK_ALLOC alloca +#else +#define YYSTACK_ALLOC malloc +#endif + +/* Note: there must be only one dollar sign in this file. + It is replaced by the list of actions, each action + as one case of the switch. */ + +#define MiniXftConfigerrok (MiniXftConfigerrstatus = 0) +#define MiniXftConfigclearin (MiniXftConfigchar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 +#define YYACCEPT goto MiniXftConfigacceptlab +#define YYABORT goto MiniXftConfigabortlab +#define YYERROR goto MiniXftConfigerrlab1 +/* Like YYERROR except do call MiniXftConfigerror. + This remains here temporarily to ease the + transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ +#define YYFAIL goto MiniXftConfigerrlab +#define YYRECOVERING() (!!MiniXftConfigerrstatus) +#define YYBACKUP(token, value) \ +do \ + if (MiniXftConfigchar == YYEMPTY && MiniXftConfiglen == 1) \ + { MiniXftConfigchar = (token), MiniXftConfiglval = (value); \ + MiniXftConfigchar1 = YYTRANSLATE (MiniXftConfigchar); \ + YYPOPSTACK; \ + goto MiniXftConfigbackup; \ + } \ + else \ + { MiniXftConfigerror ("syntax error: cannot back up"); YYERROR; } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +#ifndef YYPURE +#define YYLEX MiniXftConfiglex() +#endif + +#ifdef YYPURE +#ifdef YYLSP_NEEDED +#ifdef YYLEX_PARAM +#define YYLEX MiniXftConfiglex(&MiniXftConfiglval, &MiniXftConfiglloc, YYLEX_PARAM) +#else +#define YYLEX MiniXftConfiglex(&MiniXftConfiglval, &MiniXftConfiglloc) +#endif +#else /* not YYLSP_NEEDED */ +#ifdef YYLEX_PARAM +#define YYLEX MiniXftConfiglex(&MiniXftConfiglval, YYLEX_PARAM) +#else +#define YYLEX MiniXftConfiglex(&MiniXftConfiglval) +#endif +#endif /* not YYLSP_NEEDED */ +#endif + +/* If nonreentrant, generate the variables here */ + +#ifndef YYPURE + +int MiniXftConfigchar; /* the lookahead symbol */ +YYSTYPE MiniXftConfiglval; /* the semantic value of the */ + /* lookahead symbol */ + +#ifdef YYLSP_NEEDED +YYLTYPE MiniXftConfiglloc; /* location data for the lookahead */ + /* symbol */ +#endif + +int MiniXftConfignerrs; /* number of parse errors so far */ +#endif /* not YYPURE */ + +#if YYDEBUG != 0 +int MiniXftConfigdebug; /* nonzero means print parse trace */ +/* Since this is uninitialized, it does not stop multiple parsers + from coexisting. */ +#endif + +/* YYINITDEPTH indicates the initial size of the parser's stacks */ + +#ifndef YYINITDEPTH +#define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH is the maximum size the stacks can grow to + (effective only if the built-in stack extension method is used). */ + +#if YYMAXDEPTH == 0 +#undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 10000 +#endif + +/* Define __MiniXftConfig_memcpy. Note that the size argument + should be passed with type unsigned int, because that is what the non-GCC + definitions require. With GCC, __builtin_memcpy takes an arg + of type size_t, but it can handle unsigned int. */ + +#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ +#define __MiniXftConfig_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT) +#else /* not GNU C or C++ */ +#ifndef __cplusplus + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__MiniXftConfig_memcpy (to, from, count) + char *to; + char *from; + unsigned int count; +{ + register char *f = from; + register char *t = to; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#else /* __cplusplus */ + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__MiniXftConfig_memcpy (char *to, char *from, unsigned int count) +{ + register char *t = to; + register char *f = from; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#endif +#endif + +#line 217 "/usr/lib/bison.simple" + +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into MiniXftConfigparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef YYPARSE_PARAM +#ifdef __cplusplus +#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +#define YYPARSE_PARAM_DECL +#else /* not __cplusplus */ +#define YYPARSE_PARAM_ARG YYPARSE_PARAM +#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +#endif /* not __cplusplus */ +#else /* not YYPARSE_PARAM */ +#define YYPARSE_PARAM_ARG +#define YYPARSE_PARAM_DECL +#endif /* not YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +#ifdef YYPARSE_PARAM +int MiniXftConfigparse (void *); +#else +int MiniXftConfigparse (void); +#endif +#endif + +int +MiniXftConfigparse(YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + register int MiniXftConfigstate; + register int MiniXftConfign; + register short *MiniXftConfigssp; + register YYSTYPE *MiniXftConfigvsp; + int MiniXftConfigerrstatus; /* number of tokens to shift before error messages enabled */ + int MiniXftConfigchar1 = 0; /* lookahead token as an internal (translated) token number */ + + short MiniXftConfigssa[YYINITDEPTH]; /* the state stack */ + YYSTYPE MiniXftConfigvsa[YYINITDEPTH]; /* the semantic value stack */ + + short *MiniXftConfigss = MiniXftConfigssa; /* refer to the stacks thru separate pointers */ + YYSTYPE *MiniXftConfigvs = MiniXftConfigvsa; /* to allow MiniXftConfigoverflow to reallocate them elsewhere */ + +#ifdef YYLSP_NEEDED + YYLTYPE MiniXftConfiglsa[YYINITDEPTH]; /* the location stack */ + YYLTYPE *MiniXftConfigls = MiniXftConfiglsa; + YYLTYPE *MiniXftConfiglsp; + +#define YYPOPSTACK (MiniXftConfigvsp--, MiniXftConfigssp--, MiniXftConfiglsp--) +#else +#define YYPOPSTACK (MiniXftConfigvsp--, MiniXftConfigssp--) +#endif + + int MiniXftConfigstacksize = YYINITDEPTH; + int MiniXftConfigfree_stacks = 0; + +#ifdef YYPURE + int MiniXftConfigchar; + YYSTYPE MiniXftConfiglval; + int MiniXftConfignerrs; +#ifdef YYLSP_NEEDED + YYLTYPE MiniXftConfiglloc; +#endif +#endif + + YYSTYPE MiniXftConfigval; /* the variable used to return */ + /* semantic values from the action */ + /* routines */ + + int MiniXftConfiglen; + +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + fprintf(stderr, "Starting parse\n"); +#endif + + MiniXftConfigstate = 0; + MiniXftConfigerrstatus = 0; + MiniXftConfignerrs = 0; + MiniXftConfigchar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + MiniXftConfigssp = MiniXftConfigss - 1; + MiniXftConfigvsp = MiniXftConfigvs; +#ifdef YYLSP_NEEDED + MiniXftConfiglsp = MiniXftConfigls; +#endif + +/* Push a new state, which is found in MiniXftConfigstate . */ +/* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. */ +MiniXftConfignewstate: + + *++MiniXftConfigssp = MiniXftConfigstate; + + if (MiniXftConfigssp >= MiniXftConfigss + MiniXftConfigstacksize - 1) + { + /* Give user a chance to reallocate the stack */ + /* Use copies of these so that the &'s don't force the real ones into memory. */ + YYSTYPE *MiniXftConfigvs1 = MiniXftConfigvs; + short *MiniXftConfigss1 = MiniXftConfigss; +#ifdef YYLSP_NEEDED + YYLTYPE *MiniXftConfigls1 = MiniXftConfigls; +#endif + + /* Get the current used size of the three stacks, in elements. */ + int size = MiniXftConfigssp - MiniXftConfigss + 1; + +#ifdef MiniXftConfigoverflow + /* Each stack pointer address is followed by the size of + the data in use in that stack, in bytes. */ +#ifdef YYLSP_NEEDED + /* This used to be a conditional around just the two extra args, + but that might be undefined if MiniXftConfigoverflow is a macro. */ + MiniXftConfigoverflow("parser stack overflow", + &MiniXftConfigss1, size * sizeof (*MiniXftConfigssp), + &MiniXftConfigvs1, size * sizeof (*MiniXftConfigvsp), + &MiniXftConfigls1, size * sizeof (*MiniXftConfiglsp), + &MiniXftConfigstacksize); +#else + MiniXftConfigoverflow("parser stack overflow", + &MiniXftConfigss1, size * sizeof (*MiniXftConfigssp), + &MiniXftConfigvs1, size * sizeof (*MiniXftConfigvsp), + &MiniXftConfigstacksize); +#endif + + MiniXftConfigss = MiniXftConfigss1; MiniXftConfigvs = MiniXftConfigvs1; +#ifdef YYLSP_NEEDED + MiniXftConfigls = MiniXftConfigls1; +#endif +#else /* no MiniXftConfigoverflow */ + /* Extend the stack our own way. */ + if (MiniXftConfigstacksize >= YYMAXDEPTH) + { + MiniXftConfigerror("parser stack overflow"); + if (MiniXftConfigfree_stacks) + { + free (MiniXftConfigss); + free (MiniXftConfigvs); +#ifdef YYLSP_NEEDED + free (MiniXftConfigls); +#endif + } + return 2; + } + MiniXftConfigstacksize *= 2; + if (MiniXftConfigstacksize > YYMAXDEPTH) + MiniXftConfigstacksize = YYMAXDEPTH; +#ifndef YYSTACK_USE_ALLOCA + MiniXftConfigfree_stacks = 1; +#endif + MiniXftConfigss = (short *) YYSTACK_ALLOC (MiniXftConfigstacksize * sizeof (*MiniXftConfigssp)); + __MiniXftConfig_memcpy ((char *)MiniXftConfigss, (char *)MiniXftConfigss1, + size * (unsigned int) sizeof (*MiniXftConfigssp)); + MiniXftConfigvs = (YYSTYPE *) YYSTACK_ALLOC (MiniXftConfigstacksize * sizeof (*MiniXftConfigvsp)); + __MiniXftConfig_memcpy ((char *)MiniXftConfigvs, (char *)MiniXftConfigvs1, + size * (unsigned int) sizeof (*MiniXftConfigvsp)); +#ifdef YYLSP_NEEDED + MiniXftConfigls = (YYLTYPE *) YYSTACK_ALLOC (MiniXftConfigstacksize * sizeof (*MiniXftConfiglsp)); + __MiniXftConfig_memcpy ((char *)MiniXftConfigls, (char *)MiniXftConfigls1, + size * (unsigned int) sizeof (*MiniXftConfiglsp)); +#endif +#endif /* no MiniXftConfigoverflow */ + + MiniXftConfigssp = MiniXftConfigss + size - 1; + MiniXftConfigvsp = MiniXftConfigvs + size - 1; +#ifdef YYLSP_NEEDED + MiniXftConfiglsp = MiniXftConfigls + size - 1; +#endif + +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + fprintf(stderr, "Stack size increased to %d\n", MiniXftConfigstacksize); +#endif + + if (MiniXftConfigssp >= MiniXftConfigss + MiniXftConfigstacksize - 1) + YYABORT; + } + +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + fprintf(stderr, "Entering state %d\n", MiniXftConfigstate); +#endif + + goto MiniXftConfigbackup; + MiniXftConfigbackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* MiniXftConfigresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + MiniXftConfign = MiniXftConfigpact[MiniXftConfigstate]; + if (MiniXftConfign == YYFLAG) + goto MiniXftConfigdefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* MiniXftConfigchar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (MiniXftConfigchar == YYEMPTY) + { +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + fprintf(stderr, "Reading a token: "); +#endif + MiniXftConfigchar = YYLEX; + } + + /* Convert token to internal form (in MiniXftConfigchar1) for indexing tables with */ + + if (MiniXftConfigchar <= 0) /* This means end of input. */ + { + MiniXftConfigchar1 = 0; + MiniXftConfigchar = YYEOF; /* Don't call YYLEX any more */ + +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + fprintf(stderr, "Now at end of input.\n"); +#endif + } + else + { + MiniXftConfigchar1 = YYTRANSLATE(MiniXftConfigchar); + +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + { + fprintf (stderr, "Next token is %d (%s", MiniXftConfigchar, MiniXftConfigtname[MiniXftConfigchar1]); + /* Give the individual parser a way to print the precise meaning + of a token, for further debugging info. */ +#ifdef YYPRINT + YYPRINT (stderr, MiniXftConfigchar, MiniXftConfiglval); +#endif + fprintf (stderr, ")\n"); + } +#endif + } + + MiniXftConfign += MiniXftConfigchar1; + if (MiniXftConfign < 0 || MiniXftConfign > YYLAST || MiniXftConfigcheck[MiniXftConfign] != MiniXftConfigchar1) + goto MiniXftConfigdefault; + + MiniXftConfign = MiniXftConfigtable[MiniXftConfign]; + + /* MiniXftConfign is what to do for this token type in this state. + Negative => reduce, -MiniXftConfign is rule number. + Positive => shift, MiniXftConfign is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (MiniXftConfign < 0) + { + if (MiniXftConfign == YYFLAG) + goto MiniXftConfigerrlab; + MiniXftConfign = -MiniXftConfign; + goto MiniXftConfigreduce; + } + else if (MiniXftConfign == 0) + goto MiniXftConfigerrlab; + + if (MiniXftConfign == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + fprintf(stderr, "Shifting token %d (%s), ", MiniXftConfigchar, MiniXftConfigtname[MiniXftConfigchar1]); +#endif + + /* Discard the token being shifted unless it is eof. */ + if (MiniXftConfigchar != YYEOF) + MiniXftConfigchar = YYEMPTY; + + *++MiniXftConfigvsp = MiniXftConfiglval; +#ifdef YYLSP_NEEDED + *++MiniXftConfiglsp = MiniXftConfiglloc; +#endif + + /* count tokens shifted since error; after three, turn off error status. */ + if (MiniXftConfigerrstatus) MiniXftConfigerrstatus--; + + MiniXftConfigstate = MiniXftConfign; + goto MiniXftConfignewstate; + +/* Do the default action for the current state. */ +MiniXftConfigdefault: + + MiniXftConfign = MiniXftConfigdefact[MiniXftConfigstate]; + if (MiniXftConfign == 0) + goto MiniXftConfigerrlab; + +/* Do a reduction. MiniXftConfign is the number of a rule to reduce with. */ +MiniXftConfigreduce: + MiniXftConfiglen = MiniXftConfigr2[MiniXftConfign]; + if (MiniXftConfiglen > 0) + MiniXftConfigval = MiniXftConfigvsp[1-MiniXftConfiglen]; /* implement default value of the action */ + +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + { + int i; + + fprintf (stderr, "Reducing via rule %d (line %d), ", + MiniXftConfign, MiniXftConfigrline[MiniXftConfign]); + + /* Print the symbols being reduced, and their result. */ + for (i = MiniXftConfigprhs[MiniXftConfign]; MiniXftConfigrhs[i] > 0; i++) + fprintf (stderr, "%s ", MiniXftConfigtname[MiniXftConfigrhs[i]]); + fprintf (stderr, " -> %s\n", MiniXftConfigtname[MiniXftConfigr1[MiniXftConfign]]); + } +#endif + + + switch (MiniXftConfign) { + +case 3: +#line 81 "minixftgram.y" +{ MiniXftConfigAddDir (MiniXftConfigvsp[0].sval); ; + break;} +case 4: +#line 83 "minixftgram.y" +{ MiniXftConfigSetCache (MiniXftConfigvsp[0].sval); ; + break;} +case 5: +#line 85 "minixftgram.y" +{ MiniXftConfigPushInput (MiniXftConfigvsp[0].sval, True); ; + break;} +case 6: +#line 87 "minixftgram.y" +{ MiniXftConfigPushInput (MiniXftConfigvsp[0].sval, False); ; + break;} +case 7: +#line 89 "minixftgram.y" +{ MiniXftConfigAddEdit (MiniXftConfigvsp[-2].tval, MiniXftConfigvsp[0].Eval); ; + break;} +case 8: +#line 92 "minixftgram.y" +{ MiniXftConfigvsp[-1].tval->next = MiniXftConfigvsp[0].tval; MiniXftConfigval.tval = MiniXftConfigvsp[-1].tval; ; + break;} +case 9: +#line 94 "minixftgram.y" +{ MiniXftConfigval.tval = 0; ; + break;} +case 10: +#line 97 "minixftgram.y" +{ MiniXftConfigval.tval = MiniXftTestCreate (MiniXftConfigvsp[-3].qval, MiniXftConfigvsp[-2].sval, MiniXftConfigvsp[-1].oval, MiniXftConfigvsp[0].vval); ; + break;} +case 11: +#line 100 "minixftgram.y" +{ MiniXftConfigval.qval = MiniXftQualAny; ; + break;} +case 12: +#line 102 "minixftgram.y" +{ MiniXftConfigval.qval = MiniXftQualAll; ; + break;} +case 13: +#line 104 "minixftgram.y" +{ MiniXftConfigval.qval = MiniXftQualAny; ; + break;} +case 14: +#line 107 "minixftgram.y" +{ + MiniXftConfigval.sval = MiniXftConfigSaveField (MiniXftConfigvsp[0].sval); + ; + break;} +case 15: +#line 112 "minixftgram.y" +{ MiniXftConfigval.oval = MiniXftOpEqual; ; + break;} +case 16: +#line 114 "minixftgram.y" +{ MiniXftConfigval.oval = MiniXftOpEqual; ; + break;} +case 17: +#line 116 "minixftgram.y" +{ MiniXftConfigval.oval = MiniXftOpNotEqual; ; + break;} +case 18: +#line 118 "minixftgram.y" +{ MiniXftConfigval.oval = MiniXftOpLess; ; + break;} +case 19: +#line 120 "minixftgram.y" +{ MiniXftConfigval.oval = MiniXftOpLessEqual; ; + break;} +case 20: +#line 122 "minixftgram.y" +{ MiniXftConfigval.oval = MiniXftOpMore; ; + break;} +case 21: +#line 124 "minixftgram.y" +{ MiniXftConfigval.oval = MiniXftOpMoreEqual; ; + break;} +case 22: +#line 127 "minixftgram.y" +{ + MiniXftConfigval.vval.type = MiniXftTypeInteger; + MiniXftConfigval.vval.u.i = MiniXftConfigvsp[0].ival; + ; + break;} +case 23: +#line 132 "minixftgram.y" +{ + MiniXftConfigval.vval.type = MiniXftTypeDouble; + MiniXftConfigval.vval.u.d = MiniXftConfigvsp[0].dval; + ; + break;} +case 24: +#line 137 "minixftgram.y" +{ + MiniXftConfigval.vval.type = MiniXftTypeString; + MiniXftConfigval.vval.u.s = MiniXftConfigvsp[0].sval; + ; + break;} +case 25: +#line 142 "minixftgram.y" +{ + MiniXftConfigval.vval.type = MiniXftTypeBool; + MiniXftConfigval.vval.u.b = True; + ; + break;} +case 26: +#line 147 "minixftgram.y" +{ + MiniXftConfigval.vval.type = MiniXftTypeBool; + MiniXftConfigval.vval.u.b = False; + ; + break;} +case 27: +#line 152 "minixftgram.y" +{ + MiniXftConfigval.vval.type = MiniXftTypeVoid; + ; + break;} +case 28: +#line 156 "minixftgram.y" +{ + MiniXftConfigval.vval.type = MiniXftTypeMatrix; + MiniXftConfigval.vval.u.m = &matrix; + ; + break;} +case 29: +#line 162 "minixftgram.y" +{ + matrix.xx = MiniXftConfigvsp[-4].dval; + matrix.xy = MiniXftConfigvsp[-3].dval; + matrix.yx = MiniXftConfigvsp[-2].dval; + matrix.yy = MiniXftConfigvsp[-1].dval; + ; + break;} +case 30: +#line 169 "minixftgram.y" +{ MiniXftConfigval.dval = (double) MiniXftConfigvsp[0].ival; ; + break;} +case 32: +#line 173 "minixftgram.y" +{ MiniXftConfigvsp[-1].Eval->next = MiniXftConfigvsp[0].Eval; MiniXftConfigval.Eval = MiniXftConfigvsp[-1].Eval; ; + break;} +case 33: +#line 175 "minixftgram.y" +{ MiniXftConfigval.Eval = 0; ; + break;} +case 34: +#line 178 "minixftgram.y" +{ MiniXftConfigval.Eval = MiniXftEditCreate (MiniXftConfigvsp[-3].sval, MiniXftConfigvsp[-2].oval, MiniXftConfigvsp[-1].eval); ; + break;} +case 35: +#line 181 "minixftgram.y" +{ MiniXftConfigval.oval = MiniXftOpAssign; ; + break;} +case 36: +#line 183 "minixftgram.y" +{ MiniXftConfigval.oval = MiniXftOpPrepend; ; + break;} +case 37: +#line 185 "minixftgram.y" +{ MiniXftConfigval.oval = MiniXftOpAppend; ; + break;} +case 38: +#line 188 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateInteger (MiniXftConfigvsp[0].ival); ; + break;} +case 39: +#line 190 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateDouble (MiniXftConfigvsp[0].dval); ; + break;} +case 40: +#line 192 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateString (MiniXftConfigvsp[0].sval); ; + break;} +case 41: +#line 194 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateBool (True); ; + break;} +case 42: +#line 196 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateBool (False); ; + break;} +case 43: +#line 198 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateNil (); ; + break;} +case 44: +#line 200 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateMatrix (&matrix); ; + break;} +case 45: +#line 202 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateField (MiniXftConfigvsp[0].sval); ; + break;} +case 46: +#line 204 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpOr, MiniXftConfigvsp[0].eval); ; + break;} +case 47: +#line 206 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpAnd, MiniXftConfigvsp[0].eval); ; + break;} +case 48: +#line 208 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpEqual, MiniXftConfigvsp[0].eval); ; + break;} +case 49: +#line 210 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpNotEqual, MiniXftConfigvsp[0].eval); ; + break;} +case 50: +#line 212 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpLess, MiniXftConfigvsp[0].eval); ; + break;} +case 51: +#line 214 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpLessEqual, MiniXftConfigvsp[0].eval); ; + break;} +case 52: +#line 216 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpMore, MiniXftConfigvsp[0].eval); ; + break;} +case 53: +#line 218 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpMoreEqual, MiniXftConfigvsp[0].eval); ; + break;} +case 54: +#line 220 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpPlus, MiniXftConfigvsp[0].eval); ; + break;} +case 55: +#line 222 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpMinus, MiniXftConfigvsp[0].eval); ; + break;} +case 56: +#line 224 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpTimes, MiniXftConfigvsp[0].eval); ; + break;} +case 57: +#line 226 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpDivide, MiniXftConfigvsp[0].eval); ; + break;} +case 58: +#line 228 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[0].eval, MiniXftOpNot, (MiniXftExpr *) 0); ; + break;} +case 59: +#line 230 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-4].eval, MiniXftOpQuest, MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpQuest, MiniXftConfigvsp[0].eval)); ; + break;} +} + /* the action file gets copied in in place of this dollarsign */ +#line 543 "/usr/lib/bison.simple" + + MiniXftConfigvsp -= MiniXftConfiglen; + MiniXftConfigssp -= MiniXftConfiglen; +#ifdef YYLSP_NEEDED + MiniXftConfiglsp -= MiniXftConfiglen; +#endif + +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + { + short *ssp1 = MiniXftConfigss - 1; + fprintf (stderr, "state stack now"); + while (ssp1 != MiniXftConfigssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + + *++MiniXftConfigvsp = MiniXftConfigval; + +#ifdef YYLSP_NEEDED + MiniXftConfiglsp++; + if (MiniXftConfiglen == 0) + { + MiniXftConfiglsp->first_line = MiniXftConfiglloc.first_line; + MiniXftConfiglsp->first_column = MiniXftConfiglloc.first_column; + MiniXftConfiglsp->last_line = (MiniXftConfiglsp-1)->last_line; + MiniXftConfiglsp->last_column = (MiniXftConfiglsp-1)->last_column; + MiniXftConfiglsp->text = 0; + } + else + { + MiniXftConfiglsp->last_line = (MiniXftConfiglsp+MiniXftConfiglen-1)->last_line; + MiniXftConfiglsp->last_column = (MiniXftConfiglsp+MiniXftConfiglen-1)->last_column; + } +#endif + + /* Now "shift" the result of the reduction. + Determine what state that goes to, + based on the state we popped back to + and the rule number reduced by. */ + + MiniXftConfign = MiniXftConfigr1[MiniXftConfign]; + + MiniXftConfigstate = MiniXftConfigpgoto[MiniXftConfign - YYNTBASE] + *MiniXftConfigssp; + if (MiniXftConfigstate >= 0 && MiniXftConfigstate <= YYLAST && MiniXftConfigcheck[MiniXftConfigstate] == *MiniXftConfigssp) + MiniXftConfigstate = MiniXftConfigtable[MiniXftConfigstate]; + else + MiniXftConfigstate = MiniXftConfigdefgoto[MiniXftConfign - YYNTBASE]; + + goto MiniXftConfignewstate; + +MiniXftConfigerrlab: /* here on detecting error */ + + if (! MiniXftConfigerrstatus) + /* If not already recovering from an error, report this error. */ + { + ++MiniXftConfignerrs; + +#ifdef YYERROR_VERBOSE + MiniXftConfign = MiniXftConfigpact[MiniXftConfigstate]; + + if (MiniXftConfign > YYFLAG && MiniXftConfign < YYLAST) + { + int size = 0; + char *msg; + int x, count; + + count = 0; + /* Start X at -MiniXftConfign if nec to avoid negative indexes in MiniXftConfigcheck. */ + for (x = (MiniXftConfign < 0 ? -MiniXftConfign : 0); + x < (sizeof(MiniXftConfigtname) / sizeof(char *)); x++) + if (MiniXftConfigcheck[x + MiniXftConfign] == x) + size += strlen(MiniXftConfigtname[x]) + 15, count++; + msg = (char *) malloc(size + 15); + if (msg != 0) + { + strcpy(msg, "parse error"); + + if (count < 5) + { + count = 0; + for (x = (MiniXftConfign < 0 ? -MiniXftConfign : 0); + x < (sizeof(MiniXftConfigtname) / sizeof(char *)); x++) + if (MiniXftConfigcheck[x + MiniXftConfign] == x) + { + strcat(msg, count == 0 ? ", expecting `" : " or `"); + strcat(msg, MiniXftConfigtname[x]); + strcat(msg, "'"); + count++; + } + } + MiniXftConfigerror(msg); + free(msg); + } + else + MiniXftConfigerror ("parse error; also virtual memory exceeded"); + } + else +#endif /* YYERROR_VERBOSE */ + MiniXftConfigerror("parse error"); + } + + goto MiniXftConfigerrlab1; +MiniXftConfigerrlab1: /* here on error raised explicitly by an action */ + + if (MiniXftConfigerrstatus == 3) + { + /* if just tried and failed to reuse lookahead token after an error, discard it. */ + + /* return failure if at end of input */ + if (MiniXftConfigchar == YYEOF) + YYABORT; + +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + fprintf(stderr, "Discarding token %d (%s).\n", MiniXftConfigchar, MiniXftConfigtname[MiniXftConfigchar1]); +#endif + + MiniXftConfigchar = YYEMPTY; + } + + /* Else will try to reuse lookahead token + after shifting the error token. */ + + MiniXftConfigerrstatus = 3; /* Each real token shifted decrements this */ + + goto MiniXftConfigerrhandle; + +MiniXftConfigerrdefault: /* current state does not do anything special for the error token. */ + +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + MiniXftConfign = MiniXftConfigdefact[MiniXftConfigstate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ + if (MiniXftConfign) goto MiniXftConfigdefault; +#endif + +MiniXftConfigerrpop: /* pop the current state because it cannot handle the error token */ + + if (MiniXftConfigssp == MiniXftConfigss) YYABORT; + MiniXftConfigvsp--; + MiniXftConfigstate = *--MiniXftConfigssp; +#ifdef YYLSP_NEEDED + MiniXftConfiglsp--; +#endif + +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + { + short *ssp1 = MiniXftConfigss - 1; + fprintf (stderr, "Error: state stack now"); + while (ssp1 != MiniXftConfigssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + +MiniXftConfigerrhandle: + + MiniXftConfign = MiniXftConfigpact[MiniXftConfigstate]; + if (MiniXftConfign == YYFLAG) + goto MiniXftConfigerrdefault; + + MiniXftConfign += YYTERROR; + if (MiniXftConfign < 0 || MiniXftConfign > YYLAST || MiniXftConfigcheck[MiniXftConfign] != YYTERROR) + goto MiniXftConfigerrdefault; + + MiniXftConfign = MiniXftConfigtable[MiniXftConfign]; + if (MiniXftConfign < 0) + { + if (MiniXftConfign == YYFLAG) + goto MiniXftConfigerrpop; + MiniXftConfign = -MiniXftConfign; + goto MiniXftConfigreduce; + } + else if (MiniXftConfign == 0) + goto MiniXftConfigerrpop; + + if (MiniXftConfign == YYFINAL) + YYACCEPT; + +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + fprintf(stderr, "Shifting error token, "); +#endif + + *++MiniXftConfigvsp = MiniXftConfiglval; +#ifdef YYLSP_NEEDED + *++MiniXftConfiglsp = MiniXftConfiglloc; +#endif + + MiniXftConfigstate = MiniXftConfign; + goto MiniXftConfignewstate; + + MiniXftConfigacceptlab: + /* YYACCEPT comes here. */ + if (MiniXftConfigfree_stacks) + { + free (MiniXftConfigss); + free (MiniXftConfigvs); +#ifdef YYLSP_NEEDED + free (MiniXftConfigls); +#endif + } + return 0; + + MiniXftConfigabortlab: + /* YYABORT comes here. */ + if (MiniXftConfigfree_stacks) + { + free (MiniXftConfigss); + free (MiniXftConfigvs); +#ifdef YYLSP_NEEDED + free (MiniXftConfigls); +#endif + } + return 1; +} +#line 232 "minixftgram.y" + + +int +MiniXftConfigwrap (void) +{ + return 1; +} + +void +MiniXftConfigerror (char *fmt, ...) +{ + va_list args; + + fprintf (stderr, "\"%s\": line %d, ", MiniXftConfigFile, MiniXftConfigLineno); + va_start (args, fmt); + vfprintf (stderr, fmt, args); + va_end (args); + fprintf (stderr, "\n"); +} + +MiniXftTest * +MiniXftTestCreate (MiniXftQual qual, const char *field, MiniXftOp compare, MiniXftValue value) +{ + MiniXftTest *test = (MiniXftTest *) malloc (sizeof (MiniXftTest));; + + if (test) + { + test->next = 0; + test->qual = qual; + test->field = field; /* already saved in grammar */ + test->op = compare; + if (value.type == MiniXftTypeString) + value.u.s = _MiniXftSaveString (value.u.s); + else if (value.type == MiniXftTypeMatrix) + value.u.m = _MiniXftSaveMatrix (value.u.m); + test->value = value; + } + return test; +} + +MiniXftExpr * +MiniXftExprCreateInteger (int i) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = MiniXftOpInteger; + e->u.ival = i; + } + return e; +} + +MiniXftExpr * +MiniXftExprCreateDouble (double d) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = MiniXftOpDouble; + e->u.dval = d; + } + return e; +} + +MiniXftExpr * +MiniXftExprCreateString (const char *s) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = MiniXftOpString; + e->u.sval = _MiniXftSaveString (s); + } + return e; +} + +MiniXftExpr * +MiniXftExprCreateMatrix (const MiniXftMatrix *m) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = MiniXftOpMatrix; + e->u.mval = _MiniXftSaveMatrix (m); + } + return e; +} + +MiniXftExpr * +MiniXftExprCreateBool (Bool b) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = MiniXftOpBool; + e->u.bval = b; + } + return e; +} + +MiniXftExpr * +MiniXftExprCreateNil (void) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = MiniXftOpNil; + } + return e; +} + +MiniXftExpr * +MiniXftExprCreateField (const char *field) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = MiniXftOpField; + e->u.field = _MiniXftSaveString (field); + } + return e; +} + +MiniXftExpr * +MiniXftExprCreateOp (MiniXftExpr *left, MiniXftOp op, MiniXftExpr *right) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = op; + e->u.tree.left = left; + e->u.tree.right = right; + } + return e; +} + +void +MiniXftExprDestroy (MiniXftExpr *e) +{ + switch (e->op) { + case MiniXftOpInteger: + break; + case MiniXftOpDouble: + break; + case MiniXftOpString: + free (e->u.sval); + break; + case MiniXftOpMatrix: + free (e->u.mval); + break; + case MiniXftOpBool: + break; + case MiniXftOpField: + free (e->u.field); + break; + case MiniXftOpAssign: + case MiniXftOpPrepend: + case MiniXftOpAppend: + break; + case MiniXftOpOr: + case MiniXftOpAnd: + case MiniXftOpEqual: + case MiniXftOpNotEqual: + case MiniXftOpLess: + case MiniXftOpLessEqual: + case MiniXftOpMore: + case MiniXftOpMoreEqual: + case MiniXftOpPlus: + case MiniXftOpMinus: + case MiniXftOpTimes: + case MiniXftOpDivide: + case MiniXftOpQuest: + MiniXftExprDestroy (e->u.tree.right); + /* fall through */ + case MiniXftOpNot: + MiniXftExprDestroy (e->u.tree.left); + break; + case MiniXftOpNil: + break; + } + free (e); +} + +MiniXftEdit * +MiniXftEditCreate (const char *field, MiniXftOp op, MiniXftExpr *expr) +{ + MiniXftEdit *e = (MiniXftEdit *) malloc (sizeof (MiniXftEdit)); + + if (e) + { + e->next = 0; + e->field = field; /* already saved in grammar */ + e->op = op; + e->expr = expr; + } + return e; +} + +void +MiniXftEditDestroy (MiniXftEdit *e) +{ + if (e->next) + MiniXftEditDestroy (e->next); + free ((void *) e->field); + if (e->expr) + MiniXftExprDestroy (e->expr); +} + +char * +MiniXftConfigSaveField (const char *field) +{ + return _MiniXftSaveString (field); +} diff --git a/pango/mini-xft/minixftgram.h b/pango/mini-xft/minixftgram.h new file mode 100644 index 00000000..8207b436 --- /dev/null +++ b/pango/mini-xft/minixftgram.h @@ -0,0 +1,49 @@ +typedef union { + int ival; + double dval; + char *sval; + MiniXftExpr *eval; + MiniXftPattern *pval; + MiniXftValue vval; + MiniXftEdit *Eval; + MiniXftOp oval; + MiniXftQual qval; + MiniXftTest *tval; +} YYSTYPE; +#define INTEGER 257 +#define DOUBLE 258 +#define STRING 259 +#define NAME 260 +#define ANY 261 +#define ALL 262 +#define DIR 263 +#define CACHE 264 +#define INCLUDE 265 +#define INCLUDEIF 266 +#define MATCH 267 +#define EDIT 268 +#define TOK_TRUE 269 +#define TOK_FALSE 270 +#define TOK_NIL 271 +#define EQUAL 272 +#define SEMI 273 +#define OS 274 +#define CS 275 +#define QUEST 276 +#define COLON 277 +#define OROR 278 +#define ANDAND 279 +#define EQEQ 280 +#define NOTEQ 281 +#define LESS 282 +#define LESSEQ 283 +#define MORE 284 +#define MOREEQ 285 +#define PLUS 286 +#define MINUS 287 +#define TIMES 288 +#define DIVIDE 289 +#define NOT 290 + + +extern YYSTYPE MiniXftConfiglval; diff --git a/pango/mini-xft/minixftgram.y b/pango/mini-xft/minixftgram.y new file mode 100644 index 00000000..e2daaa33 --- /dev/null +++ b/pango/mini-xft/minixftgram.y @@ -0,0 +1,452 @@ +/* + * $XFree86: xc/lib/MiniXft/xftgram.y,v 1.5 2001/05/16 10:32:54 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +%{ + +#include <stdlib.h> +#include <stdio.h> +#include "minixftint.h" + +static MiniXftMatrix matrix; + +%} + +%union { + int ival; + double dval; + char *sval; + MiniXftExpr *eval; + MiniXftPattern *pval; + MiniXftValue vval; + MiniXftEdit *Eval; + MiniXftOp oval; + MiniXftQual qval; + MiniXftTest *tval; +} + +%token <ival> INTEGER +%token <dval> DOUBLE +%token <sval> STRING NAME +%token <ival> ANY ALL +%token <ival> DIR CACHE INCLUDE INCLUDEIF MATCH EDIT +%token <ival> TOK_TRUE TOK_FALSE TOK_NIL +%token <ival> EQUAL SEMI OS CS + +%type <eval> expr +%type <vval> value +%type <sval> field +%type <Eval> edit +%type <Eval> edits +%type <oval> eqop +%type <qval> qual +%type <oval> compare +%type <tval> tests test +%type <dval> number + +%right <ival> QUEST COLON +%left <ival> OROR +%left <ival> ANDAND +%left <ival> EQEQ NOTEQ +%left <ival> LESS LESSEQ MORE MOREEQ +%left <ival> PLUS MINUS +%left <ival> TIMES DIVIDE +%right <ival> NOT + +%% +configs : configs config + | + ; +config : DIR STRING + { MiniXftConfigAddDir ($2); } + | CACHE STRING + { MiniXftConfigSetCache ($2); } + | INCLUDE STRING + { MiniXftConfigPushInput ($2, True); } + | INCLUDEIF STRING + { MiniXftConfigPushInput ($2, False); } + | MATCH tests EDIT edits + { MiniXftConfigAddEdit ($2, $4); } + ; +tests : test tests + { $1->next = $2; $$ = $1; } + | + { $$ = 0; } + ; +test : qual field compare value + { $$ = MiniXftTestCreate ($1, $2, $3, $4); } + ; +qual : ANY + { $$ = MiniXftQualAny; } + | ALL + { $$ = MiniXftQualAll; } + | + { $$ = MiniXftQualAny; } + ; +field : NAME + { + $$ = MiniXftConfigSaveField ($1); + } + ; +compare : EQUAL + { $$ = MiniXftOpEqual; } + | EQEQ + { $$ = MiniXftOpEqual; } + | NOTEQ + { $$ = MiniXftOpNotEqual; } + | LESS + { $$ = MiniXftOpLess; } + | LESSEQ + { $$ = MiniXftOpLessEqual; } + | MORE + { $$ = MiniXftOpMore; } + | MOREEQ + { $$ = MiniXftOpMoreEqual; } + ; +value : INTEGER + { + $$.type = MiniXftTypeInteger; + $$.u.i = $1; + } + | DOUBLE + { + $$.type = MiniXftTypeDouble; + $$.u.d = $1; + } + | STRING + { + $$.type = MiniXftTypeString; + $$.u.s = $1; + } + | TOK_TRUE + { + $$.type = MiniXftTypeBool; + $$.u.b = True; + } + | TOK_FALSE + { + $$.type = MiniXftTypeBool; + $$.u.b = False; + } + | TOK_NIL + { + $$.type = MiniXftTypeVoid; + } + | matrix + { + $$.type = MiniXftTypeMatrix; + $$.u.m = &matrix; + } + ; +matrix : OS number number number number CS + { + matrix.xx = $2; + matrix.xy = $3; + matrix.yx = $4; + matrix.__REALLY_YY__ = $5; + } +number : INTEGER + { $$ = (double) $1; } + | DOUBLE + ; +edits : edit edits + { $1->next = $2; $$ = $1; } + | + { $$ = 0; } + ; +edit : field eqop expr SEMI + { $$ = MiniXftEditCreate ($1, $2, $3); } + ; +eqop : EQUAL + { $$ = MiniXftOpAssign; } + | PLUS EQUAL + { $$ = MiniXftOpPrepend; } + | EQUAL PLUS + { $$ = MiniXftOpAppend; } + ; +expr : INTEGER + { $$ = MiniXftExprCreateInteger ($1); } + | DOUBLE + { $$ = MiniXftExprCreateDouble ($1); } + | STRING + { $$ = MiniXftExprCreateString ($1); } + | TOK_TRUE + { $$ = MiniXftExprCreateBool (True); } + | TOK_FALSE + { $$ = MiniXftExprCreateBool (False); } + | TOK_NIL + { $$ = MiniXftExprCreateNil (); } + | matrix + { $$ = MiniXftExprCreateMatrix (&matrix); } + | NAME + { $$ = MiniXftExprCreateField ($1); } + | expr OROR expr + { $$ = MiniXftExprCreateOp ($1, MiniXftOpOr, $3); } + | expr ANDAND expr + { $$ = MiniXftExprCreateOp ($1, MiniXftOpAnd, $3); } + | expr EQEQ expr + { $$ = MiniXftExprCreateOp ($1, MiniXftOpEqual, $3); } + | expr NOTEQ expr + { $$ = MiniXftExprCreateOp ($1, MiniXftOpNotEqual, $3); } + | expr LESS expr + { $$ = MiniXftExprCreateOp ($1, MiniXftOpLess, $3); } + | expr LESSEQ expr + { $$ = MiniXftExprCreateOp ($1, MiniXftOpLessEqual, $3); } + | expr MORE expr + { $$ = MiniXftExprCreateOp ($1, MiniXftOpMore, $3); } + | expr MOREEQ expr + { $$ = MiniXftExprCreateOp ($1, MiniXftOpMoreEqual, $3); } + | expr PLUS expr + { $$ = MiniXftExprCreateOp ($1, MiniXftOpPlus, $3); } + | expr MINUS expr + { $$ = MiniXftExprCreateOp ($1, MiniXftOpMinus, $3); } + | expr TIMES expr + { $$ = MiniXftExprCreateOp ($1, MiniXftOpTimes, $3); } + | expr DIVIDE expr + { $$ = MiniXftExprCreateOp ($1, MiniXftOpDivide, $3); } + | NOT expr + { $$ = MiniXftExprCreateOp ($2, MiniXftOpNot, (MiniXftExpr *) 0); } + | expr QUEST expr COLON expr + { $$ = MiniXftExprCreateOp ($1, MiniXftOpQuest, MiniXftExprCreateOp ($3, MiniXftOpQuest, $5)); } + ; +%% + +int +MiniXftConfigwrap (void) +{ + return 1; +} + +void +MiniXftConfigerror (char *fmt, ...) +{ + va_list args; + + fprintf (stderr, "\"%s\": line %d, ", MiniXftConfigFile, MiniXftConfigLineno); + va_start (args, fmt); + vfprintf (stderr, fmt, args); + va_end (args); + fprintf (stderr, "\n"); +} + +MiniXftTest * +MiniXftTestCreate (MiniXftQual qual, const char *field, MiniXftOp compare, MiniXftValue value) +{ + MiniXftTest *test = (MiniXftTest *) malloc (sizeof (MiniXftTest));; + + if (test) + { + test->next = 0; + test->qual = qual; + test->field = field; /* already saved in grammar */ + test->op = compare; + if (value.type == MiniXftTypeString) + value.u.s = _MiniXftSaveString (value.u.s); + else if (value.type == MiniXftTypeMatrix) + value.u.m = _MiniXftSaveMatrix (value.u.m); + test->value = value; + } + return test; +} + +MiniXftExpr * +MiniXftExprCreateInteger (int i) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = MiniXftOpInteger; + e->u.ival = i; + } + return e; +} + +MiniXftExpr * +MiniXftExprCreateDouble (double d) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = MiniXftOpDouble; + e->u.dval = d; + } + return e; +} + +MiniXftExpr * +MiniXftExprCreateString (const char *s) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = MiniXftOpString; + e->u.sval = _MiniXftSaveString (s); + } + return e; +} + +MiniXftExpr * +MiniXftExprCreateMatrix (const MiniXftMatrix *m) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = MiniXftOpMatrix; + e->u.mval = _MiniXftSaveMatrix (m); + } + return e; +} + +MiniXftExpr * +MiniXftExprCreateBool (Bool b) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = MiniXftOpBool; + e->u.bval = b; + } + return e; +} + +MiniXftExpr * +MiniXftExprCreateNil (void) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = MiniXftOpNil; + } + return e; +} + +MiniXftExpr * +MiniXftExprCreateField (const char *field) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = MiniXftOpField; + e->u.field = _MiniXftSaveString (field); + } + return e; +} + +MiniXftExpr * +MiniXftExprCreateOp (MiniXftExpr *left, MiniXftOp op, MiniXftExpr *right) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = op; + e->u.tree.left = left; + e->u.tree.right = right; + } + return e; +} + +void +MiniXftExprDestroy (MiniXftExpr *e) +{ + switch (e->op) { + case MiniXftOpInteger: + break; + case MiniXftOpDouble: + break; + case MiniXftOpString: + free (e->u.sval); + break; + case MiniXftOpMatrix: + free (e->u.mval); + break; + case MiniXftOpBool: + break; + case MiniXftOpField: + free (e->u.field); + break; + case MiniXftOpAssign: + case MiniXftOpPrepend: + case MiniXftOpAppend: + break; + case MiniXftOpOr: + case MiniXftOpAnd: + case MiniXftOpEqual: + case MiniXftOpNotEqual: + case MiniXftOpLess: + case MiniXftOpLessEqual: + case MiniXftOpMore: + case MiniXftOpMoreEqual: + case MiniXftOpPlus: + case MiniXftOpMinus: + case MiniXftOpTimes: + case MiniXftOpDivide: + case MiniXftOpQuest: + MiniXftExprDestroy (e->u.tree.right); + /* fall through */ + case MiniXftOpNot: + MiniXftExprDestroy (e->u.tree.left); + break; + case MiniXftOpNil: + break; + } + free (e); +} + +MiniXftEdit * +MiniXftEditCreate (const char *field, MiniXftOp op, MiniXftExpr *expr) +{ + MiniXftEdit *e = (MiniXftEdit *) malloc (sizeof (MiniXftEdit)); + + if (e) + { + e->next = 0; + e->field = field; /* already saved in grammar */ + e->op = op; + e->expr = expr; + } + return e; +} + +void +MiniXftEditDestroy (MiniXftEdit *e) +{ + if (e->next) + MiniXftEditDestroy (e->next); + free ((void *) e->field); + if (e->expr) + MiniXftExprDestroy (e->expr); +} + +char * +MiniXftConfigSaveField (const char *field) +{ + return _MiniXftSaveString (field); +} diff --git a/pango/mini-xft/minixftinit.c b/pango/mini-xft/minixftinit.c new file mode 100644 index 00000000..9a995044 --- /dev/null +++ b/pango/mini-xft/minixftinit.c @@ -0,0 +1,48 @@ +/* + * $XFree86: xc/lib/MiniXft/xftinit.c,v 1.2 2000/12/15 17:12:53 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include <stdlib.h> +#include "minixftint.h" + +MiniXftFontSet *_MiniXftFontSet; +Bool _MiniXftConfigInitialized; + +Bool +MiniXftInit (char *config) +{ + if (_MiniXftConfigInitialized) + return True; + _MiniXftConfigInitialized = True; + if (!config) + { + config = getenv ("XFT_CONFIG"); + if (!config) + config = XFT_DEFAULT_PATH; + } + if (MiniXftConfigLexFile (config)) + { + MiniXftConfigparse (); + } + return True; +} diff --git a/pango/mini-xft/minixftint.h b/pango/mini-xft/minixftint.h new file mode 100644 index 00000000..22f937a9 --- /dev/null +++ b/pango/mini-xft/minixftint.h @@ -0,0 +1,395 @@ +/* + * $XFree86: xc/lib/MiniXft/minixftint.h,v 1.26 2001/07/13 18:16:10 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _XFTINT_H_ +#define _XFTINT_H_ + +#include "MiniXftFreetype.h" + +typedef struct _MiniXftMatcher { + char *object; + double (*compare) (char *object, MiniXftValue value1, MiniXftValue value2); +} MiniXftMatcher; + +typedef struct _MiniXftSymbolic { + const char *name; + int value; +} MiniXftSymbolic; + +#define XFT_DRAW_N_SRC 2 + +#define XFT_DRAW_SRC_TEXT 0 +#define XFT_DRAW_SRC_RECT 1 + +typedef struct _MiniXftDisplayInfo { + struct _MiniXftDisplayInfo *next; + Display *display; + // XExtCodes *codes; + MiniXftPattern *defaults; + // MiniXftFontSet *coreFonts; + Bool hasRender; +} MiniXftDisplayInfo; + +extern MiniXftDisplayInfo *_MiniXftDisplayInfo; +extern MiniXftFontSet *_MiniXftGlobalFontSet; +extern char **MiniXftConfigDirs; +extern MiniXftFontSet *_MiniXftFontSet; + +#define XFT_NMISSING 256 + +#ifndef XFT_DEFAULT_PATH +#define XFT_DEFAULT_PATH "/usr/X11R6/lib/X11/XftConfig" +#endif + +#define XFT_DBG_OPEN 1 +#define XFT_DBG_OPENV 2 +#define XFT_DBG_RENDER 4 +#define XFT_DBG_DRAW 8 +#define XFT_DBG_REF 16 +#define XFT_DBG_GLYPH 32 +#define XFT_DBG_GLYPHV 64 +#define XFT_DBG_CACHE 128 +#define XFT_DBG_CACHEV 256 +#define XFT_DBG_MATCH 512 +#define XFT_DBG_MATCHV 1024 + +typedef enum _MiniXftOp { + MiniXftOpInteger, MiniXftOpDouble, MiniXftOpString, MiniXftOpMatrix, MiniXftOpBool, MiniXftOpNil, + MiniXftOpField, + MiniXftOpAssign, MiniXftOpPrepend, MiniXftOpAppend, + MiniXftOpQuest, + MiniXftOpOr, MiniXftOpAnd, MiniXftOpEqual, MiniXftOpNotEqual, + MiniXftOpLess, MiniXftOpLessEqual, MiniXftOpMore, MiniXftOpMoreEqual, + MiniXftOpPlus, MiniXftOpMinus, MiniXftOpTimes, MiniXftOpDivide, + MiniXftOpNot +} MiniXftOp; + +typedef struct _MiniXftExpr { + MiniXftOp op; + union { + int ival; + double dval; + char *sval; + MiniXftMatrix *mval; + Bool bval; + char *field; + struct { + struct _MiniXftExpr *left, *right; + } tree; + } u; +} MiniXftExpr; + +typedef enum _MiniXftQual { + MiniXftQualAny, MiniXftQualAll +} MiniXftQual; + +typedef struct _MiniXftTest { + struct _MiniXftTest *next; + MiniXftQual qual; + const char *field; + MiniXftOp op; + MiniXftValue value; +} MiniXftTest; + +typedef struct _MiniXftEdit { + struct _MiniXftEdit *next; + const char *field; + MiniXftOp op; + MiniXftExpr *expr; +} MiniXftEdit; + +typedef struct _MiniXftSubst { + struct _MiniXftSubst *next; + MiniXftTest *test; + MiniXftEdit *edit; +} MiniXftSubst; + +/* + * I tried this with functions that took va_list* arguments + * but portability concerns made me change these functions + * into macros (sigh). + */ + +#define _MiniXftPatternVapBuild(result, orig, va) \ +{ \ + MiniXftPattern *__p__ = (orig); \ + const char *__o__; \ + MiniXftValue __v__; \ + \ + if (!__p__) \ + { \ + __p__ = MiniXftPatternCreate (); \ + if (!__p__) \ + goto _MiniXftPatternVapBuild_bail0; \ + } \ + for (;;) \ + { \ + __o__ = va_arg (va, const char *); \ + if (!__o__) \ + break; \ + __v__.type = va_arg (va, MiniXftType); \ + switch (__v__.type) { \ + case MiniXftTypeVoid: \ + goto _MiniXftPatternVapBuild_bail1; \ + case MiniXftTypeInteger: \ + __v__.u.i = va_arg (va, int); \ + break; \ + case MiniXftTypeDouble: \ + __v__.u.d = va_arg (va, double); \ + break; \ + case MiniXftTypeString: \ + __v__.u.s = va_arg (va, char *); \ + break; \ + case MiniXftTypeBool: \ + __v__.u.b = va_arg (va, Bool); \ + break; \ + case MiniXftTypeMatrix: \ + __v__.u.m = va_arg (va, MiniXftMatrix *); \ + break; \ + } \ + if (!MiniXftPatternAdd (__p__, __o__, __v__, True)) \ + goto _MiniXftPatternVapBuild_bail1; \ + } \ + result = __p__; \ + goto _MiniXftPatternVapBuild_return; \ + \ +_MiniXftPatternVapBuild_bail1: \ + if (!orig) \ + MiniXftPatternDestroy (__p__); \ +_MiniXftPatternVapBuild_bail0: \ + result = 0; \ + \ +_MiniXftPatternVapBuild_return: \ + ; \ +} + + +/* xftcache.c */ + +char * +MiniXftFileCacheFind (char *file, int id, int *count); + +void +MiniXftFileCacheDispose (void); + +void +MiniXftFileCacheLoad (char *cache); + +Bool +MiniXftFileCacheUpdate (char *file, int id, char *name); + +Bool +MiniXftFileCacheSave (char *cache); + +Bool +MiniXftFileCacheReadDir (MiniXftFontSet *set, const char *cache_file); + +Bool +MiniXftFileCacheWriteDir (MiniXftFontSet *set, const char *cache_file); + +/* xftcfg.c */ +Bool +MiniXftConfigAddDir (char *d); + +Bool +MiniXftConfigSetCache (char *c); + +char * +MiniXftConfigGetCache (void); + +Bool +MiniXftConfigAddEdit (MiniXftTest *test, MiniXftEdit *edit); + +Bool +_MiniXftConfigCompareValue (MiniXftValue m, + MiniXftOp op, + MiniXftValue v); + +/* xftdbg.c */ +void +MiniXftOpPrint (MiniXftOp op); + +void +MiniXftTestPrint (MiniXftTest *test); + +void +MiniXftExprPrint (MiniXftExpr *expr); + +void +MiniXftEditPrint (MiniXftEdit *edit); + +void +MiniXftSubstPrint (MiniXftSubst *subst); + +/* xftdpy.c */ +int +MiniXftDefaultParseBool (char *v); + +Bool +MiniXftDefaultGetBool (Display *dpy, const char *object, int screen, Bool def); + +int +MiniXftDefaultGetInteger (Display *dpy, const char *object, int screen, int def); + +double +MiniXftDefaultGetDouble (Display *dpy, const char *object, int screen, double def); + +MiniXftFontSet * +MiniXftDisplayGetFontSet (Display *dpy); + +/* xftextent.c */ +/* xftfont.c */ +int +_MiniXftFontDebug (void); + +/* xftfs.c */ +/* xftgram.y */ +int +MiniXftConfigparse (void); + +int +MiniXftConfigwrap (void); + +void +MiniXftConfigerror (char *fmt, ...); + +char * +MiniXftConfigSaveField (const char *field); + +MiniXftTest * +MiniXftTestCreate (MiniXftQual qual, const char *field, MiniXftOp compare, MiniXftValue value); + +MiniXftExpr * +MiniXftExprCreateInteger (int i); + +MiniXftExpr * +MiniXftExprCreateDouble (double d); + +MiniXftExpr * +MiniXftExprCreateString (const char *s); + +MiniXftExpr * +MiniXftExprCreateMatrix (const MiniXftMatrix *m); + +MiniXftExpr * +MiniXftExprCreateBool (Bool b); + +MiniXftExpr * +MiniXftExprCreateNil (void); + +MiniXftExpr * +MiniXftExprCreateField (const char *field); + +MiniXftExpr * +MiniXftExprCreateOp (MiniXftExpr *left, MiniXftOp op, MiniXftExpr *right); + +void +MiniXftExprDestroy (MiniXftExpr *e); + +MiniXftEdit * +MiniXftEditCreate (const char *field, MiniXftOp op, MiniXftExpr *expr); + +void +MiniXftEditDestroy (MiniXftEdit *e); + +/* xftinit.c */ + +/* xftlex.l */ +extern int MiniXftConfigLineno; +extern char *MiniXftConfigFile; + +int +MiniXftConfiglex (void); + +Bool +MiniXftConfigLexFile(char *s); + +Bool +MiniXftConfigPushInput (char *s, Bool complain); + +/* xftlist.c */ +Bool +MiniXftListValueCompare (MiniXftValue v1, + MiniXftValue v2); + +Bool +MiniXftListValueListCompare (MiniXftValueList *v1orig, + MiniXftValueList *v2orig, + MiniXftQual qual); + +Bool +MiniXftListMatch (MiniXftPattern *p, + MiniXftPattern *font, + MiniXftQual qual); + +Bool +MiniXftListAppend (MiniXftFontSet *s, + MiniXftPattern *font, + MiniXftObjectSet *os); + + +/* xftmatch.c */ + +/* xftname.c */ +Bool +MiniXftNameConstant (char *string, int *result); + +/* xftpat.c */ + +/* xftrender.c */ + +/* xftmatrix.c */ +MiniXftMatrix * +_MiniXftSaveMatrix (const MiniXftMatrix *mat); + +/* xftstr.c */ +char * +_MiniXftSaveString (const char *s); + +const char * +_MiniXftGetInt(const char *ptr, int *val); + +char * +_MiniXftSplitStr (const char *field, char *save); + +char * +_MiniXftDownStr (const char *field, char *save); + +const char * +_MiniXftSplitField (const char *field, char *save); + +const char * +_MiniXftSplitValue (const char *field, char *save); + +int +_MiniXftMatchSymbolic (MiniXftSymbolic *s, int n, const char *name, int def); + +int +_MiniXftStrCmpIgnoreCase (const char *s1, const char *s2); + +/* xftxlfd.c */ +Bool +MiniXftCoreAddFonts (MiniXftFontSet *set, Display *dpy, Bool ignore_scalable); + +#endif /* _XFT_INT_H_ */ diff --git a/pango/mini-xft/minixftlex.c b/pango/mini-xft/minixftlex.c new file mode 100644 index 00000000..4e901a6d --- /dev/null +++ b/pango/mini-xft/minixftlex.c @@ -0,0 +1,1985 @@ +/* A lexical scanner generated by flex */ + +/* Scanner skeleton version: + * $Header$ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include <stdio.h> +#include <unistd.h> + + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include <stdlib.h> + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include <io.h> +#include <stdlib.h> +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define MiniXftConfigconst const +#else +#define MiniXftConfigconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN MiniXftConfig_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((MiniXftConfig_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE MiniXftConfigrestart( MiniXftConfigin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct MiniXftConfig_buffer_state *YY_BUFFER_STATE; + +extern int MiniXftConfigleng; +extern FILE *MiniXftConfigin, *MiniXftConfigout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * MiniXftConfigless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the MiniXftConfigless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define MiniXftConfigless(n) \ + do \ + { \ + /* Undo effects of setting up MiniXftConfigtext. */ \ + *MiniXftConfig_cp = MiniXftConfig_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + MiniXftConfig_c_buf_p = MiniXftConfig_cp = MiniXftConfig_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up MiniXftConfigtext again */ \ + } \ + while ( 0 ) + +#define unput(c) MiniXftConfigunput( c, MiniXftConfigtext_ptr ) + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int MiniXftConfig_size_t; + + +struct MiniXftConfig_buffer_state + { + FILE *MiniXftConfig_input_file; + + char *MiniXftConfig_ch_buf; /* input buffer */ + char *MiniXftConfig_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + MiniXftConfig_size_t MiniXftConfig_buf_size; + + /* Number of characters read into MiniXftConfig_ch_buf, not including EOB + * characters. + */ + int MiniXftConfig_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int MiniXftConfig_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int MiniXftConfig_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int MiniXftConfig_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int MiniXftConfig_fill_buffer; + + int MiniXftConfig_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via MiniXftConfigrestart()), so that the user can continue scanning by + * just pointing MiniXftConfigin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE MiniXftConfig_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER MiniXftConfig_current_buffer + + +/* MiniXftConfig_hold_char holds the character lost when MiniXftConfigtext is formed. */ +static char MiniXftConfig_hold_char; + +static int MiniXftConfig_n_chars; /* number of characters read into MiniXftConfig_ch_buf */ + + +int MiniXftConfigleng; + +/* Points to current character in buffer. */ +static char *MiniXftConfig_c_buf_p = (char *) 0; +static int MiniXftConfig_init = 1; /* whether we need to initialize */ +static int MiniXftConfig_start = 0; /* start state number */ + +/* Flag which is used to allow MiniXftConfigwrap()'s to do buffer switches + * instead of setting up a fresh MiniXftConfigin. A bit of a hack ... + */ +static int MiniXftConfig_did_buffer_switch_on_eof; + +void MiniXftConfigrestart YY_PROTO(( FILE *input_file )); + +void MiniXftConfig_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void MiniXftConfig_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE MiniXftConfig_create_buffer YY_PROTO(( FILE *file, int size )); +void MiniXftConfig_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void MiniXftConfig_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void MiniXftConfig_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER MiniXftConfig_flush_buffer( MiniXftConfig_current_buffer ) + +YY_BUFFER_STATE MiniXftConfig_scan_buffer YY_PROTO(( char *base, MiniXftConfig_size_t size )); +YY_BUFFER_STATE MiniXftConfig_scan_string YY_PROTO(( MiniXftConfigconst char *MiniXftConfig_str )); +YY_BUFFER_STATE MiniXftConfig_scan_bytes YY_PROTO(( MiniXftConfigconst char *bytes, int len )); + +static void *MiniXftConfig_flex_alloc YY_PROTO(( MiniXftConfig_size_t )); +static void *MiniXftConfig_flex_realloc YY_PROTO(( void *, MiniXftConfig_size_t )); +static void MiniXftConfig_flex_free YY_PROTO(( void * )); + +#define MiniXftConfig_new_buffer MiniXftConfig_create_buffer + +#define MiniXftConfig_set_interactive(is_interactive) \ + { \ + if ( ! MiniXftConfig_current_buffer ) \ + MiniXftConfig_current_buffer = MiniXftConfig_create_buffer( MiniXftConfigin, YY_BUF_SIZE ); \ + MiniXftConfig_current_buffer->MiniXftConfig_is_interactive = is_interactive; \ + } + +#define MiniXftConfig_set_bol(at_bol) \ + { \ + if ( ! MiniXftConfig_current_buffer ) \ + MiniXftConfig_current_buffer = MiniXftConfig_create_buffer( MiniXftConfigin, YY_BUF_SIZE ); \ + MiniXftConfig_current_buffer->MiniXftConfig_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (MiniXftConfig_current_buffer->MiniXftConfig_at_bol) + +typedef unsigned char YY_CHAR; +FILE *MiniXftConfigin = (FILE *) 0, *MiniXftConfigout = (FILE *) 0; +typedef int MiniXftConfig_state_type; +extern char *MiniXftConfigtext; +#define MiniXftConfigtext_ptr MiniXftConfigtext + +static MiniXftConfig_state_type MiniXftConfig_get_previous_state YY_PROTO(( void )); +static MiniXftConfig_state_type MiniXftConfig_try_NUL_trans YY_PROTO(( MiniXftConfig_state_type current_state )); +static int MiniXftConfig_get_next_buffer YY_PROTO(( void )); +static void MiniXftConfig_fatal_error YY_PROTO(( MiniXftConfigconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up MiniXftConfigtext. + */ +#define YY_DO_BEFORE_ACTION \ + MiniXftConfigtext_ptr = MiniXftConfig_bp; \ + MiniXftConfigleng = (int) (MiniXftConfig_cp - MiniXftConfig_bp); \ + MiniXftConfig_hold_char = *MiniXftConfig_cp; \ + *MiniXftConfig_cp = '\0'; \ + MiniXftConfig_c_buf_p = MiniXftConfig_cp; + +#define YY_NUM_RULES 39 +#define YY_END_OF_BUFFER 40 +static MiniXftConfigconst short int MiniXftConfig_accept[94] = + { 0, + 0, 0, 40, 37, 38, 21, 37, 37, 19, 17, + 18, 37, 20, 34, 15, 16, 24, 14, 28, 30, + 36, 31, 32, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 37, 2, 29, 0, 33, 0, 22, 35, + 0, 1, 35, 34, 0, 25, 26, 27, 36, 36, + 36, 36, 36, 36, 36, 36, 36, 36, 36, 23, + 33, 0, 35, 0, 0, 35, 13, 12, 36, 3, + 36, 36, 36, 36, 11, 36, 35, 0, 36, 8, + 36, 36, 36, 9, 4, 10, 36, 7, 36, 5, + 36, 6, 0 + + } ; + +static MiniXftConfigconst int MiniXftConfig_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 3, 4, 5, 1, 1, 6, 1, 1, + 1, 7, 8, 1, 9, 10, 11, 12, 12, 12, + 12, 12, 12, 12, 12, 12, 12, 13, 14, 15, + 16, 17, 18, 1, 19, 19, 19, 19, 20, 19, + 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, + 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, + 21, 22, 23, 1, 24, 1, 25, 19, 26, 27, + + 28, 29, 19, 30, 31, 19, 19, 32, 33, 34, + 19, 19, 19, 35, 36, 37, 38, 19, 19, 19, + 39, 19, 40, 41, 42, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static MiniXftConfigconst int MiniXftConfig_meta[43] = + { 0, + 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 3, 1, 1, 1, 1, 1, 1, 3, 3, + 1, 1, 1, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 1, + 1, 1 + } ; + +static MiniXftConfigconst short int MiniXftConfig_base[96] = + { 0, + 0, 126, 130, 132, 132, 113, 39, 122, 132, 132, + 132, 32, 120, 35, 132, 132, 110, 109, 108, 132, + 0, 132, 132, 14, 98, 91, 94, 95, 85, 93, + 86, 81, 74, 132, 132, 45, 132, 46, 132, 42, + 102, 132, 45, 46, 67, 132, 132, 132, 0, 81, + 73, 85, 75, 77, 73, 78, 66, 70, 63, 132, + 47, 41, 66, 88, 87, 86, 0, 0, 67, 0, + 59, 59, 61, 66, 0, 63, 32, 47, 62, 0, + 60, 49, 54, 0, 0, 0, 54, 0, 52, 46, + 42, 0, 132, 106, 61 + + } ; + +static MiniXftConfigconst short int MiniXftConfig_def[96] = + { 0, + 93, 1, 93, 93, 93, 93, 94, 93, 93, 93, + 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, + 95, 93, 93, 95, 95, 95, 95, 95, 95, 95, + 95, 95, 93, 93, 93, 94, 93, 94, 93, 93, + 93, 93, 93, 93, 93, 93, 93, 93, 95, 95, + 95, 95, 95, 95, 95, 95, 95, 95, 95, 93, + 94, 93, 93, 93, 93, 93, 95, 95, 95, 95, + 95, 95, 95, 95, 95, 95, 93, 93, 95, 95, + 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, + 95, 95, 0, 93, 93 + + } ; + +static MiniXftConfigconst short int MiniXftConfig_nxt[175] = + { 0, + 4, 5, 6, 7, 4, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 21, + 22, 4, 23, 4, 24, 25, 26, 27, 28, 21, + 29, 21, 30, 31, 21, 21, 32, 21, 21, 4, + 33, 4, 37, 40, 43, 50, 44, 51, 37, 61, + 37, 45, 62, 40, 45, 43, 63, 44, 78, 45, + 38, 45, 45, 49, 45, 45, 38, 38, 38, 45, + 92, 41, 45, 45, 65, 65, 91, 63, 66, 90, + 89, 41, 77, 88, 64, 45, 87, 86, 77, 85, + 84, 83, 82, 45, 81, 80, 79, 66, 66, 78, + + 76, 75, 74, 73, 72, 64, 36, 71, 36, 70, + 69, 68, 67, 62, 60, 59, 58, 57, 56, 55, + 54, 53, 52, 48, 47, 46, 42, 39, 35, 93, + 34, 3, 93, 93, 93, 93, 93, 93, 93, 93, + 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, + 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, + 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, + 93, 93, 93, 93 + } ; + +static MiniXftConfigconst short int MiniXftConfig_chk[175] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 7, 12, 14, 24, 14, 24, 36, 38, + 61, 77, 62, 40, 14, 44, 43, 44, 78, 77, + 7, 40, 14, 95, 43, 44, 36, 38, 61, 40, + 91, 12, 43, 44, 45, 45, 90, 63, 45, 89, + 87, 40, 62, 83, 43, 63, 82, 81, 78, 79, + 76, 74, 73, 63, 72, 71, 69, 66, 65, 64, + + 59, 58, 57, 56, 55, 63, 94, 54, 94, 53, + 52, 51, 50, 41, 33, 32, 31, 30, 29, 28, + 27, 26, 25, 19, 18, 17, 13, 8, 6, 3, + 2, 93, 93, 93, 93, 93, 93, 93, 93, 93, + 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, + 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, + 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, + 93, 93, 93, 93 + } ; + +static MiniXftConfig_state_type MiniXftConfig_last_accepting_state; +static char *MiniXftConfig_last_accepting_cpos; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define MiniXftConfigmore() MiniXftConfigmore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *MiniXftConfigtext; +#line 1 "minixftlex.l" +#define INITIAL 0 +#line 2 "minixftlex.l" +/* + * $XFree86: xc/lib/MiniXft/xftlex.l,v 1.7 2001/05/18 16:03:06 tsi Exp $ + * + * Copyright (c) 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include <string.h> +#include "minixftint.h" + +#include "minixftgram.h" + +int MiniXftConfigLineno; + +static void _MiniXftConfigSkipComment (void); + +static void _MiniXftConfigSkipLine (void); + +static int _MiniXftConfigPopInput (void); + + +#define XFT_CONFIG_IN_DEEP 20 +FILE *MiniXftConfigInStack[XFT_CONFIG_IN_DEEP]; +FILE **MiniXftConfigInpt = MiniXftConfigInStack + XFT_CONFIG_IN_DEEP; +FILE *MiniXftConfigInput; +int MiniXftConfigLinenos[XFT_CONFIG_IN_DEEP]; +int *MiniXftConfigLinenopt = MiniXftConfigLinenos + XFT_CONFIG_IN_DEEP; +char *MiniXftConfigFile = ""; +char *MiniXftConfigFileNames[XFT_CONFIG_IN_DEEP]; +char **MiniXftConfigFileNamePt = MiniXftConfigFileNames + XFT_CONFIG_IN_DEEP; +int MiniXftConfigFiledeep = 0; + +#undef YY_INPUT + +#define YY_INPUT(buf,result,max_size) \ +{ \ + int c; \ + result = 0; \ + while (result < max_size) { \ + c = getc (MiniXftConfigInput); \ + if (c < 0) { \ + c = _MiniXftConfigPopInput (); \ + if (c < 0) \ + break; \ + } \ + buf[result++] = c; \ + if (c == '\n') \ + { \ + MiniXftConfigLineno++; \ + break; \ + } \ + } \ +} + +#ifndef FLEX_SCANNER +#undef input +#undef unput +static int input (void) +{ + char buf[1]; + static int r = EOF; + + if (r == 0) + return 0; + YY_INPUT(buf, r, 1); + if (r == 0) + return EOF; + return buf[0]; +} + +static void unput (char c) +{ + if (!c || c == EOF) + return; + if (c == '\n') + MiniXftConfigLineno--; + ungetc (c, MiniXftConfigInput); +} +#endif + +#line 531 "lex.MiniXftConfig.c" + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int MiniXftConfigwrap YY_PROTO(( void )); +#else +extern int MiniXftConfigwrap YY_PROTO(( void )); +#endif +#endif + +#ifndef YY_NO_UNPUT +static void MiniXftConfigunput YY_PROTO(( int c, char *buf_ptr )); +#endif + +#ifndef MiniXftConfigtext_ptr +static void MiniXftConfig_flex_strncpy YY_PROTO(( char *, MiniXftConfigconst char *, int )); +#endif + +#ifdef YY_NEED_STRLEN +static int MiniXftConfig_flex_strlen YY_PROTO(( MiniXftConfigconst char * )); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int MiniXftConfiginput YY_PROTO(( void )); +#else +static int input YY_PROTO(( void )); +#endif +#endif + +#if YY_STACK_USED +static int MiniXftConfig_start_stack_ptr = 0; +static int MiniXftConfig_start_stack_depth = 0; +static int *MiniXftConfig_start_stack = 0; +#ifndef YY_NO_PUSH_STATE +static void MiniXftConfig_push_state YY_PROTO(( int new_state )); +#endif +#ifndef YY_NO_POP_STATE +static void MiniXftConfig_pop_state YY_PROTO(( void )); +#endif +#ifndef YY_NO_TOP_STATE +static int MiniXftConfig_top_state YY_PROTO(( void )); +#endif + +#else +#define YY_NO_PUSH_STATE 1 +#define YY_NO_POP_STATE 1 +#define YY_NO_TOP_STATE 1 +#endif + +#ifdef YY_MALLOC_DECL +YY_MALLOC_DECL +#else +#if __STDC__ +#ifndef __cplusplus +#include <stdlib.h> +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( MiniXftConfigtext, MiniXftConfigleng, 1, MiniXftConfigout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( MiniXftConfig_current_buffer->MiniXftConfig_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( MiniXftConfigin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( MiniXftConfigin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else if ( ((result = fread( buf, 1, max_size, MiniXftConfigin )) == 0) \ + && ferror( MiniXftConfigin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); +#endif + +/* No semi-colon after return; correct usage is to write "MiniXftConfigterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef MiniXftConfigterminate +#define MiniXftConfigterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) MiniXftConfig_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int MiniXftConfiglex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after MiniXftConfigtext and MiniXftConfigleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + if ( MiniXftConfigleng > 0 ) \ + MiniXftConfig_current_buffer->MiniXftConfig_at_bol = \ + (MiniXftConfigtext[MiniXftConfigleng - 1] == '\n'); \ + YY_USER_ACTION + +YY_DECL + { + register MiniXftConfig_state_type MiniXftConfig_current_state; + register char *MiniXftConfig_cp = NULL, *MiniXftConfig_bp = NULL; + register int MiniXftConfig_act; + +#line 100 "minixftlex.l" + +#line 687 "lex.MiniXftConfig.c" + + if ( MiniXftConfig_init ) + { + MiniXftConfig_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! MiniXftConfig_start ) + MiniXftConfig_start = 1; /* first start state */ + + if ( ! MiniXftConfigin ) + MiniXftConfigin = stdin; + + if ( ! MiniXftConfigout ) + MiniXftConfigout = stdout; + + if ( ! MiniXftConfig_current_buffer ) + MiniXftConfig_current_buffer = + MiniXftConfig_create_buffer( MiniXftConfigin, YY_BUF_SIZE ); + + MiniXftConfig_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + MiniXftConfig_cp = MiniXftConfig_c_buf_p; + + /* Support of MiniXftConfigtext. */ + *MiniXftConfig_cp = MiniXftConfig_hold_char; + + /* MiniXftConfig_bp points to the position in MiniXftConfig_ch_buf of the start of + * the current run. + */ + MiniXftConfig_bp = MiniXftConfig_cp; + + MiniXftConfig_current_state = MiniXftConfig_start; + MiniXftConfig_current_state += YY_AT_BOL(); +MiniXftConfig_match: + do + { + register YY_CHAR MiniXftConfig_c = MiniXftConfig_ec[YY_SC_TO_UI(*MiniXftConfig_cp)]; + if ( MiniXftConfig_accept[MiniXftConfig_current_state] ) + { + MiniXftConfig_last_accepting_state = MiniXftConfig_current_state; + MiniXftConfig_last_accepting_cpos = MiniXftConfig_cp; + } + while ( MiniXftConfig_chk[MiniXftConfig_base[MiniXftConfig_current_state] + MiniXftConfig_c] != MiniXftConfig_current_state ) + { + MiniXftConfig_current_state = (int) MiniXftConfig_def[MiniXftConfig_current_state]; + if ( MiniXftConfig_current_state >= 94 ) + MiniXftConfig_c = MiniXftConfig_meta[(unsigned int) MiniXftConfig_c]; + } + MiniXftConfig_current_state = MiniXftConfig_nxt[MiniXftConfig_base[MiniXftConfig_current_state] + (unsigned int) MiniXftConfig_c]; + ++MiniXftConfig_cp; + } + while ( MiniXftConfig_base[MiniXftConfig_current_state] != 132 ); + +MiniXftConfig_find_action: + MiniXftConfig_act = MiniXftConfig_accept[MiniXftConfig_current_state]; + if ( MiniXftConfig_act == 0 ) + { /* have to back up */ + MiniXftConfig_cp = MiniXftConfig_last_accepting_cpos; + MiniXftConfig_current_state = MiniXftConfig_last_accepting_state; + MiniXftConfig_act = MiniXftConfig_accept[MiniXftConfig_current_state]; + } + + YY_DO_BEFORE_ACTION; + + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( MiniXftConfig_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *MiniXftConfig_cp = MiniXftConfig_hold_char; + MiniXftConfig_cp = MiniXftConfig_last_accepting_cpos; + MiniXftConfig_current_state = MiniXftConfig_last_accepting_state; + goto MiniXftConfig_find_action; + +case 1: +YY_RULE_SETUP +#line 101 "minixftlex.l" +_MiniXftConfigSkipComment(); + YY_BREAK +case 2: +YY_RULE_SETUP +#line 102 "minixftlex.l" +_MiniXftConfigSkipLine(); + YY_BREAK +case 3: +YY_RULE_SETUP +#line 103 "minixftlex.l" +return DIR; + YY_BREAK +case 4: +YY_RULE_SETUP +#line 104 "minixftlex.l" +return CACHE; + YY_BREAK +case 5: +YY_RULE_SETUP +#line 105 "minixftlex.l" +return INCLUDE; + YY_BREAK +case 6: +YY_RULE_SETUP +#line 106 "minixftlex.l" +return INCLUDEIF; + YY_BREAK +case 7: +YY_RULE_SETUP +#line 107 "minixftlex.l" +return MATCH; + YY_BREAK +case 8: +YY_RULE_SETUP +#line 108 "minixftlex.l" +return EDIT; + YY_BREAK +case 9: +YY_RULE_SETUP +#line 109 "minixftlex.l" +return TOK_TRUE; + YY_BREAK +case 10: +YY_RULE_SETUP +#line 110 "minixftlex.l" +return TOK_FALSE; + YY_BREAK +case 11: +YY_RULE_SETUP +#line 111 "minixftlex.l" +return TOK_NIL; + YY_BREAK +case 12: +YY_RULE_SETUP +#line 112 "minixftlex.l" +return ANY; + YY_BREAK +case 13: +YY_RULE_SETUP +#line 113 "minixftlex.l" +return ALL; + YY_BREAK +case 14: +YY_RULE_SETUP +#line 114 "minixftlex.l" +return EQUAL; + YY_BREAK +case 15: +YY_RULE_SETUP +#line 115 "minixftlex.l" +return COLON; + YY_BREAK +case 16: +YY_RULE_SETUP +#line 116 "minixftlex.l" +return SEMI; + YY_BREAK +case 17: +YY_RULE_SETUP +#line 117 "minixftlex.l" +return PLUS; + YY_BREAK +case 18: +YY_RULE_SETUP +#line 118 "minixftlex.l" +return MINUS; + YY_BREAK +case 19: +YY_RULE_SETUP +#line 119 "minixftlex.l" +return TIMES; + YY_BREAK +case 20: +YY_RULE_SETUP +#line 120 "minixftlex.l" +return DIVIDE; + YY_BREAK +case 21: +YY_RULE_SETUP +#line 121 "minixftlex.l" +return NOT; + YY_BREAK +case 22: +YY_RULE_SETUP +#line 122 "minixftlex.l" +return ANDAND; + YY_BREAK +case 23: +YY_RULE_SETUP +#line 123 "minixftlex.l" +return OROR; + YY_BREAK +case 24: +YY_RULE_SETUP +#line 124 "minixftlex.l" +return LESS; + YY_BREAK +case 25: +YY_RULE_SETUP +#line 125 "minixftlex.l" +return LESSEQ; + YY_BREAK +case 26: +YY_RULE_SETUP +#line 126 "minixftlex.l" +return EQEQ; + YY_BREAK +case 27: +YY_RULE_SETUP +#line 127 "minixftlex.l" +return MOREEQ; + YY_BREAK +case 28: +YY_RULE_SETUP +#line 128 "minixftlex.l" +return MORE; + YY_BREAK +case 29: +YY_RULE_SETUP +#line 129 "minixftlex.l" +return NOTEQ; + YY_BREAK +case 30: +YY_RULE_SETUP +#line 130 "minixftlex.l" +return QUEST; + YY_BREAK +case 31: +YY_RULE_SETUP +#line 131 "minixftlex.l" +return OS; + YY_BREAK +case 32: +YY_RULE_SETUP +#line 132 "minixftlex.l" +return CS; + YY_BREAK +case 33: +YY_RULE_SETUP +#line 133 "minixftlex.l" +{ + MiniXftConfigtext[MiniXftConfigleng - 1] = '\0'; + MiniXftConfiglval.sval = MiniXftConfigtext+1; + return STRING; + } + YY_BREAK +case 34: +YY_RULE_SETUP +#line 138 "minixftlex.l" +{ + MiniXftConfiglval.ival = strtol (MiniXftConfigtext, 0, 10); + return INTEGER; + } + YY_BREAK +case 35: +YY_RULE_SETUP +#line 142 "minixftlex.l" +{ + MiniXftConfiglval.dval = strtod (MiniXftConfigtext, 0); + return DOUBLE; + } + YY_BREAK +case 36: +YY_RULE_SETUP +#line 146 "minixftlex.l" +{ + if (MiniXftNameConstant (MiniXftConfigtext, &MiniXftConfiglval.ival)) + return INTEGER; + MiniXftConfiglval.sval = MiniXftConfigtext; + return NAME; + } + YY_BREAK +case 37: +YY_RULE_SETUP +#line 152 "minixftlex.l" +; + YY_BREAK +case 38: +YY_RULE_SETUP +#line 153 "minixftlex.l" +; + YY_BREAK +case 39: +YY_RULE_SETUP +#line 154 "minixftlex.l" +ECHO; + YY_BREAK +#line 981 "lex.MiniXftConfig.c" +case YY_STATE_EOF(INITIAL): + MiniXftConfigterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int MiniXftConfig_amount_of_matched_text = (int) (MiniXftConfig_cp - MiniXftConfigtext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *MiniXftConfig_cp = MiniXftConfig_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( MiniXftConfig_current_buffer->MiniXftConfig_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed MiniXftConfigin at a new source and called + * MiniXftConfiglex(). If so, then we have to assure + * consistency between MiniXftConfig_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + MiniXftConfig_n_chars = MiniXftConfig_current_buffer->MiniXftConfig_n_chars; + MiniXftConfig_current_buffer->MiniXftConfig_input_file = MiniXftConfigin; + MiniXftConfig_current_buffer->MiniXftConfig_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for MiniXftConfig_c_buf_p "<=" to the position + * of the first EOB in the buffer, since MiniXftConfig_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( MiniXftConfig_c_buf_p <= &MiniXftConfig_current_buffer->MiniXftConfig_ch_buf[MiniXftConfig_n_chars] ) + { /* This was really a NUL. */ + MiniXftConfig_state_type MiniXftConfig_next_state; + + MiniXftConfig_c_buf_p = MiniXftConfigtext_ptr + MiniXftConfig_amount_of_matched_text; + + MiniXftConfig_current_state = MiniXftConfig_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * MiniXftConfig_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + MiniXftConfig_next_state = MiniXftConfig_try_NUL_trans( MiniXftConfig_current_state ); + + MiniXftConfig_bp = MiniXftConfigtext_ptr + YY_MORE_ADJ; + + if ( MiniXftConfig_next_state ) + { + /* Consume the NUL. */ + MiniXftConfig_cp = ++MiniXftConfig_c_buf_p; + MiniXftConfig_current_state = MiniXftConfig_next_state; + goto MiniXftConfig_match; + } + + else + { + MiniXftConfig_cp = MiniXftConfig_c_buf_p; + goto MiniXftConfig_find_action; + } + } + + else switch ( MiniXftConfig_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + MiniXftConfig_did_buffer_switch_on_eof = 0; + + if ( MiniXftConfigwrap() ) + { + /* Note: because we've taken care in + * MiniXftConfig_get_next_buffer() to have set up + * MiniXftConfigtext, we can now set up + * MiniXftConfig_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + MiniXftConfig_c_buf_p = MiniXftConfigtext_ptr + YY_MORE_ADJ; + + MiniXftConfig_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! MiniXftConfig_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + MiniXftConfig_c_buf_p = + MiniXftConfigtext_ptr + MiniXftConfig_amount_of_matched_text; + + MiniXftConfig_current_state = MiniXftConfig_get_previous_state(); + + MiniXftConfig_cp = MiniXftConfig_c_buf_p; + MiniXftConfig_bp = MiniXftConfigtext_ptr + YY_MORE_ADJ; + goto MiniXftConfig_match; + + case EOB_ACT_LAST_MATCH: + MiniXftConfig_c_buf_p = + &MiniXftConfig_current_buffer->MiniXftConfig_ch_buf[MiniXftConfig_n_chars]; + + MiniXftConfig_current_state = MiniXftConfig_get_previous_state(); + + MiniXftConfig_cp = MiniXftConfig_c_buf_p; + MiniXftConfig_bp = MiniXftConfigtext_ptr + YY_MORE_ADJ; + goto MiniXftConfig_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of MiniXftConfiglex */ + + +/* MiniXftConfig_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int MiniXftConfig_get_next_buffer() + { + register char *dest = MiniXftConfig_current_buffer->MiniXftConfig_ch_buf; + register char *source = MiniXftConfigtext_ptr; + register int number_to_move, i; + int ret_val; + + if ( MiniXftConfig_c_buf_p > &MiniXftConfig_current_buffer->MiniXftConfig_ch_buf[MiniXftConfig_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( MiniXftConfig_current_buffer->MiniXftConfig_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( MiniXftConfig_c_buf_p - MiniXftConfigtext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (MiniXftConfig_c_buf_p - MiniXftConfigtext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( MiniXftConfig_current_buffer->MiniXftConfig_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + MiniXftConfig_current_buffer->MiniXftConfig_n_chars = MiniXftConfig_n_chars = 0; + + else + { + int num_to_read = + MiniXftConfig_current_buffer->MiniXftConfig_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = MiniXftConfig_current_buffer; + + int MiniXftConfig_c_buf_p_offset = + (int) (MiniXftConfig_c_buf_p - b->MiniXftConfig_ch_buf); + + if ( b->MiniXftConfig_is_our_buffer ) + { + int new_size = b->MiniXftConfig_buf_size * 2; + + if ( new_size <= 0 ) + b->MiniXftConfig_buf_size += b->MiniXftConfig_buf_size / 8; + else + b->MiniXftConfig_buf_size *= 2; + + b->MiniXftConfig_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + MiniXftConfig_flex_realloc( (void *) b->MiniXftConfig_ch_buf, + b->MiniXftConfig_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->MiniXftConfig_ch_buf = 0; + + if ( ! b->MiniXftConfig_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + MiniXftConfig_c_buf_p = &b->MiniXftConfig_ch_buf[MiniXftConfig_c_buf_p_offset]; + + num_to_read = MiniXftConfig_current_buffer->MiniXftConfig_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&MiniXftConfig_current_buffer->MiniXftConfig_ch_buf[number_to_move]), + MiniXftConfig_n_chars, num_to_read ); + + MiniXftConfig_current_buffer->MiniXftConfig_n_chars = MiniXftConfig_n_chars; + } + + if ( MiniXftConfig_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + MiniXftConfigrestart( MiniXftConfigin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + MiniXftConfig_current_buffer->MiniXftConfig_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + MiniXftConfig_n_chars += number_to_move; + MiniXftConfig_current_buffer->MiniXftConfig_ch_buf[MiniXftConfig_n_chars] = YY_END_OF_BUFFER_CHAR; + MiniXftConfig_current_buffer->MiniXftConfig_ch_buf[MiniXftConfig_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + MiniXftConfigtext_ptr = &MiniXftConfig_current_buffer->MiniXftConfig_ch_buf[0]; + + return ret_val; + } + + +/* MiniXftConfig_get_previous_state - get the state just before the EOB char was reached */ + +static MiniXftConfig_state_type MiniXftConfig_get_previous_state() + { + register MiniXftConfig_state_type MiniXftConfig_current_state; + register char *MiniXftConfig_cp; + + MiniXftConfig_current_state = MiniXftConfig_start; + MiniXftConfig_current_state += YY_AT_BOL(); + + for ( MiniXftConfig_cp = MiniXftConfigtext_ptr + YY_MORE_ADJ; MiniXftConfig_cp < MiniXftConfig_c_buf_p; ++MiniXftConfig_cp ) + { + register YY_CHAR MiniXftConfig_c = (*MiniXftConfig_cp ? MiniXftConfig_ec[YY_SC_TO_UI(*MiniXftConfig_cp)] : 1); + if ( MiniXftConfig_accept[MiniXftConfig_current_state] ) + { + MiniXftConfig_last_accepting_state = MiniXftConfig_current_state; + MiniXftConfig_last_accepting_cpos = MiniXftConfig_cp; + } + while ( MiniXftConfig_chk[MiniXftConfig_base[MiniXftConfig_current_state] + MiniXftConfig_c] != MiniXftConfig_current_state ) + { + MiniXftConfig_current_state = (int) MiniXftConfig_def[MiniXftConfig_current_state]; + if ( MiniXftConfig_current_state >= 94 ) + MiniXftConfig_c = MiniXftConfig_meta[(unsigned int) MiniXftConfig_c]; + } + MiniXftConfig_current_state = MiniXftConfig_nxt[MiniXftConfig_base[MiniXftConfig_current_state] + (unsigned int) MiniXftConfig_c]; + } + + return MiniXftConfig_current_state; + } + + +/* MiniXftConfig_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = MiniXftConfig_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static MiniXftConfig_state_type MiniXftConfig_try_NUL_trans( MiniXftConfig_state_type MiniXftConfig_current_state ) +#else +static MiniXftConfig_state_type MiniXftConfig_try_NUL_trans( MiniXftConfig_current_state ) +MiniXftConfig_state_type MiniXftConfig_current_state; +#endif + { + register int MiniXftConfig_is_jam; + register char *MiniXftConfig_cp = MiniXftConfig_c_buf_p; + + register YY_CHAR MiniXftConfig_c = 1; + if ( MiniXftConfig_accept[MiniXftConfig_current_state] ) + { + MiniXftConfig_last_accepting_state = MiniXftConfig_current_state; + MiniXftConfig_last_accepting_cpos = MiniXftConfig_cp; + } + while ( MiniXftConfig_chk[MiniXftConfig_base[MiniXftConfig_current_state] + MiniXftConfig_c] != MiniXftConfig_current_state ) + { + MiniXftConfig_current_state = (int) MiniXftConfig_def[MiniXftConfig_current_state]; + if ( MiniXftConfig_current_state >= 94 ) + MiniXftConfig_c = MiniXftConfig_meta[(unsigned int) MiniXftConfig_c]; + } + MiniXftConfig_current_state = MiniXftConfig_nxt[MiniXftConfig_base[MiniXftConfig_current_state] + (unsigned int) MiniXftConfig_c]; + MiniXftConfig_is_jam = (MiniXftConfig_current_state == 93); + + return MiniXftConfig_is_jam ? 0 : MiniXftConfig_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void MiniXftConfigunput( int c, register char *MiniXftConfig_bp ) +#else +static void MiniXftConfigunput( c, MiniXftConfig_bp ) +int c; +register char *MiniXftConfig_bp; +#endif + { + register char *MiniXftConfig_cp = MiniXftConfig_c_buf_p; + + /* undo effects of setting up MiniXftConfigtext */ + *MiniXftConfig_cp = MiniXftConfig_hold_char; + + if ( MiniXftConfig_cp < MiniXftConfig_current_buffer->MiniXftConfig_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = MiniXftConfig_n_chars + 2; + register char *dest = &MiniXftConfig_current_buffer->MiniXftConfig_ch_buf[ + MiniXftConfig_current_buffer->MiniXftConfig_buf_size + 2]; + register char *source = + &MiniXftConfig_current_buffer->MiniXftConfig_ch_buf[number_to_move]; + + while ( source > MiniXftConfig_current_buffer->MiniXftConfig_ch_buf ) + *--dest = *--source; + + MiniXftConfig_cp += (int) (dest - source); + MiniXftConfig_bp += (int) (dest - source); + MiniXftConfig_current_buffer->MiniXftConfig_n_chars = + MiniXftConfig_n_chars = MiniXftConfig_current_buffer->MiniXftConfig_buf_size; + + if ( MiniXftConfig_cp < MiniXftConfig_current_buffer->MiniXftConfig_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--MiniXftConfig_cp = (char) c; + + + MiniXftConfigtext_ptr = MiniXftConfig_bp; + MiniXftConfig_hold_char = *MiniXftConfig_cp; + MiniXftConfig_c_buf_p = MiniXftConfig_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifdef __cplusplus +static int MiniXftConfiginput() +#else +static int input() +#endif + { + int c; + + *MiniXftConfig_c_buf_p = MiniXftConfig_hold_char; + + if ( *MiniXftConfig_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* MiniXftConfig_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( MiniXftConfig_c_buf_p < &MiniXftConfig_current_buffer->MiniXftConfig_ch_buf[MiniXftConfig_n_chars] ) + /* This was really a NUL. */ + *MiniXftConfig_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = MiniXftConfig_c_buf_p - MiniXftConfigtext_ptr; + ++MiniXftConfig_c_buf_p; + + switch ( MiniXftConfig_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because MiniXftConfig_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + MiniXftConfigrestart( MiniXftConfigin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + { + if ( MiniXftConfigwrap() ) + return EOF; + + if ( ! MiniXftConfig_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return MiniXftConfiginput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + MiniXftConfig_c_buf_p = MiniXftConfigtext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) MiniXftConfig_c_buf_p; /* cast for 8-bit char's */ + *MiniXftConfig_c_buf_p = '\0'; /* preserve MiniXftConfigtext */ + MiniXftConfig_hold_char = *++MiniXftConfig_c_buf_p; + + MiniXftConfig_current_buffer->MiniXftConfig_at_bol = (c == '\n'); + + return c; + } + + +#ifdef YY_USE_PROTOS +void MiniXftConfigrestart( FILE *input_file ) +#else +void MiniXftConfigrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! MiniXftConfig_current_buffer ) + MiniXftConfig_current_buffer = MiniXftConfig_create_buffer( MiniXftConfigin, YY_BUF_SIZE ); + + MiniXftConfig_init_buffer( MiniXftConfig_current_buffer, input_file ); + MiniXftConfig_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void MiniXftConfig_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void MiniXftConfig_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( MiniXftConfig_current_buffer == new_buffer ) + return; + + if ( MiniXftConfig_current_buffer ) + { + /* Flush out information for old buffer. */ + *MiniXftConfig_c_buf_p = MiniXftConfig_hold_char; + MiniXftConfig_current_buffer->MiniXftConfig_buf_pos = MiniXftConfig_c_buf_p; + MiniXftConfig_current_buffer->MiniXftConfig_n_chars = MiniXftConfig_n_chars; + } + + MiniXftConfig_current_buffer = new_buffer; + MiniXftConfig_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (MiniXftConfigwrap()) processing, but the only time this flag + * is looked at is after MiniXftConfigwrap() is called, so it's safe + * to go ahead and always set it. + */ + MiniXftConfig_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void MiniXftConfig_load_buffer_state( void ) +#else +void MiniXftConfig_load_buffer_state() +#endif + { + MiniXftConfig_n_chars = MiniXftConfig_current_buffer->MiniXftConfig_n_chars; + MiniXftConfigtext_ptr = MiniXftConfig_c_buf_p = MiniXftConfig_current_buffer->MiniXftConfig_buf_pos; + MiniXftConfigin = MiniXftConfig_current_buffer->MiniXftConfig_input_file; + MiniXftConfig_hold_char = *MiniXftConfig_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE MiniXftConfig_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE MiniXftConfig_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) MiniXftConfig_flex_alloc( sizeof( struct MiniXftConfig_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in MiniXftConfig_create_buffer()" ); + + b->MiniXftConfig_buf_size = size; + + /* MiniXftConfig_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->MiniXftConfig_ch_buf = (char *) MiniXftConfig_flex_alloc( b->MiniXftConfig_buf_size + 2 ); + if ( ! b->MiniXftConfig_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in MiniXftConfig_create_buffer()" ); + + b->MiniXftConfig_is_our_buffer = 1; + + MiniXftConfig_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void MiniXftConfig_delete_buffer( YY_BUFFER_STATE b ) +#else +void MiniXftConfig_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == MiniXftConfig_current_buffer ) + MiniXftConfig_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->MiniXftConfig_is_our_buffer ) + MiniXftConfig_flex_free( (void *) b->MiniXftConfig_ch_buf ); + + MiniXftConfig_flex_free( (void *) b ); + } + + + +#ifdef YY_USE_PROTOS +void MiniXftConfig_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void MiniXftConfig_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + MiniXftConfig_flush_buffer( b ); + + b->MiniXftConfig_input_file = file; + b->MiniXftConfig_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->MiniXftConfig_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->MiniXftConfig_is_interactive = 0; +#else + b->MiniXftConfig_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void MiniXftConfig_flush_buffer( YY_BUFFER_STATE b ) +#else +void MiniXftConfig_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->MiniXftConfig_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->MiniXftConfig_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->MiniXftConfig_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->MiniXftConfig_buf_pos = &b->MiniXftConfig_ch_buf[0]; + + b->MiniXftConfig_at_bol = 1; + b->MiniXftConfig_buffer_status = YY_BUFFER_NEW; + + if ( b == MiniXftConfig_current_buffer ) + MiniXftConfig_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE MiniXftConfig_scan_buffer( char *base, MiniXftConfig_size_t size ) +#else +YY_BUFFER_STATE MiniXftConfig_scan_buffer( base, size ) +char *base; +MiniXftConfig_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) MiniXftConfig_flex_alloc( sizeof( struct MiniXftConfig_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in MiniXftConfig_scan_buffer()" ); + + b->MiniXftConfig_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->MiniXftConfig_buf_pos = b->MiniXftConfig_ch_buf = base; + b->MiniXftConfig_is_our_buffer = 0; + b->MiniXftConfig_input_file = 0; + b->MiniXftConfig_n_chars = b->MiniXftConfig_buf_size; + b->MiniXftConfig_is_interactive = 0; + b->MiniXftConfig_at_bol = 1; + b->MiniXftConfig_fill_buffer = 0; + b->MiniXftConfig_buffer_status = YY_BUFFER_NEW; + + MiniXftConfig_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE MiniXftConfig_scan_string( MiniXftConfigconst char *MiniXftConfig_str ) +#else +YY_BUFFER_STATE MiniXftConfig_scan_string( MiniXftConfig_str ) +MiniXftConfigconst char *MiniXftConfig_str; +#endif + { + int len; + for ( len = 0; MiniXftConfig_str[len]; ++len ) + ; + + return MiniXftConfig_scan_bytes( MiniXftConfig_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE MiniXftConfig_scan_bytes( MiniXftConfigconst char *bytes, int len ) +#else +YY_BUFFER_STATE MiniXftConfig_scan_bytes( bytes, len ) +MiniXftConfigconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + MiniXftConfig_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) MiniXftConfig_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in MiniXftConfig_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = MiniXftConfig_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in MiniXftConfig_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->MiniXftConfig_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void MiniXftConfig_push_state( int new_state ) +#else +static void MiniXftConfig_push_state( new_state ) +int new_state; +#endif + { + if ( MiniXftConfig_start_stack_ptr >= MiniXftConfig_start_stack_depth ) + { + MiniXftConfig_size_t new_size; + + MiniXftConfig_start_stack_depth += YY_START_STACK_INCR; + new_size = MiniXftConfig_start_stack_depth * sizeof( int ); + + if ( ! MiniXftConfig_start_stack ) + MiniXftConfig_start_stack = (int *) MiniXftConfig_flex_alloc( new_size ); + + else + MiniXftConfig_start_stack = (int *) MiniXftConfig_flex_realloc( + (void *) MiniXftConfig_start_stack, new_size ); + + if ( ! MiniXftConfig_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + MiniXftConfig_start_stack[MiniXftConfig_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void MiniXftConfig_pop_state() + { + if ( --MiniXftConfig_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(MiniXftConfig_start_stack[MiniXftConfig_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int MiniXftConfig_top_state() + { + return MiniXftConfig_start_stack[MiniXftConfig_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void MiniXftConfig_fatal_error( MiniXftConfigconst char msg[] ) +#else +static void MiniXftConfig_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine MiniXftConfigless() so it works in section 3 code. */ + +#undef MiniXftConfigless +#define MiniXftConfigless(n) \ + do \ + { \ + /* Undo effects of setting up MiniXftConfigtext. */ \ + MiniXftConfigtext[MiniXftConfigleng] = MiniXftConfig_hold_char; \ + MiniXftConfig_c_buf_p = MiniXftConfigtext + n; \ + MiniXftConfig_hold_char = *MiniXftConfig_c_buf_p; \ + *MiniXftConfig_c_buf_p = '\0'; \ + MiniXftConfigleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef MiniXftConfigtext_ptr +#ifdef YY_USE_PROTOS +static void MiniXftConfig_flex_strncpy( char *s1, MiniXftConfigconst char *s2, int n ) +#else +static void MiniXftConfig_flex_strncpy( s1, s2, n ) +char *s1; +MiniXftConfigconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int MiniXftConfig_flex_strlen( MiniXftConfigconst char *s ) +#else +static int MiniXftConfig_flex_strlen( s ) +MiniXftConfigconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *MiniXftConfig_flex_alloc( MiniXftConfig_size_t size ) +#else +static void *MiniXftConfig_flex_alloc( size ) +MiniXftConfig_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *MiniXftConfig_flex_realloc( void *ptr, MiniXftConfig_size_t size ) +#else +static void *MiniXftConfig_flex_realloc( ptr, size ) +void *ptr; +MiniXftConfig_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void MiniXftConfig_flex_free( void *ptr ) +#else +static void MiniXftConfig_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + MiniXftConfiglex(); + return 0; + } +#endif +#line 154 "minixftlex.l" + +static void +_MiniXftConfigSkipComment (void) +{ + int c; + + c = input(); + for (;;) { + while (c != EOF && c != '*') + c = input(); + if (c == EOF) + return; + c = input(); + if (c == EOF || c == '/') + return; + } +} + +static void +_MiniXftConfigSkipLine (void) +{ + int c; + + do { + c = input(); + } while (c != EOF && c != '\n'); + if (c == '\n') unput('\n'); +} + +Bool +MiniXftConfigLexFile(char *s) +{ + FILE *f; + + f = fopen (s, "r"); + if (f == 0) + { + fprintf (stderr, "cannot open file \"%s\"\n", s); + return False; + } + ++MiniXftConfigFiledeep; + MiniXftConfigInput = f; + MiniXftConfigFile = s; + return True; +} + +Bool +MiniXftConfigPushInput (char *s, Bool complain) +{ + FILE *f; + char *t; + char *h; + + if (MiniXftConfigInpt == MiniXftConfigInStack) + { + (void) fprintf (stderr, "files nested too deeply\n"); + return False; + } + t = s; + if (*s == '~') + { + h = getenv ("HOME"); + if (h) + { + t = (char *) malloc (strlen (h) + strlen (s)); + if (t) + { + strcpy (t, h); + strcat (t, s+1); + } + else + t = s; + } + } + f = fopen (t, "r"); + if (t != s) + free (t); + if (f == 0) + { + if (complain) + (void) fprintf (stderr, "cannot open file %s\n", s); + return False; + } + ++MiniXftConfigFiledeep; + *--MiniXftConfigInpt = MiniXftConfigInput; + *--MiniXftConfigLinenopt = MiniXftConfigLineno; + *--MiniXftConfigFileNamePt = MiniXftConfigFile; + MiniXftConfigInput = f; + MiniXftConfigLineno = 1; + MiniXftConfigFile = _MiniXftSaveString (s); + return True; +} + +static int +_MiniXftConfigPopInput (void) +{ + int c; + + for (;;) + { + c = getc (MiniXftConfigInput); + if (c >= 0) + return c; + fclose (MiniXftConfigInput); + MiniXftConfigInput = 0; + if (MiniXftConfigInpt == MiniXftConfigInStack + XFT_CONFIG_IN_DEEP) + return EOF; + MiniXftConfigInput = *MiniXftConfigInpt++; + MiniXftConfigLineno = *MiniXftConfigLinenopt++; + free (MiniXftConfigFile); + MiniXftConfigFile = *MiniXftConfigFileNamePt++; + --MiniXftConfigFiledeep; + } +} + +void +MiniXftConfigLexDone (void) +{ +#ifdef FLEX_SCANNER + MiniXftConfig_delete_buffer (MiniXftConfig_current_buffer); +#endif +} diff --git a/pango/mini-xft/minixftlex.l b/pango/mini-xft/minixftlex.l new file mode 100644 index 00000000..9ddb7920 --- /dev/null +++ b/pango/mini-xft/minixftlex.l @@ -0,0 +1,275 @@ +%{ +/* + * $XFree86: xc/lib/MiniXft/xftlex.l,v 1.7 2001/05/18 16:03:06 tsi Exp $ + * + * Copyright (c) 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include <string.h> +#include "minixftint.h" + +#include "minixftgram.h" + +int MiniXftConfigLineno; + +static void _MiniXftConfigSkipComment (void); + +static void _MiniXftConfigSkipLine (void); + +static int _MiniXftConfigPopInput (void); + + +#define XFT_CONFIG_IN_DEEP 20 +FILE *MiniXftConfigInStack[XFT_CONFIG_IN_DEEP]; +FILE **MiniXftConfigInpt = MiniXftConfigInStack + XFT_CONFIG_IN_DEEP; +FILE *MiniXftConfigInput; +int MiniXftConfigLinenos[XFT_CONFIG_IN_DEEP]; +int *MiniXftConfigLinenopt = MiniXftConfigLinenos + XFT_CONFIG_IN_DEEP; +char *MiniXftConfigFile = ""; +char *MiniXftConfigFileNames[XFT_CONFIG_IN_DEEP]; +char **MiniXftConfigFileNamePt = MiniXftConfigFileNames + XFT_CONFIG_IN_DEEP; +int MiniXftConfigFiledeep = 0; + +#undef YY_INPUT + +#define YY_INPUT(buf,result,max_size) \ +{ \ + int c; \ + result = 0; \ + while (result < max_size) { \ + c = getc (MiniXftConfigInput); \ + if (c < 0) { \ + c = _MiniXftConfigPopInput (); \ + if (c < 0) \ + break; \ + } \ + buf[result++] = c; \ + if (c == '\n') \ + { \ + MiniXftConfigLineno++; \ + break; \ + } \ + } \ +} + +#ifndef FLEX_SCANNER +#undef input +#undef unput +static int input (void) +{ + char buf[1]; + static int r = EOF; + + if (r == 0) + return 0; + YY_INPUT(buf, r, 1); + if (r == 0) + return EOF; + return buf[0]; +} + +static void unput (char c) +{ + if (!c || c == EOF) + return; + if (c == '\n') + MiniXftConfigLineno--; + ungetc (c, MiniXftConfigInput); +} +#endif + +%} +%% +"/\052" _MiniXftConfigSkipComment(); +^# _MiniXftConfigSkipLine(); +dir return DIR; +cache return CACHE; +include return INCLUDE; +includeif return INCLUDEIF; +match return MATCH; +edit return EDIT; +true return TOK_TRUE; +false return TOK_FALSE; +nil return TOK_NIL; +any return ANY; +all return ALL; +"=" return EQUAL; +":" return COLON; +";" return SEMI; +"+" return PLUS; +"-" return MINUS; +"*" return TIMES; +"/" return DIVIDE; +"!" return NOT; +"&&" return ANDAND; +"||" return OROR; +"<" return LESS; +"<=" return LESSEQ; +"==" return EQEQ; +">=" return MOREEQ; +">" return MORE; +"!=" return NOTEQ; +"?" return QUEST; +"[" return OS; +"]" return CS; +\"([^\n\"]|\\\")*\" { + yytext[yyleng - 1] = '\0'; + yylval.sval = yytext+1; + return STRING; + } +[0-9]+ { + yylval.ival = strtol (yytext, 0, 10); + return INTEGER; + } +(([0-9]+((\.[0-9]*(\{[0-9]+\})?)?))|(\.[0-9]+)|(\.[0-9]*\{[0-9]+\}))(([Ee][-+]?[0-9]+)?) { + yylval.dval = strtod (yytext, 0); + return DOUBLE; + } +[a-zA-Z][0-9a-zA-Z_]* { + if (MiniXftNameConstant (yytext, &yylval.ival)) + return INTEGER; + yylval.sval = yytext; + return NAME; + } +. ; +"\n" ; +%% +static void +_MiniXftConfigSkipComment (void) +{ + int c; + + c = input(); + for (;;) { + while (c != EOF && c != '*') + c = input(); + if (c == EOF) + return; + c = input(); + if (c == EOF || c == '/') + return; + } +} + +static void +_MiniXftConfigSkipLine (void) +{ + int c; + + do { + c = input(); + } while (c != EOF && c != '\n'); + if (c == '\n') unput('\n'); +} + +Bool +MiniXftConfigLexFile(char *s) +{ + FILE *f; + + f = fopen (s, "r"); + if (f == 0) + { + fprintf (stderr, "cannot open file \"%s\"\n", s); + return False; + } + ++MiniXftConfigFiledeep; + MiniXftConfigInput = f; + MiniXftConfigFile = s; + return True; +} + +Bool +MiniXftConfigPushInput (char *s, Bool complain) +{ + FILE *f; + char *t; + char *h; + + if (MiniXftConfigInpt == MiniXftConfigInStack) + { + (void) fprintf (stderr, "files nested too deeply\n"); + return False; + } + t = s; + if (*s == '~') + { + h = getenv ("HOME"); + if (h) + { + t = (char *) malloc (strlen (h) + strlen (s)); + if (t) + { + strcpy (t, h); + strcat (t, s+1); + } + else + t = s; + } + } + f = fopen (t, "r"); + if (t != s) + free (t); + if (f == 0) + { + if (complain) + (void) fprintf (stderr, "cannot open file %s\n", s); + return False; + } + ++MiniXftConfigFiledeep; + *--MiniXftConfigInpt = MiniXftConfigInput; + *--MiniXftConfigLinenopt = MiniXftConfigLineno; + *--MiniXftConfigFileNamePt = MiniXftConfigFile; + MiniXftConfigInput = f; + MiniXftConfigLineno = 1; + MiniXftConfigFile = _MiniXftSaveString (s); + return True; +} + +static int +_MiniXftConfigPopInput (void) +{ + int c; + + for (;;) + { + c = getc (MiniXftConfigInput); + if (c >= 0) + return c; + fclose (MiniXftConfigInput); + MiniXftConfigInput = 0; + if (MiniXftConfigInpt == MiniXftConfigInStack + XFT_CONFIG_IN_DEEP) + return EOF; + MiniXftConfigInput = *MiniXftConfigInpt++; + MiniXftConfigLineno = *MiniXftConfigLinenopt++; + free (MiniXftConfigFile); + MiniXftConfigFile = *MiniXftConfigFileNamePt++; + --MiniXftConfigFiledeep; + } +} + +void +MiniXftConfigLexDone (void) +{ +#ifdef FLEX_SCANNER + MiniXftConfig_delete_buffer (MiniXftConfig_current_buffer); +#endif +} diff --git a/pango/mini-xft/minixftlist.c b/pango/mini-xft/minixftlist.c new file mode 100644 index 00000000..230ab858 --- /dev/null +++ b/pango/mini-xft/minixftlist.c @@ -0,0 +1,303 @@ +/* + * $XFree86: xc/lib/MiniXft/xftlist.c,v 1.2 2000/12/07 23:57:28 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include <stdlib.h> +#include "minixftint.h" + +MiniXftObjectSet * +MiniXftObjectSetCreate (void) +{ + MiniXftObjectSet *os; + + os = (MiniXftObjectSet *) malloc (sizeof (MiniXftObjectSet)); + if (!os) + return 0; + os->nobject = 0; + os->sobject = 0; + os->objects = 0; + return os; +} + +Bool +MiniXftObjectSetAdd (MiniXftObjectSet *os, const char *object) +{ + int s; + const char **objects; + + if (os->nobject == os->sobject) + { + s = os->sobject + 4; + if (os->objects) + objects = (const char **) realloc ((void *) os->objects, + s * sizeof (const char **)); + else + objects = (const char **) malloc (s * sizeof (const char **)); + if (!objects) + return False; + os->objects = objects; + os->sobject = s; + } + os->objects[os->nobject++] = object; + return True; +} + +void +MiniXftObjectSetDestroy (MiniXftObjectSet *os) +{ + if (os->objects) + free ((void *) os->objects); + free (os); +} + +#define _MiniXftObjectSetVapBuild(__ret__, __first__, __va__) \ +{ \ + MiniXftObjectSet *__os__; \ + const char *__ob__; \ + \ + __ret__ = 0; \ + __os__ = MiniXftObjectSetCreate (); \ + if (!__os__) \ + goto _MiniXftObjectSetVapBuild_bail0; \ + __ob__ = __first__; \ + while (__ob__) \ + { \ + if (!MiniXftObjectSetAdd (__os__, __ob__)) \ + goto _MiniXftObjectSetVapBuild_bail1; \ + __ob__ = va_arg (__va__, const char *); \ + } \ + __ret__ = __os__; \ + \ +_MiniXftObjectSetVapBuild_bail1: \ + if (!__ret__ && __os__) \ + MiniXftObjectSetDestroy (__os__); \ +_MiniXftObjectSetVapBuild_bail0: \ + ; \ +} + +MiniXftObjectSet * +MiniXftObjectSetVaBuild (const char *first, va_list va) +{ + MiniXftObjectSet *ret; + + _MiniXftObjectSetVapBuild (ret, first, va); + return ret; +} + +MiniXftObjectSet * +MiniXftObjectSetBuild (const char *first, ...) +{ + va_list va; + MiniXftObjectSet *os; + + va_start (va, first); + _MiniXftObjectSetVapBuild (os, first, va); + va_end (va); + return os; +} + +Bool +MiniXftListValueCompare (MiniXftValue v1, + MiniXftValue v2) +{ + return _MiniXftConfigCompareValue (v1, MiniXftOpEqual, v2); +} + +Bool +MiniXftListValueListCompare (MiniXftValueList *v1orig, + MiniXftValueList *v2orig, + MiniXftQual qual) +{ + MiniXftValueList *v1, *v2; + + for (v1 = v1orig; v1; v1 = v1->next) + { + for (v2 = v2orig; v2; v2 = v2->next) + { + if (_MiniXftConfigCompareValue (v1->value, MiniXftOpEqual, v2->value)) + { + if (qual == MiniXftQualAny) + return True; + else + break; + } + } + if (qual == MiniXftQualAll) + { + if (!v2) + return False; + } + } + if (qual == MiniXftQualAll) + return True; + else + return False; +} + +/* + * True iff all objects in "p" match "font" + */ +Bool +MiniXftListMatch (MiniXftPattern *p, + MiniXftPattern *font, + MiniXftQual qual) +{ + int i; + MiniXftPatternElt *e; + + for (i = 0; i < p->num; i++) + { + e = MiniXftPatternFind (font, p->elts[i].object, False); + if (!e) + { + if (qual == MiniXftQualAll) + continue; + else + return False; + } + if (!MiniXftListValueListCompare (p->elts[i].values, e->values, qual)) + return False; + } + return True; +} + +Bool +MiniXftListAppend (MiniXftFontSet *s, + MiniXftPattern *font, + MiniXftObjectSet *os) +{ + int f; + int o; + MiniXftPattern *l; + MiniXftPatternElt *e; + MiniXftValueList *v; + + for (f = 0; f < s->nfont; f++) + { + l = s->fonts[f]; + if (MiniXftListMatch (l, font, MiniXftQualAll)) + return True; + } + l = MiniXftPatternCreate (); + if (!l) + goto bail0; + for (o = 0; o < os->nobject; o++) + { + e = MiniXftPatternFind (font, os->objects[o], False); + if (e) + { + for (v = e->values; v; v = v->next) + { + if (!MiniXftPatternAdd (l, os->objects[o], v->value, True)) + goto bail1; + } + } + } + if (!MiniXftFontSetAdd (s, l)) + goto bail1; + return True; +bail1: + MiniXftPatternDestroy (l); +bail0: + return False; +} + +MiniXftFontSet * +MiniXftListFontSets (MiniXftFontSet **sets, + int nsets, + MiniXftPattern *p, + MiniXftObjectSet *os) +{ + MiniXftFontSet *ret; + MiniXftFontSet *s; + int f; + int set; + + ret = MiniXftFontSetCreate (); + if (!ret) + goto bail0; + for (set = 0; set < nsets; set++) + { + s = sets[set]; + for (f = 0; f < s->nfont; f++) + { + if (MiniXftListMatch (p, s->fonts[f], MiniXftQualAny)) + { + if (!MiniXftListAppend (ret, s->fonts[f], os)) + goto bail1; + } + } + } + return ret; +bail1: + MiniXftFontSetDestroy (ret); +bail0: + return 0; +} + +MiniXftFontSet * +MiniXftListFontsPatternObjects (Display *dpy, + int screen, + MiniXftPattern *pattern, + MiniXftObjectSet *os) +{ + MiniXftFontSet *sets[2]; + int nsets = 0; + + if (!MiniXftInit (0)) + return 0; + + if (MiniXftInitFtLibrary ()) + { + sets[nsets] = _MiniXftFontSet; + if (sets[nsets]) + nsets++; + } + return MiniXftListFontSets (sets, nsets, pattern, os); +} + +MiniXftFontSet * +MiniXftListFonts (Display *dpy, + int screen, + ...) +{ + va_list va; + MiniXftFontSet *fs; + MiniXftObjectSet *os; + MiniXftPattern *pattern; + const char *first; + + va_start (va, screen); + + _MiniXftPatternVapBuild (pattern, 0, va); + + first = va_arg (va, const char *); + _MiniXftObjectSetVapBuild (os, first, va); + + va_end (va); + + fs = MiniXftListFontsPatternObjects (dpy, screen, pattern, os); + MiniXftPatternDestroy (pattern); + MiniXftObjectSetDestroy (os); + return fs; +} diff --git a/pango/mini-xft/minixftmatch.c b/pango/mini-xft/minixftmatch.c new file mode 100644 index 00000000..3b68f70b --- /dev/null +++ b/pango/mini-xft/minixftmatch.c @@ -0,0 +1,330 @@ +/* + * $XFree86: xc/lib/MiniXft/xftmatch.c,v 1.6 2001/09/21 19:54:53 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include <string.h> +#include <ctype.h> +#include "minixftint.h" +#include <stdio.h> + +static double +_MiniXftCompareInteger (char *object, MiniXftValue value1, MiniXftValue value2) +{ + int v; + + if (value2.type != MiniXftTypeInteger || value1.type != MiniXftTypeInteger) + return -1.0; + v = value2.u.i - value1.u.i; + if (v < 0) + v = -v; + return (double) v; +} + +static double +_MiniXftCompareString (char *object, MiniXftValue value1, MiniXftValue value2) +{ + if (value2.type != MiniXftTypeString || value1.type != MiniXftTypeString) + return -1.0; + return (double) _MiniXftStrCmpIgnoreCase (value1.u.s, value2.u.s) != 0; +} + +static double +_MiniXftCompareBool (char *object, MiniXftValue value1, MiniXftValue value2) +{ + if (value2.type != MiniXftTypeBool || value1.type != MiniXftTypeBool) + return -1.0; + return (double) value2.u.b != value1.u.b; +} + +static double +_MiniXftCompareSize (char *object, MiniXftValue value1, MiniXftValue value2) +{ + double v1, v2, v; + + switch (value1.type) { + case MiniXftTypeInteger: + v1 = value1.u.i; + break; + case MiniXftTypeDouble: + v1 = value1.u.d; + break; + default: + return -1; + } + switch (value2.type) { + case MiniXftTypeInteger: + v2 = value2.u.i; + break; + case MiniXftTypeDouble: + v2 = value2.u.d; + break; + default: + return -1; + } + if (v2 == 0) + return 0; + v = v2 - v1; + if (v < 0) + v = -v; + return v; +} + +/* + * Order is significant, it defines the precedence of + * each value, earlier values are more significant than + * later values + */ +static MiniXftMatcher _MiniXftMatchers [] = { + { XFT_FOUNDRY, _MiniXftCompareString, }, + { XFT_ENCODING, _MiniXftCompareString, }, + { XFT_FAMILY, _MiniXftCompareString, }, + { XFT_SPACING, _MiniXftCompareInteger, }, + { XFT_PIXEL_SIZE, _MiniXftCompareSize, }, + { XFT_STYLE, _MiniXftCompareString, }, + { XFT_SLANT, _MiniXftCompareInteger, }, + { XFT_WEIGHT, _MiniXftCompareInteger, }, + { XFT_RASTERIZER, _MiniXftCompareString, }, + { XFT_ANTIALIAS, _MiniXftCompareBool, }, + { XFT_OUTLINE, _MiniXftCompareBool, }, +}; + +#define NUM_MATCHER (sizeof _MiniXftMatchers / sizeof _MiniXftMatchers[0]) + +static Bool +_MiniXftCompareValueList (const char *object, + MiniXftValueList *v1orig, /* pattern */ + MiniXftValueList *v2orig, /* target */ + MiniXftValue *bestValue, + double *value, + MiniXftResult *result) +{ + MiniXftValueList *v1, *v2; + double v, best; + int j; + int i; + + for (i = 0; i < NUM_MATCHER; i++) + { + if (!_MiniXftStrCmpIgnoreCase (_MiniXftMatchers[i].object, object)) + break; + } + if (i == NUM_MATCHER) + { + if (bestValue) + *bestValue = v2orig->value; + return True; + } + + best = 1e99; + j = 0; + for (v1 = v1orig; v1; v1 = v1->next) + { + for (v2 = v2orig; v2; v2 = v2->next) + { + v = (*_MiniXftMatchers[i].compare) (_MiniXftMatchers[i].object, + v1->value, + v2->value); + if (v < 0) + { + *result = MiniXftResultTypeMismatch; + return False; + } + if (_MiniXftFontDebug () & XFT_DBG_MATCHV) + printf (" v %g j %d ", v, j); + v = v * 100 + j; + if (v < best) + { + if (bestValue) + *bestValue = v2->value; + best = v; + } + } + j++; + } + if (_MiniXftFontDebug () & XFT_DBG_MATCHV) + { + printf (" %s: %g ", object, best); + MiniXftValueListPrint (v1orig); + printf (", "); + MiniXftValueListPrint (v2orig); + printf ("\n"); + } + value[i] += best; + return True; +} + +/* + * Return a value indicating the distance between the two lists of + * values + */ + +static Bool +_MiniXftCompare (MiniXftPattern *pat, + MiniXftPattern *fnt, + double *value, + MiniXftResult *result) +{ + int i, i1, i2; + + for (i = 0; i < NUM_MATCHER; i++) + value[i] = 0.0; + + for (i1 = 0; i1 < pat->num; i1++) + { + for (i2 = 0; i2 < fnt->num; i2++) + { + if (!_MiniXftStrCmpIgnoreCase (pat->elts[i1].object, + fnt->elts[i2].object)) + { + if (!_MiniXftCompareValueList (pat->elts[i1].object, + pat->elts[i1].values, + fnt->elts[i2].values, + 0, + value, + result)) + return False; + break; + } + } +#if 0 + /* + * Overspecified patterns are slightly penalized in + * case some other font includes the requested field + */ + if (i2 == fnt->num) + { + for (i2 = 0; i2 < NUM_MATCHER; i2++) + { + if (!_MiniXftStrCmpIgnoreCase (_MiniXftMatchers[i2].object, + pat->elts[i1].object)) + { + value[i2] = 1.0; + break; + } + } + } +#endif + } + return True; +} + +MiniXftPattern * +MiniXftFontSetMatch (MiniXftFontSet **sets, + int nsets, + MiniXftPattern *p, + MiniXftResult *result) +{ + double score[NUM_MATCHER], bestscore[NUM_MATCHER]; + int f; + MiniXftFontSet *s; + MiniXftPattern *best; + MiniXftPattern *new; + MiniXftPatternElt *fe, *pe; + MiniXftValue v; + int i; + int set; + + for (i = 0; i < NUM_MATCHER; i++) + bestscore[i] = 0; + best = 0; + if (_MiniXftFontDebug () & XFT_DBG_MATCH) + { + printf ("Match "); + MiniXftPatternPrint (p); + } + for (set = 0; set < nsets; set++) + { + s = sets[set]; + for (f = 0; f < s->nfont; f++) + { + if (_MiniXftFontDebug () & XFT_DBG_MATCH) + { + printf ("Font %d ", f); + MiniXftPatternPrint (s->fonts[f]); + } + if (!_MiniXftCompare (p, s->fonts[f], score, result)) + return 0; + if (_MiniXftFontDebug () & XFT_DBG_MATCH) + { + printf ("Score"); + for (i = 0; i < NUM_MATCHER; i++) + { + printf (" %g", score[i]); + } + printf ("\n"); + } + for (i = 0; i < NUM_MATCHER; i++) + { + if (best && bestscore[i] < score[i]) + break; + if (!best || score[i] < bestscore[i]) + { + for (i = 0; i < NUM_MATCHER; i++) + bestscore[i] = score[i]; + best = s->fonts[f]; + break; + } + } + } + } + if (_MiniXftFontDebug () & XFT_DBG_MATCH) + { + printf ("Best score"); + for (i = 0; i < NUM_MATCHER; i++) + printf (" %g", bestscore[i]); + MiniXftPatternPrint (best); + } + if (!best) + { + *result = MiniXftResultNoMatch; + return 0; + } + new = MiniXftPatternCreate (); + if (!new) + return 0; + for (i = 0; i < best->num; i++) + { + fe = &best->elts[i]; + pe = MiniXftPatternFind (p, fe->object, False); + if (pe) + { + if (!_MiniXftCompareValueList (pe->object, pe->values, + fe->values, &v, score, result)) + { + MiniXftPatternDestroy (new); + return 0; + } + } + else + v = fe->values->value; + MiniXftPatternAdd (new, fe->object, v, True); + } + for (i = 0; i < p->num; i++) + { + pe = &p->elts[i]; + fe = MiniXftPatternFind (best, pe->object, False); + if (!fe) + MiniXftPatternAdd (new, pe->object, pe->values->value, True); + } + return new; +} diff --git a/pango/mini-xft/minixftmatrix.c b/pango/mini-xft/minixftmatrix.c new file mode 100644 index 00000000..b7decb69 --- /dev/null +++ b/pango/mini-xft/minixftmatrix.c @@ -0,0 +1,104 @@ +/* + * $XFree86: xc/lib/MiniXft/xftmatrix.c,v 1.1 2001/03/30 18:50:18 keithp Exp $ + * + * Copyright © 2000 Tuomas J. Lukka + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Tuomas Lukka not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Tuomas Lukka makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * TUOMAS LUKKA DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL TUOMAS LUKKA BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include <math.h> +#include <stdlib.h> +#include <ctype.h> +#include "minixftint.h" + +MiniXftMatrix * +_MiniXftSaveMatrix (const MiniXftMatrix *mat) +{ + MiniXftMatrix *r; + if(!mat) + return 0; + r = (MiniXftMatrix *) malloc (sizeof (*r) ); + if (!r) + return 0; + *r = *mat; + return r; +} + +int +MiniXftMatrixEqual (const MiniXftMatrix *mat1, const MiniXftMatrix *mat2) +{ + if(mat1 == mat2) return True; + if(mat1 == 0 || mat2 == 0) return False; + return mat1->xx == mat2->xx && + mat1->xy == mat2->xy && + mat1->yx == mat2->yx && + mat1->yy == mat2->yy; +} + +void +MiniXftMatrixMultiply (MiniXftMatrix *result, MiniXftMatrix *a, MiniXftMatrix *b) +{ + MiniXftMatrix r; + + r.xx = a->xx * b->xx + a->xy * b->yx; + r.xy = a->xx * b->xy + a->xy * b->yy; + r.yx = a->yx * b->xx + a->yy * b->yx; + r.yy = a->yx * b->xy + a->yy * b->yy; + *result = r; +} + +void +MiniXftMatrixRotate (MiniXftMatrix *m, double c, double s) +{ + MiniXftMatrix r; + + /* + * X Coordinate system is upside down, swap to make + * rotations counterclockwise + */ + r.xx = c; + r.xy = -s; + r.yx = s; + r.yy = c; + MiniXftMatrixMultiply (m, &r, m); +} + +void +MiniXftMatrixScale (MiniXftMatrix *m, double sx, double sy) +{ + MiniXftMatrix r; + + r.xx = sx; + r.xy = 0; + r.yx = 0; + r.yy = sy; + MiniXftMatrixMultiply (m, &r, m); +} + +void +MiniXftMatrixShear (MiniXftMatrix *m, double sh, double sv) +{ + MiniXftMatrix r; + + r.xx = 1; + r.xy = sh; + r.yx = sv; + r.yy = 1; + MiniXftMatrixMultiply (m, &r, m); +} diff --git a/pango/mini-xft/minixftname.c b/pango/mini-xft/minixftname.c new file mode 100644 index 00000000..3452f39a --- /dev/null +++ b/pango/mini-xft/minixftname.c @@ -0,0 +1,391 @@ +/* + * $XFree86: xc/lib/MiniXft/xftname.c,v 1.10 2001/03/30 18:50:18 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "minixftint.h" +#include <ctype.h> +#include <stdlib.h> +#include <string.h> +#include <stdio.h> + +typedef struct _MiniXftObjectType { + const char *object; + MiniXftType type; +} MiniXftObjectType; + +static const MiniXftObjectType _MiniXftObjectTypes[] = { + { XFT_FAMILY, MiniXftTypeString, }, + { XFT_STYLE, MiniXftTypeString, }, + { XFT_SLANT, MiniXftTypeInteger, }, + { XFT_WEIGHT, MiniXftTypeInteger, }, + { XFT_SIZE, MiniXftTypeDouble, }, + { XFT_PIXEL_SIZE, MiniXftTypeDouble, }, + { XFT_ENCODING, MiniXftTypeString, }, + { XFT_SPACING, MiniXftTypeInteger, }, + { XFT_FOUNDRY, MiniXftTypeString, }, + { XFT_CORE, MiniXftTypeBool, }, + { XFT_ANTIALIAS, MiniXftTypeBool, }, + { XFT_XLFD, MiniXftTypeString, }, + { XFT_FILE, MiniXftTypeString, }, + { XFT_INDEX, MiniXftTypeInteger, }, + { XFT_RASTERIZER, MiniXftTypeString, }, + { XFT_OUTLINE, MiniXftTypeBool, }, + { XFT_SCALABLE, MiniXftTypeBool, }, + { XFT_RGBA, MiniXftTypeInteger, }, + { XFT_SCALE, MiniXftTypeDouble, }, + { XFT_RENDER, MiniXftTypeBool, }, + { XFT_MINSPACE, MiniXftTypeBool, }, + { XFT_CHAR_WIDTH, MiniXftTypeInteger }, + { XFT_CHAR_HEIGHT, MiniXftTypeInteger }, + { XFT_MATRIX, MiniXftTypeMatrix }, +}; + +#define NUM_OBJECT_TYPES (sizeof _MiniXftObjectTypes / sizeof _MiniXftObjectTypes[0]) + +static const MiniXftObjectType * +MiniXftNameGetType (const char *object) +{ + int i; + + for (i = 0; i < NUM_OBJECT_TYPES; i++) + { + if (!_MiniXftStrCmpIgnoreCase (object, _MiniXftObjectTypes[i].object)) + return &_MiniXftObjectTypes[i]; + } + return 0; +} + +typedef struct _MiniXftConstant { + const char *name; + const char *object; + int value; +} MiniXftConstant; + +static MiniXftConstant MiniXftConstants[] = { + { "light", "weight", XFT_WEIGHT_LIGHT, }, + { "medium", "weight", XFT_WEIGHT_MEDIUM, }, + { "demibold", "weight", XFT_WEIGHT_DEMIBOLD, }, + { "bold", "weight", XFT_WEIGHT_BOLD, }, + { "black", "weight", XFT_WEIGHT_BLACK, }, + + { "roman", "slant", XFT_SLANT_ROMAN, }, + { "italic", "slant", XFT_SLANT_ITALIC, }, + { "oblique", "slant", XFT_SLANT_OBLIQUE, }, + + { "proportional", "spacing", XFT_PROPORTIONAL, }, + { "mono", "spacing", XFT_MONO, }, + { "charcell", "spacing", XFT_CHARCELL, }, + + { "rgb", "rgba", XFT_RGBA_RGB, }, + { "bgr", "rgba", XFT_RGBA_BGR, }, + { "vrgb", "rgba", XFT_RGBA_VRGB }, + { "vbgr", "rgba", XFT_RGBA_VBGR }, +}; + +#define NUM_XFT_CONSTANTS (sizeof MiniXftConstants/sizeof MiniXftConstants[0]) + +static MiniXftConstant * +_MiniXftNameConstantLookup (char *string) +{ + int i; + + for (i = 0; i < NUM_XFT_CONSTANTS; i++) + if (!_MiniXftStrCmpIgnoreCase (string, MiniXftConstants[i].name)) + return &MiniXftConstants[i]; + return 0; +} + +Bool +MiniXftNameConstant (char *string, int *result) +{ + MiniXftConstant *c; + + if ((c = _MiniXftNameConstantLookup(string))) + { + *result = c->value; + return True; + } + return False; +} + +static MiniXftValue +_MiniXftNameConvert (MiniXftType type, char *string, MiniXftMatrix *m) +{ + MiniXftValue v; + + v.type = type; + switch (v.type) { + case MiniXftTypeInteger: + if (!MiniXftNameConstant (string, &v.u.i)) + v.u.i = atoi (string); + break; + case MiniXftTypeString: + v.u.s = string; + break; + case MiniXftTypeBool: + v.u.b = MiniXftDefaultParseBool (string); + break; + case MiniXftTypeDouble: + v.u.d = strtod (string, 0); + break; + case MiniXftTypeMatrix: + v.u.m = m; + sscanf (string, "%lg %lg %lg %lg", &m->xx, &m->xy, &m->yx, &m->yy); + break; + default: + break; + } + return v; +} + +static const char * +_MiniXftNameFindNext (const char *cur, const char *delim, char *save, char *last) +{ + char c; + + while ((c = *cur)) + { + if (c == '\\') + { + ++cur; + if (!(c = *cur)) + break; + } + else if (strchr (delim, c)) + break; + ++cur; + *save++ = c; + } + *save = 0; + *last = *cur; + if (*cur) + cur++; + return cur; +} + +MiniXftPattern * +MiniXftNameParse (const char *name) +{ + char *save; + MiniXftPattern *pat; + double d; + char *e; + char delim; + MiniXftValue v; + MiniXftMatrix m; + const MiniXftObjectType *t; + MiniXftConstant *c; + + save = malloc (strlen (name) + 1); + if (!save) + goto bail0; + pat = MiniXftPatternCreate (); + if (!pat) + goto bail1; + + for (;;) + { + name = _MiniXftNameFindNext (name, "-,:", save, &delim); + if (save[0]) + { + if (!MiniXftPatternAddString (pat, XFT_FAMILY, save)) + goto bail2; + } + if (delim != ',') + break; + } + if (delim == '-') + { + for (;;) + { + name = _MiniXftNameFindNext (name, "-,:", save, &delim); + d = strtod (save, &e); + if (e != save) + { + if (!MiniXftPatternAddDouble (pat, XFT_SIZE, d)) + goto bail2; + } + if (delim != ',') + break; + } + } + while (delim == ':') + { + name = _MiniXftNameFindNext (name, "=_:", save, &delim); + if (save[0]) + { + if (delim == '=' || delim == '_') + { + t = MiniXftNameGetType (save); + for (;;) + { + name = _MiniXftNameFindNext (name, ":,", save, &delim); + if (save[0] && t) + { + v = _MiniXftNameConvert (t->type, save, &m); + if (!MiniXftPatternAdd (pat, t->object, v, True)) + goto bail2; + } + if (delim != ',') + break; + } + } + else + { + if ((c = _MiniXftNameConstantLookup (save))) + { + if (!MiniXftPatternAddInteger (pat, c->object, c->value)) + goto bail2; + } + } + } + } + + free (save); + return pat; + +bail2: + MiniXftPatternDestroy (pat); +bail1: + free (save); +bail0: + return 0; +} + +static Bool +_MiniXftNameUnparseString (const char *string, char *escape, char **destp, int *lenp) +{ + int len = *lenp; + char *dest = *destp; + char c; + + while ((c = *string++)) + { + if (escape && strchr (escape, c)) + { + if (len-- == 0) + return False; + *dest++ = escape[0]; + } + if (len-- == 0) + return False; + *dest++ = c; + } + *destp = dest; + *lenp = len; + return True; +} + +static Bool +_MiniXftNameUnparseValue (MiniXftValue v, char *escape, char **destp, int *lenp) +{ + char temp[1024]; + + switch (v.type) { + case MiniXftTypeVoid: + return True; + case MiniXftTypeInteger: + sprintf (temp, "%d", v.u.i); + return _MiniXftNameUnparseString (temp, 0, destp, lenp); + case MiniXftTypeDouble: + sprintf (temp, "%g", v.u.d); + return _MiniXftNameUnparseString (temp, 0, destp, lenp); + case MiniXftTypeString: + return _MiniXftNameUnparseString (v.u.s, escape, destp, lenp); + case MiniXftTypeBool: + return _MiniXftNameUnparseString (v.u.b ? "True" : "False", 0, destp, lenp); + case MiniXftTypeMatrix: + sprintf (temp, "%g %g %g %g", + v.u.m->xx, v.u.m->xy, v.u.m->yx, v.u.m->yy); + return _MiniXftNameUnparseString (temp, 0, destp, lenp); + } + return False; +} + +static Bool +_MiniXftNameUnparseValueList (MiniXftValueList *v, char *escape, char **destp, int *lenp) +{ + while (v) + { + if (!_MiniXftNameUnparseValue (v->value, escape, destp, lenp)) + return False; + if ((v = v->next)) + if (!_MiniXftNameUnparseString (",", 0, destp, lenp)) + return False; + } + return True; +} + +#define XFT_ESCAPE_FIXED "\\-:," +#define XFT_ESCAPE_VARIABLE "\\=_:," + +Bool +MiniXftNameUnparse (MiniXftPattern *pat, char *dest, int len) +{ + int i; + MiniXftPatternElt *e; + const MiniXftObjectType *o; + + e = MiniXftPatternFind (pat, XFT_FAMILY, False); + if (e) + { + if (!_MiniXftNameUnparseValueList (e->values, XFT_ESCAPE_FIXED, + &dest, &len)) + return False; + } + e = MiniXftPatternFind (pat, XFT_SIZE, False); + if (e) + { + if (!_MiniXftNameUnparseString ("-", 0, &dest, &len)) + return False; + if (!_MiniXftNameUnparseValueList (e->values, XFT_ESCAPE_FIXED, &dest, &len)) + return False; + } + for (i = 0; i < NUM_OBJECT_TYPES; i++) + { + o = &_MiniXftObjectTypes[i]; + if (!strcmp (o->object, XFT_FAMILY) || + !strcmp (o->object, XFT_SIZE) || + !strcmp (o->object, XFT_FILE)) + continue; + + e = MiniXftPatternFind (pat, o->object, False); + if (e) + { + if (!_MiniXftNameUnparseString (":", 0, &dest, &len)) + return False; + if (!_MiniXftNameUnparseString (o->object, XFT_ESCAPE_VARIABLE, + &dest, &len)) + return False; + if (!_MiniXftNameUnparseString ("=", 0, &dest, &len)) + return False; + if (!_MiniXftNameUnparseValueList (e->values, XFT_ESCAPE_VARIABLE, + &dest, &len)) + return False; + } + } + if (len == 0) + return False; + *dest = '\0'; + return True; +} diff --git a/pango/mini-xft/minixftpat.c b/pango/mini-xft/minixftpat.c new file mode 100644 index 00000000..223966b3 --- /dev/null +++ b/pango/mini-xft/minixftpat.c @@ -0,0 +1,411 @@ +/* + * $XFree86: xc/lib/MiniXft/xftpat.c,v 1.6 2001/03/30 18:50:18 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include <stdlib.h> +#include <string.h> +#include "minixftint.h" + +MiniXftPattern * +MiniXftPatternCreate (void) +{ + MiniXftPattern *p; + + p = (MiniXftPattern *) malloc (sizeof (MiniXftPattern)); + if (!p) + return 0; + p->num = 0; + p->size = 0; + p->elts = 0; + return p; +} + +void +MiniXftValueDestroy (MiniXftValue v) +{ + if (v.type == MiniXftTypeString) + free (v.u.s); + if( v.type == MiniXftTypeMatrix) + free (v.u.m); +} + +void +MiniXftValueListDestroy (MiniXftValueList *l) +{ + MiniXftValueList *next; + for (; l; l = next) + { + if (l->value.type == MiniXftTypeString) + free (l->value.u.s); + if (l->value.type == MiniXftTypeMatrix) + free (l->value.u.m); + next = l->next; + free (l); + } +} + +void +MiniXftPatternDestroy (MiniXftPattern *p) +{ + int i; + + for (i = 0; i < p->num; i++) + MiniXftValueListDestroy (p->elts[i].values); + + if (p->elts) + { + free (p->elts); + p->elts = 0; + } + p->num = p->size = 0; + free (p); +} + +MiniXftPatternElt * +MiniXftPatternFind (MiniXftPattern *p, const char *object, Bool insert) +{ + int i; + int s; + MiniXftPatternElt *e; + + /* match existing */ + for (i = 0; i < p->num; i++) + { + if (!_MiniXftStrCmpIgnoreCase (object, p->elts[i].object)) + return &p->elts[i]; + } + + if (!insert) + return 0; + + /* grow array */ + if (i == p->size) + { + s = p->size + 16; + if (p->elts) + e = (MiniXftPatternElt *) realloc (p->elts, s * sizeof (MiniXftPatternElt)); + else + e = (MiniXftPatternElt *) malloc (s * sizeof (MiniXftPatternElt)); + if (!e) + return False; + p->elts = e; + while (p->size < s) + { + p->elts[p->size].object = 0; + p->elts[p->size].values = 0; + p->size++; + } + } + + /* bump count */ + p->num++; + + return &p->elts[i]; +} + +Bool +MiniXftPatternAdd (MiniXftPattern *p, const char *object, MiniXftValue value, Bool append) +{ + MiniXftPatternElt *e; + MiniXftValueList *new, **prev; + + new = (MiniXftValueList *) malloc (sizeof (MiniXftValueList)); + if (!new) + goto bail0; + + /* dup string */ + if (value.type == MiniXftTypeString) + { + value.u.s = _MiniXftSaveString (value.u.s); + if (!value.u.s) + goto bail1; + } + else if (value.type == MiniXftTypeMatrix) + { + value.u.m = _MiniXftSaveMatrix (value.u.m); + if (!value.u.m) + goto bail1; + } + new->value = value; + new->next = 0; + + e = MiniXftPatternFind (p, object, True); + if (!e) + goto bail2; + + e->object = object; + if (append) + { + for (prev = &e->values; *prev; prev = &(*prev)->next); + *prev = new; + } + else + { + new->next = e->values; + e->values = new; + } + + return True; + +bail2: + if (value.type == MiniXftTypeString) + free (value.u.s); + else if (value.type == MiniXftTypeMatrix) + free (value.u.m); +bail1: + free (new); +bail0: + return False; +} + +Bool +MiniXftPatternDel (MiniXftPattern *p, const char *object) +{ + MiniXftPatternElt *e; + int i; + + e = MiniXftPatternFind (p, object, False); + if (!e) + return False; + + i = e - p->elts; + + /* destroy value */ + MiniXftValueListDestroy (e->values); + + /* shuffle existing ones down */ + memmove (e, e+1, (p->elts + p->num - (e + 1)) * sizeof (MiniXftPatternElt)); + p->num--; + p->elts[p->num].object = 0; + p->elts[p->num].values = 0; + return True; +} + +Bool +MiniXftPatternAddInteger (MiniXftPattern *p, const char *object, int i) +{ + MiniXftValue v; + + v.type = MiniXftTypeInteger; + v.u.i = i; + return MiniXftPatternAdd (p, object, v, True); +} + +Bool +MiniXftPatternAddDouble (MiniXftPattern *p, const char *object, double d) +{ + MiniXftValue v; + + v.type = MiniXftTypeDouble; + v.u.d = d; + return MiniXftPatternAdd (p, object, v, True); +} + + +Bool +MiniXftPatternAddString (MiniXftPattern *p, const char *object, const char *s) +{ + MiniXftValue v; + + v.type = MiniXftTypeString; + v.u.s = (char *) s; + return MiniXftPatternAdd (p, object, v, True); +} + +Bool +MiniXftPatternAddMatrix (MiniXftPattern *p, const char *object, const MiniXftMatrix *s) +{ + MiniXftValue v; + + v.type = MiniXftTypeMatrix; + v.u.m = (MiniXftMatrix *) s; + return MiniXftPatternAdd (p, object, v, True); +} + + +Bool +MiniXftPatternAddBool (MiniXftPattern *p, const char *object, Bool b) +{ + MiniXftValue v; + + v.type = MiniXftTypeBool; + v.u.b = b; + return MiniXftPatternAdd (p, object, v, True); +} + +MiniXftResult +MiniXftPatternGet (MiniXftPattern *p, const char *object, int id, MiniXftValue *v) +{ + MiniXftPatternElt *e; + MiniXftValueList *l; + + e = MiniXftPatternFind (p, object, False); + if (!e) + return MiniXftResultNoMatch; + for (l = e->values; l; l = l->next) + { + if (!id) + { + *v = l->value; + return MiniXftResultMatch; + } + id--; + } + return MiniXftResultNoId; +} + +MiniXftResult +MiniXftPatternGetInteger (MiniXftPattern *p, const char *object, int id, int *i) +{ + MiniXftValue v; + MiniXftResult r; + + r = MiniXftPatternGet (p, object, id, &v); + if (r != MiniXftResultMatch) + return r; + switch (v.type) { + case MiniXftTypeDouble: + *i = (int) v.u.d; + break; + case MiniXftTypeInteger: + *i = v.u.i; + break; + default: + return MiniXftResultTypeMismatch; + } + return MiniXftResultMatch; +} + +MiniXftResult +MiniXftPatternGetDouble (MiniXftPattern *p, const char *object, int id, double *d) +{ + MiniXftValue v; + MiniXftResult r; + + r = MiniXftPatternGet (p, object, id, &v); + if (r != MiniXftResultMatch) + return r; + switch (v.type) { + case MiniXftTypeDouble: + *d = v.u.d; + break; + case MiniXftTypeInteger: + *d = (double) v.u.i; + break; + default: + return MiniXftResultTypeMismatch; + } + return MiniXftResultMatch; +} + +MiniXftResult +MiniXftPatternGetString (MiniXftPattern *p, const char *object, int id, char **s) +{ + MiniXftValue v; + MiniXftResult r; + + r = MiniXftPatternGet (p, object, id, &v); + if (r != MiniXftResultMatch) + return r; + if (v.type != MiniXftTypeString) + return MiniXftResultTypeMismatch; + *s = v.u.s; + return MiniXftResultMatch; +} + +MiniXftResult +MiniXftPatternGetMatrix (MiniXftPattern *p, const char *object, int id, MiniXftMatrix **m) +{ + MiniXftValue v; + MiniXftResult r; + + r = MiniXftPatternGet (p, object, id, &v); + if (r != MiniXftResultMatch) + return r; + if (v.type != MiniXftTypeMatrix) + return MiniXftResultTypeMismatch; + *m = v.u.m; + return MiniXftResultMatch; +} + + +MiniXftResult +MiniXftPatternGetBool (MiniXftPattern *p, const char *object, int id, Bool *b) +{ + MiniXftValue v; + MiniXftResult r; + + r = MiniXftPatternGet (p, object, id, &v); + if (r != MiniXftResultMatch) + return r; + if (v.type != MiniXftTypeBool) + return MiniXftResultTypeMismatch; + *b = v.u.b; + return MiniXftResultMatch; +} + +MiniXftPattern * +MiniXftPatternDuplicate (MiniXftPattern *orig) +{ + MiniXftPattern *new; + int i; + MiniXftValueList *l; + + new = MiniXftPatternCreate (); + if (!new) + goto bail0; + + for (i = 0; i < orig->num; i++) + { + for (l = orig->elts[i].values; l; l = l->next) + if (!MiniXftPatternAdd (new, orig->elts[i].object, l->value, True)) + goto bail1; + } + + return new; + +bail1: + MiniXftPatternDestroy (new); +bail0: + return 0; +} + +MiniXftPattern * +MiniXftPatternVaBuild (MiniXftPattern *orig, va_list va) +{ + MiniXftPattern *ret; + + _MiniXftPatternVapBuild (ret, orig, va); + return ret; +} + +MiniXftPattern * +MiniXftPatternBuild (MiniXftPattern *orig, ...) +{ + va_list va; + + va_start (va, orig); + _MiniXftPatternVapBuild (orig, orig, va); + va_end (va); + return orig; +} diff --git a/pango/mini-xft/minixftstr.c b/pango/mini-xft/minixftstr.c new file mode 100644 index 00000000..afa22338 --- /dev/null +++ b/pango/mini-xft/minixftstr.c @@ -0,0 +1,156 @@ +/* + * $XFree86: xc/lib/MiniXft/xftstr.c,v 1.6 2001/04/01 14:00:01 tsi Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include <stdlib.h> +#include <ctype.h> +#include <string.h> +#include "minixftint.h" + +char * +_MiniXftSaveString (const char *s) +{ + char *r; + + if (!s) + return 0; + r = (char *) malloc (strlen (s) + 1); + if (!r) + return 0; + strcpy (r, s); + return r; +} + +const char * +_MiniXftGetInt(const char *ptr, int *val) +{ + if (*ptr == '*') { + *val = -1; + ptr++; + } else + for (*val = 0; *ptr >= '0' && *ptr <= '9';) + *val = *val * 10 + *ptr++ - '0'; + if (*ptr == '-') + return ptr; + return (char *) 0; +} + +char * +_MiniXftSplitStr (const char *field, char *save) +{ + char *s = save; + char c; + + while (*field) + { + if (*field == '-') + break; + c = *field++; + *save++ = c; + } + *save = 0; + return s; +} + +char * +_MiniXftDownStr (const char *field, char *save) +{ + char *s = save; + char c; + + while (*field) + { + c = *field++; + *save++ = c; + } + *save = 0; + return s; +} + +const char * +_MiniXftSplitField (const char *field, char *save) +{ + char c; + + while (*field) + { + if (*field == '-' || *field == '=') + break; + c = *field++; + *save++ = c; + } + *save = 0; + return field; +} + +const char * +_MiniXftSplitValue (const char *field, char *save) +{ + char c; + + while (*field) + { + if (*field == '-' || *field == ',') + break; + c = *field++; + *save++ = c; + } + *save = 0; + if (*field) + field++; + return field; +} + +int +_MiniXftMatchSymbolic (MiniXftSymbolic *s, int n, const char *name, int def) +{ + while (n--) + { + if (!_MiniXftStrCmpIgnoreCase (s->name, name)) + return s->value; + s++; + } + return def; +} + +int +_MiniXftStrCmpIgnoreCase (const char *s1, const char *s2) +{ + char c1, c2; + + for (;;) + { + c1 = *s1++; + c2 = *s2++; + if (!c1 || !c2) + break; + if (isupper (c1)) + c1 = tolower (c1); + if (isupper (c2)) + c2 = tolower (c2); + if (c1 != c2) + break; + } + return (int) c2 - (int) c1; +} + |