Synchronised line endinge with release branch

1 files changed, 363 insertions, 363 deletions

diff --git a/fontconfig/fc-case/fc-case.c b/fontconfig/fc-case/fc-case.c
index dd8b1f08a..236bff5f0 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 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));

-}

+/*
+ * 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));
+}