svn merge ^/branches/released .

1 files changed, 363 insertions, 363 deletions

diff --git a/fontconfig/fc-case/fc-case.c b/fontconfig/fc-case/fc-case.c
index e86b34783..dd8b1f08a 100644
--- a/fontconfig/fc-case/fc-case.c
+++ b/fontconfig/fc-case/fc-case.c
@@ -1,363 +1,363 @@
-/*
- * fontconfig/fc-case/fc-case.c
- *
- * Copyright © 2004 Keith Packard
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * 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.
- *
- * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL THE AUTHOR(S) 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 "fcint.h"
-#include <ctype.h>
-
-#define MAX_OUT	    32
-#define MAX_LINE    8192
-
-typedef enum _caseFoldClass { CaseFoldCommon, CaseFoldFull, CaseFoldSimple, CaseFoldTurkic } CaseFoldClass;
-
-typedef struct _caseFoldClassMap {
-    const char	    *name;
-    CaseFoldClass   class;
-} CaseFoldClassMap;
-
-static const CaseFoldClassMap	caseFoldClassMap[] = {
-    { "C", CaseFoldCommon },
-    { "F", CaseFoldFull },
-    { "S", CaseFoldSimple },
-    { "T", CaseFoldTurkic },
-    { 0, 0 }
-};
-
-typedef struct _caseFoldRaw {
-    FcChar32	    upper;
-    CaseFoldClass   class;
-    int		    nout;
-    FcChar32	    lower[MAX_OUT];
-} CaseFoldRaw;
-
-static void
-panic (const char *reason)
-{
-    fprintf (stderr, "fc-case: panic %s\n", reason);
-    exit (1);
-}
-
-int			maxExpand;
-static FcCaseFold	*folds;
-int			nfolds;
-
-static FcCaseFold *
-addFold (void)
-{
-    if (folds)
-	folds = realloc (folds, (nfolds + 1) * sizeof (FcCaseFold));
-    else
-	folds = malloc (sizeof (FcCaseFold));
-    if (!folds)
-	panic ("out of memory");
-    return &folds[nfolds++];
-}
-
-static int
-ucs4_to_utf8 (FcChar32	ucs4,
-	      FcChar8	dest[FC_UTF8_MAX_LEN])
-{
-    int	bits;
-    FcChar8 *d = dest;
-    
-    if      (ucs4 <       0x80) {  *d++=  ucs4;                         bits= -6; }
-    else if (ucs4 <      0x800) {  *d++= ((ucs4 >>  6) & 0x1F) | 0xC0;  bits=  0; }
-    else if (ucs4 <    0x10000) {  *d++= ((ucs4 >> 12) & 0x0F) | 0xE0;  bits=  6; }
-    else if (ucs4 <   0x200000) {  *d++= ((ucs4 >> 18) & 0x07) | 0xF0;  bits= 12; }
-    else if (ucs4 <  0x4000000) {  *d++= ((ucs4 >> 24) & 0x03) | 0xF8;  bits= 18; }
-    else if (ucs4 < 0x80000000) {  *d++= ((ucs4 >> 30) & 0x01) | 0xFC;  bits= 24; }
-    else return 0;
-
-    for ( ; bits >= 0; bits-= 6) {
-	*d++= ((ucs4 >> bits) & 0x3F) | 0x80;
-    }
-    return d - dest;
-}
-
-static int
-utf8_size (FcChar32 ucs4)
-{
-    FcChar8 utf8[FC_UTF8_MAX_LEN];
-    return ucs4_to_utf8 (ucs4, utf8 );
-}
-
-static FcChar8	*foldChars;
-static int	nfoldChars;
-static int	maxFoldChars;
-static FcChar32	minFoldChar;
-static FcChar32	maxFoldChar;
-
-static void
-addChar (FcChar32 c)
-{
-    FcChar8	utf8[FC_UTF8_MAX_LEN];
-    int		len;
-    int		i;
-
-    len = ucs4_to_utf8 (c, utf8);
-    if (foldChars)
-	foldChars = realloc (foldChars, (nfoldChars + len) * sizeof (FcChar8));
-    else
-	foldChars = malloc (sizeof (FcChar8) * len);
-    if (!foldChars)
-	panic ("out of memory");
-    for (i = 0; i < len; i++)
-	foldChars[nfoldChars + i] = utf8[i];
-    nfoldChars += len;
-}
-
-static int
-foldExtends (FcCaseFold *fold, CaseFoldRaw *raw)
-{
-    switch (fold->method) {
-    case FC_CASE_FOLD_RANGE:
-	if ((short) (raw->lower[0] - raw->upper) != fold->offset)
-	    return 0;
-	if (raw->upper != fold->upper + fold->count)
-	    return 0;
-	return 1;
-    case FC_CASE_FOLD_EVEN_ODD:
-	if ((short) (raw->lower[0] - raw->upper) != 1)
-	    return 0;
-	if (raw->upper != fold->upper + fold->count + 1)
-	    return 0;
-	return 1;
-    case FC_CASE_FOLD_FULL:
-	break;
-    }
-    return 0;
-}
-	    
-static const char *
-case_fold_method_name (FcChar16 method)
-{
-    switch (method) {
-    case FC_CASE_FOLD_RANGE:	return "FC_CASE_FOLD_RANGE,";
-    case FC_CASE_FOLD_EVEN_ODD: return "FC_CASE_FOLD_EVEN_ODD,";
-    case FC_CASE_FOLD_FULL:	return "FC_CASE_FOLD_FULL,";
-    default:			return "unknown";
-    }
-}
-
-static void
-dump (void)
-{
-    int	    i;
-    
-    printf (   "#define FC_NUM_CASE_FOLD	%d\n", nfolds);
-    printf (   "#define FC_NUM_CASE_FOLD_CHARS	%d\n", nfoldChars);
-    printf (   "#define FC_MAX_CASE_FOLD_CHARS	%d\n", maxFoldChars);
-    printf (   "#define FC_MAX_CASE_FOLD_EXPAND	%d\n", maxExpand);
-    printf (   "#define FC_MIN_FOLD_CHAR	0x%08x\n", minFoldChar);
-    printf (   "#define FC_MAX_FOLD_CHAR	0x%08x\n", maxFoldChar);
-    printf (   "\n");
-    
-    /*
-     * Dump out ranges
-     */
-    printf ("static const FcCaseFold    fcCaseFold[FC_NUM_CASE_FOLD] = {\n");
-    for (i = 0; i < nfolds; i++)
-    {
-	printf ("    { 0x%08x, %-22s 0x%04x, %6d },\n",
-		folds[i].upper, case_fold_method_name (folds[i].method),
-		folds[i].count, folds[i].offset);
-    }
-    printf ("};\n\n");
-
-    /*
-     * Dump out "other" values
-     */
-
-    printf ("static const FcChar8	fcCaseFoldChars[FC_NUM_CASE_FOLD_CHARS] = {\n");
-    for (i = 0; i < nfoldChars; i++)
-    {
-	printf ("0x%02x", foldChars[i]);
-	if (i != nfoldChars - 1)
-	{
-	    if ((i & 0xf) == 0xf) 
-		printf (",\n");
-	    else
-		printf (",");
-	}
-    }
-    printf ("\n};\n");
-}
-
-/*
- * Read the standard Unicode CaseFolding.txt file
- */
-#define SEP "; \t\n"
-
-static int
-parseRaw (char *line, CaseFoldRaw *raw)
-{
-    char    *tok, *end;
-    int	    i;
-    
-    if (!isxdigit (line[0]))
-	return 0;
-    /*
-     * Get upper case value
-     */
-    tok = strtok (line, SEP);
-    if (!tok || tok[0] == '#')
-	return 0;
-    raw->upper = strtol (tok, &end, 16);
-    if (end == tok)
-	return 0;
-    /*
-     * Get class
-     */
-    tok = strtok (NULL, SEP);
-    if (!tok || tok[0] == '#')
-	return 0;
-    for (i = 0; caseFoldClassMap[i].name; i++)
-	if (!strcmp (tok, caseFoldClassMap[i].name))
-	{
-	    raw->class = caseFoldClassMap[i].class;
-	    break;
-	}
-    if (!caseFoldClassMap[i].name)
-	return 0;
-	
-    /*
-     * Get list of result characters
-     */
-    for (i = 0; i < MAX_OUT; i++)
-    {
-	tok = strtok (NULL, SEP);
-	if (!tok || tok[0] == '#')
-	    break;
-	raw->lower[i] = strtol (tok, &end, 16);
-	if (end == tok)
-	    break;
-    }
-    if (i == 0)
-	return 0;
-    raw->nout = i;
-    return 1;
-}
-
-static int
-caseFoldReadRaw (FILE *in, CaseFoldRaw *raw)
-{
-    char    line[MAX_LINE];
-
-    for (;;)
-    {
-	if (!fgets (line, sizeof (line) - 1, in))
-	    return 0;
-	if (parseRaw (line, raw))
-	    return 1;
-    }
-}
-
-int
-main (int argc, char **argv)
-{
-    FcCaseFold		*fold = 0;
-    CaseFoldRaw		raw;
-    int			i;
-    FILE		*caseFile;
-    char		line[MAX_LINE];
-    int			expand;
-
-    if (argc != 2)
-	panic ("usage: fc-case CaseFolding.txt");
-    caseFile = fopen (argv[1], "r");
-    if (!caseFile)
-	panic ("can't open case folding file");
-    
-    while (caseFoldReadRaw (caseFile, &raw))
-    {
-	if (!minFoldChar)
-	    minFoldChar = raw.upper;
-	maxFoldChar = raw.upper;
-	switch (raw.class) {
-	case CaseFoldCommon:
-	case CaseFoldFull:
-	    if (raw.nout == 1)
-	    {
-		if (fold && foldExtends (fold, &raw))
-		    fold->count = raw.upper - fold->upper + 1;
-		else
-		{
-		    fold = addFold ();
-		    fold->upper = raw.upper;
-		    fold->offset = raw.lower[0] - raw.upper;
-		    if (fold->offset == 1)
-			fold->method = FC_CASE_FOLD_EVEN_ODD;
-		    else
-			fold->method = FC_CASE_FOLD_RANGE;
-		    fold->count = 1;
-		}
-		expand = utf8_size (raw.lower[0]) - utf8_size(raw.upper);
-	    }
-	    else
-	    {
-		fold = addFold ();
-		fold->upper = raw.upper;
-		fold->method = FC_CASE_FOLD_FULL;
-		fold->offset = nfoldChars;
-		for (i = 0; i < raw.nout; i++)
-		    addChar (raw.lower[i]);
-		fold->count = nfoldChars - fold->offset;
-		if (fold->count > maxFoldChars)
-		    maxFoldChars = fold->count;
-		expand = fold->count - utf8_size (raw.upper);
-	    }
-	    if (expand > maxExpand)
-		maxExpand = expand;
-	    break;
-	case CaseFoldSimple:
-	    break;
-	case CaseFoldTurkic:
-	    break;
-	}
-    }
-    /*
-     * Scan the input until the marker is found
-     */
-    
-    while (fgets (line, sizeof (line), stdin))
-    {
-	if (!strncmp (line, "@@@", 3))
-	    break;
-	fputs (line, stdout);
-    }
-    
-    /*
-     * Dump these tables
-     */
-    dump ();
-    
-    /*
-     * And flush out the rest of the input file
-     */
-
-    while (fgets (line, sizeof (line), stdin))
-	fputs (line, stdout);
-    
-    fflush (stdout);
-    exit (ferror (stdout));
-}
+/*

+ * fontconfig/fc-case/fc-case.c

+ *

+ * Copyright © 2004 Keith Packard

+ *

+ * Permission to use, copy, modify, distribute, and sell this software and its

+ * documentation for any purpose is hereby granted without fee, provided that

+ * 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 the author(s) not be used in

+ * advertising or publicity pertaining to distribution of the software without

+ * specific, written prior permission.  The authors make no

+ * representations about the suitability of this software for any purpose.  It

+ * is provided "as is" without express or implied warranty.

+ *

+ * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

+ * EVENT SHALL THE AUTHOR(S) 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 "fcint.h"

+#include <ctype.h>

+

+#define MAX_OUT	    32

+#define MAX_LINE    8192

+

+typedef enum _caseFoldClass { CaseFoldCommon, CaseFoldFull, CaseFoldSimple, CaseFoldTurkic } CaseFoldClass;

+

+typedef struct _caseFoldClassMap {

+    const char	    *name;

+    CaseFoldClass   class;

+} CaseFoldClassMap;

+

+static const CaseFoldClassMap	caseFoldClassMap[] = {

+    { "C", CaseFoldCommon },

+    { "F", CaseFoldFull },

+    { "S", CaseFoldSimple },

+    { "T", CaseFoldTurkic },

+    { 0, 0 }

+};

+

+typedef struct _caseFoldRaw {

+    FcChar32	    upper;

+    CaseFoldClass   class;

+    int		    nout;

+    FcChar32	    lower[MAX_OUT];

+} CaseFoldRaw;

+

+static void

+panic (const char *reason)

+{

+    fprintf (stderr, "fc-case: panic %s\n", reason);

+    exit (1);

+}

+

+int			maxExpand;

+static FcCaseFold	*folds;

+int			nfolds;

+

+static FcCaseFold *

+addFold (void)

+{

+    if (folds)

+	folds = realloc (folds, (nfolds + 1) * sizeof (FcCaseFold));

+    else

+	folds = malloc (sizeof (FcCaseFold));

+    if (!folds)

+	panic ("out of memory");

+    return &folds[nfolds++];

+}

+

+static int

+ucs4_to_utf8 (FcChar32	ucs4,

+	      FcChar8	dest[FC_UTF8_MAX_LEN])

+{

+    int	bits;

+    FcChar8 *d = dest;

+    

+    if      (ucs4 <       0x80) {  *d++=  ucs4;                         bits= -6; }

+    else if (ucs4 <      0x800) {  *d++= ((ucs4 >>  6) & 0x1F) | 0xC0;  bits=  0; }

+    else if (ucs4 <    0x10000) {  *d++= ((ucs4 >> 12) & 0x0F) | 0xE0;  bits=  6; }

+    else if (ucs4 <   0x200000) {  *d++= ((ucs4 >> 18) & 0x07) | 0xF0;  bits= 12; }

+    else if (ucs4 <  0x4000000) {  *d++= ((ucs4 >> 24) & 0x03) | 0xF8;  bits= 18; }

+    else if (ucs4 < 0x80000000) {  *d++= ((ucs4 >> 30) & 0x01) | 0xFC;  bits= 24; }

+    else return 0;

+

+    for ( ; bits >= 0; bits-= 6) {

+	*d++= ((ucs4 >> bits) & 0x3F) | 0x80;

+    }

+    return d - dest;

+}

+

+static int

+utf8_size (FcChar32 ucs4)

+{

+    FcChar8 utf8[FC_UTF8_MAX_LEN];

+    return ucs4_to_utf8 (ucs4, utf8 );

+}

+

+static FcChar8	*foldChars;

+static int	nfoldChars;

+static int	maxFoldChars;

+static FcChar32	minFoldChar;

+static FcChar32	maxFoldChar;

+

+static void

+addChar (FcChar32 c)

+{

+    FcChar8	utf8[FC_UTF8_MAX_LEN];

+    int		len;

+    int		i;

+

+    len = ucs4_to_utf8 (c, utf8);

+    if (foldChars)

+	foldChars = realloc (foldChars, (nfoldChars + len) * sizeof (FcChar8));

+    else

+	foldChars = malloc (sizeof (FcChar8) * len);

+    if (!foldChars)

+	panic ("out of memory");

+    for (i = 0; i < len; i++)

+	foldChars[nfoldChars + i] = utf8[i];

+    nfoldChars += len;

+}

+

+static int

+foldExtends (FcCaseFold *fold, CaseFoldRaw *raw)

+{

+    switch (fold->method) {

+    case FC_CASE_FOLD_RANGE:

+	if ((short) (raw->lower[0] - raw->upper) != fold->offset)

+	    return 0;

+	if (raw->upper != fold->upper + fold->count)

+	    return 0;

+	return 1;

+    case FC_CASE_FOLD_EVEN_ODD:

+	if ((short) (raw->lower[0] - raw->upper) != 1)

+	    return 0;

+	if (raw->upper != fold->upper + fold->count + 1)

+	    return 0;

+	return 1;

+    case FC_CASE_FOLD_FULL:

+	break;

+    }

+    return 0;

+}

+	    

+static const char *

+case_fold_method_name (FcChar16 method)

+{

+    switch (method) {

+    case FC_CASE_FOLD_RANGE:	return "FC_CASE_FOLD_RANGE,";

+    case FC_CASE_FOLD_EVEN_ODD: return "FC_CASE_FOLD_EVEN_ODD,";

+    case FC_CASE_FOLD_FULL:	return "FC_CASE_FOLD_FULL,";

+    default:			return "unknown";

+    }

+}

+

+static void

+dump (void)

+{

+    int	    i;

+    

+    printf (   "#define FC_NUM_CASE_FOLD	%d\n", nfolds);

+    printf (   "#define FC_NUM_CASE_FOLD_CHARS	%d\n", nfoldChars);

+    printf (   "#define FC_MAX_CASE_FOLD_CHARS	%d\n", maxFoldChars);

+    printf (   "#define FC_MAX_CASE_FOLD_EXPAND	%d\n", maxExpand);

+    printf (   "#define FC_MIN_FOLD_CHAR	0x%08x\n", minFoldChar);

+    printf (   "#define FC_MAX_FOLD_CHAR	0x%08x\n", maxFoldChar);

+    printf (   "\n");

+    

+    /*

+     * Dump out ranges

+     */

+    printf ("static const FcCaseFold    fcCaseFold[FC_NUM_CASE_FOLD] = {\n");

+    for (i = 0; i < nfolds; i++)

+    {

+	printf ("    { 0x%08x, %-22s 0x%04x, %6d },\n",

+		folds[i].upper, case_fold_method_name (folds[i].method),

+		folds[i].count, folds[i].offset);

+    }

+    printf ("};\n\n");

+

+    /*

+     * Dump out "other" values

+     */

+

+    printf ("static const FcChar8	fcCaseFoldChars[FC_NUM_CASE_FOLD_CHARS] = {\n");

+    for (i = 0; i < nfoldChars; i++)

+    {

+	printf ("0x%02x", foldChars[i]);

+	if (i != nfoldChars - 1)

+	{

+	    if ((i & 0xf) == 0xf) 

+		printf (",\n");

+	    else

+		printf (",");

+	}

+    }

+    printf ("\n};\n");

+}

+

+/*

+ * Read the standard Unicode CaseFolding.txt file

+ */

+#define SEP "; \t\n"

+

+static int

+parseRaw (char *line, CaseFoldRaw *raw)

+{

+    char    *tok, *end;

+    int	    i;

+    

+    if (!isxdigit (line[0]))

+	return 0;

+    /*

+     * Get upper case value

+     */

+    tok = strtok (line, SEP);

+    if (!tok || tok[0] == '#')

+	return 0;

+    raw->upper = strtol (tok, &end, 16);

+    if (end == tok)

+	return 0;

+    /*

+     * Get class

+     */

+    tok = strtok (NULL, SEP);

+    if (!tok || tok[0] == '#')

+	return 0;

+    for (i = 0; caseFoldClassMap[i].name; i++)

+	if (!strcmp (tok, caseFoldClassMap[i].name))

+	{

+	    raw->class = caseFoldClassMap[i].class;

+	    break;

+	}

+    if (!caseFoldClassMap[i].name)

+	return 0;

+	

+    /*

+     * Get list of result characters

+     */

+    for (i = 0; i < MAX_OUT; i++)

+    {

+	tok = strtok (NULL, SEP);

+	if (!tok || tok[0] == '#')

+	    break;

+	raw->lower[i] = strtol (tok, &end, 16);

+	if (end == tok)

+	    break;

+    }

+    if (i == 0)

+	return 0;

+    raw->nout = i;

+    return 1;

+}

+

+static int

+caseFoldReadRaw (FILE *in, CaseFoldRaw *raw)

+{

+    char    line[MAX_LINE];

+

+    for (;;)

+    {

+	if (!fgets (line, sizeof (line) - 1, in))

+	    return 0;

+	if (parseRaw (line, raw))

+	    return 1;

+    }

+}

+

+int

+main (int argc, char **argv)

+{

+    FcCaseFold		*fold = 0;

+    CaseFoldRaw		raw;

+    int			i;

+    FILE		*caseFile;

+    char		line[MAX_LINE];

+    int			expand;

+

+    if (argc != 2)

+	panic ("usage: fc-case CaseFolding.txt");

+    caseFile = fopen (argv[1], "r");

+    if (!caseFile)

+	panic ("can't open case folding file");

+    

+    while (caseFoldReadRaw (caseFile, &raw))

+    {

+	if (!minFoldChar)

+	    minFoldChar = raw.upper;

+	maxFoldChar = raw.upper;

+	switch (raw.class) {

+	case CaseFoldCommon:

+	case CaseFoldFull:

+	    if (raw.nout == 1)

+	    {

+		if (fold && foldExtends (fold, &raw))

+		    fold->count = raw.upper - fold->upper + 1;

+		else

+		{

+		    fold = addFold ();

+		    fold->upper = raw.upper;

+		    fold->offset = raw.lower[0] - raw.upper;

+		    if (fold->offset == 1)

+			fold->method = FC_CASE_FOLD_EVEN_ODD;

+		    else

+			fold->method = FC_CASE_FOLD_RANGE;

+		    fold->count = 1;

+		}

+		expand = utf8_size (raw.lower[0]) - utf8_size(raw.upper);

+	    }

+	    else

+	    {

+		fold = addFold ();

+		fold->upper = raw.upper;

+		fold->method = FC_CASE_FOLD_FULL;

+		fold->offset = nfoldChars;

+		for (i = 0; i < raw.nout; i++)

+		    addChar (raw.lower[i]);

+		fold->count = nfoldChars - fold->offset;

+		if (fold->count > maxFoldChars)

+		    maxFoldChars = fold->count;

+		expand = fold->count - utf8_size (raw.upper);

+	    }

+	    if (expand > maxExpand)

+		maxExpand = expand;

+	    break;

+	case CaseFoldSimple:

+	    break;

+	case CaseFoldTurkic:

+	    break;

+	}

+    }

+    /*

+     * Scan the input until the marker is found

+     */

+    

+    while (fgets (line, sizeof (line), stdin))

+    {

+	if (!strncmp (line, "@@@", 3))

+	    break;

+	fputs (line, stdout);

+    }

+    

+    /*

+     * Dump these tables

+     */

+    dump ();

+    

+    /*

+     * And flush out the rest of the input file

+     */

+

+    while (fgets (line, sizeof (line), stdin))

+	fputs (line, stdout);

+    

+    fflush (stdout);

+    exit (ferror (stdout));

+}