ascmagic.c File Reference

#include <rz_userconf.h>
#include "file.h"
#include <stdio.h>
#include <string.h>
#include <memory.h>
#include <ctype.h>
#include <stdlib.h>
#include "names.h"

Go to the source code of this file.

Macros
#define	MAXLINELEN   300 /* longest sane line length */
#define	ISSPC(x)   ((x) == ' ' || (x) == '\t' || (x) == '\r' || (x) == '\n' || (x) == 0x85 || (x) == '\f')
#define	F   0 /* character never appears in text */
#define	T   1 /* character appears in plain ASCII text */
#define	I   2 /* character appears in ISO-8859 text */
#define	X   3 /* character appears in non-ISO extended ASCII (Mac, IBM PC) */

Functions
static int	looks_ascii (const ut8 *, size_t, unichar *, size_t *)
static int	looks_utf8_with_BOM (const ut8 *, size_t, unichar *, size_t *)
int	file_looks_utf8 (const ut8 *, size_t, unichar *, size_t *)
static int	looks_ucs16 (const ut8 *, size_t, unichar *, size_t *)
static int	looks_latin1 (const ut8 *, size_t, unichar *, size_t *)
static int	looks_extended (const ut8 *, size_t, unichar *, size_t *)
static void	from_ebcdic (const ut8 *, size_t, ut8 *)
static int	ascmatch (const ut8 *, const unichar *, size_t)
static ut8 *	encode_utf8 (ut8 *, size_t, unichar *, size_t)
int	file_ascmagic (RzMagic *ms, const ut8 *buf, size_t nbytes)

Variables
static char	text_chars [256]
static ut8	ebcdic_to_ascii []

Macro Definition Documentation

F

#define F   0 /* character never appears in text */

Definition at line 464 of file ascmagic.c.

I

#define I   2 /* character appears in ISO-8859 text */

Definition at line 466 of file ascmagic.c.

ISSPC

#define ISSPC

(

x

)

((x) == ' ' || (x) == '\t' || (x) == '\r' || (x) == '\n' || (x) == 0x85 || (x) == '\f')

Definition at line 52 of file ascmagic.c.

MAXLINELEN

#define MAXLINELEN   300 /* longest sane line length */

Definition at line 51 of file ascmagic.c.

T

#define T   1 /* character appears in plain ASCII text */

Definition at line 465 of file ascmagic.c.

X

#define X   3 /* character appears in non-ISO extended ASCII (Mac, IBM PC) */

Definition at line 467 of file ascmagic.c.

Function Documentation

ascmatch()

static int ascmatch ( const ut8 *  s, const unichar *  us, size_t  ulen  )

static

Definition at line 402 of file ascmagic.c.

                                                                  {
    size_t i;
    for (i = 0; i < ulen; i++) {
        if (s[i] != us[i]) {
            return 0;
        }
    }
    return s[i] ? 0 : 1;
}

References i, and s.

Referenced by file_ascmagic().

encode_utf8()

static ut8 * encode_utf8 ( ut8 *  buf, size_t  len, unichar *  ubuf, size_t  ulen  )

static

Definition at line 536 of file ascmagic.c.

                                                              {
    size_t i;
    ut8 *end = buf + len;
 
    for (i = 0; i < ulen; i++) {
        if (ubuf[i] <= 0x7f) {
            if (end - buf < 1) {
                return NULL;
            }
            *buf++ = (ut8)ubuf[i];
        } else if (ubuf[i] <= 0x7ff) {
            if (end - buf < 2) {
                return NULL;
            }
            *buf++ = (ut8)((ubuf[i] >> 6) + 0xc0);
            *buf++ = (ut8)((ubuf[i] & 0x3f) + 0x80);
        } else if (ubuf[i] <= 0xffff) {
            if (end - buf < 3) {
                return NULL;
            }
            *buf++ = (ut8)((ubuf[i] >> 12) + 0xe0);
            *buf++ = (ut8)(((ubuf[i] >> 6) & 0x3f) + 0x80);
            *buf++ = (ut8)((ubuf[i] & 0x3f) + 0x80);
        } else if (ubuf[i] <= 0x1fffff) {
            if (end - buf < 4) {
                return NULL;
            }
            *buf++ = (ut8)((ubuf[i] >> 18) + 0xf0);
            *buf++ = (ut8)(((ubuf[i] >> 12) & 0x3f) + 0x80);
            *buf++ = (ut8)(((ubuf[i] >> 6) & 0x3f) + 0x80);
            *buf++ = (ut8)((ubuf[i] & 0x3f) + 0x80);
        } else if (ubuf[i] <= 0x3ffffff) {
            if (end - buf < 5) {
                return NULL;
            }
            *buf++ = (ut8)((ubuf[i] >> 24) + 0xf8);
            *buf++ = (ut8)(((ubuf[i] >> 18) & 0x3f) + 0x80);
            *buf++ = (ut8)(((ubuf[i] >> 12) & 0x3f) + 0x80);
            *buf++ = (ut8)(((ubuf[i] >> 6) & 0x3f) + 0x80);
            *buf++ = (ut8)((ubuf[i] & 0x3f) + 0x80);
        } else if (ubuf[i] <= 0x7fffffff) {
            if (end - buf < 6) {
                return NULL;
            }
            *buf++ = (ut8)((ubuf[i] >> 30) + 0xfc);
            *buf++ = (ut8)(((ubuf[i] >> 24) & 0x3f) + 0x80);
            *buf++ = (ut8)(((ubuf[i] >> 18) & 0x3f) + 0x80);
            *buf++ = (ut8)(((ubuf[i] >> 12) & 0x3f) + 0x80);
            *buf++ = (ut8)(((ubuf[i] >> 6) & 0x3f) + 0x80);
            *buf++ = (ut8)((ubuf[i] & 0x3f) + 0x80);
        } else { /* Invalid character */
            return NULL;
        }
    }
 
    return buf;
}

References test_evm::end, i, len, NULL, and ut8.

Referenced by file_ascmagic().

file_ascmagic()

int file_ascmagic	(	RzMagic *	ms,
		const ut8 *	buf,
		size_t	nbytes
	)

Definition at line 65 of file ascmagic.c.

                                                              {
    return 0;
    size_t i;
    ut8 *nbuf = NULL, *utf8_buf = NULL, *utf8_end;
    unichar *ubuf = NULL;
    size_t ulen, mlen;
    const struct names *p;
    int rv = -1;
    int mime = ms->flags & RZ_MAGIC_MIME;
 
    const char *code = NULL;
    const char *code_mime = NULL;
    const char *type = NULL;
    const char *subtype = NULL;
    const char *subtype_mime = NULL;
 
    int has_escapes = 0;
    int has_backspace = 0;
    int seen_cr = 0;
 
    int n_crlf = 0;
    int n_lf = 0;
    int n_cr = 0;
    int n_nel = 0;
 
    size_t last_line_end = (size_t)-1;
    int has_long_lines = 0;
 
    /*
     * Undo the NUL-termination kindly provided by process()
     * but leave at least one byte to look at
     */
    while (nbytes > 1 && buf[nbytes - 1] == '\0') {
        nbytes--;
    }
 
    if (!(nbuf = calloc(1, (nbytes + 1) * sizeof(nbuf[0])))) {
        goto done;
    }
    if (!(ubuf = calloc(1, (nbytes + 1) * sizeof(ubuf[0])))) {
        goto done;
    }
 
    /*
     * Then try to determine whether it's any character code we can
     * identify.  Each of these tests, if it succeeds, will leave
     * the text converted into one-unichar-per-character Unicode in
     * ubuf, and the number of characters converted in ulen.
     */
    if (looks_ascii(buf, nbytes, ubuf, &ulen)) {
        code = "ASCII";
        code_mime = "us-ascii";
        type = "text";
    } else if (looks_utf8_with_BOM(buf, nbytes, ubuf, &ulen) > 0) {
        code = "UTF-8 Unicode (with BOM)";
        code_mime = "utf-8";
        type = "text";
    } else if (file_looks_utf8(buf, nbytes, ubuf, &ulen) > 1) {
        code = "UTF-8 Unicode";
        code_mime = "utf-8";
        type = "text";
    } else if ((i = looks_ucs16(buf, nbytes, ubuf, &ulen)) != 0) {
        if (i == 1) {
            code = "Little-endian UTF-16 Unicode";
        } else {
            code = "Big-endian UTF-16 Unicode";
        }
 
        type = "character data";
        code_mime = "utf-16"; /* is this defined? */
    } else if (looks_latin1(buf, nbytes, ubuf, &ulen)) {
        if (!memcmp(buf, "\xff\xff\xff\xff", 4)) {
            // uninitialized memory is not iso-8859!!
            goto done;
        }
        code = "ISO-8859";
        type = "text";
        code_mime = "iso-8859-1";
    } else if (looks_extended(buf, nbytes, ubuf, &ulen)) {
        code = "Non-ISO extended-ASCII";
        type = "text";
        code_mime = "unknown";
    } else {
        from_ebcdic(buf, nbytes, nbuf);
 
        if (looks_ascii(nbuf, nbytes, ubuf, &ulen)) {
            code = "EBCDIC";
            type = "character data";
            code_mime = "ebcdic";
        } else if (looks_latin1(nbuf, nbytes, ubuf, &ulen)) {
            code = "International EBCDIC";
            type = "character data";
            code_mime = "ebcdic";
        } else {
            rv = 0;
            goto done; /* doesn't look like text at all */
        }
    }
 
    if (nbytes <= 1) {
        rv = 0;
        goto done;
    }
 
    /* Convert ubuf to UTF-8 and try text soft magic */
    /* If original was ASCII or UTF-8, could use nbuf instead of
       re-converting. */
    /* malloc size is a conservative overestimate; could be
       re-converting improved, or at least realloced after
       re-converting conversion. */
    mlen = ulen * 6;
    if (!(utf8_buf = malloc(mlen))) {
        file_oomem(ms, mlen);
        goto done;
    }
    if (!(utf8_end = encode_utf8(utf8_buf, mlen, ubuf, ulen))) {
        goto done;
    }
    if (file_softmagic(ms, utf8_buf, utf8_end - utf8_buf, TEXTTEST) != 0) {
        rv = 1;
        goto done;
    }
 
    /* look for tokens from names.h - this is expensive! */
    if ((ms->flags & RZ_MAGIC_NO_CHECK_TOKENS) != 0) {
        goto subtype_identified;
    }
 
    i = 0;
    while (i < ulen) {
        size_t end;
 
        /* skip past any leading space */
        while (i < ulen && ISSPC(ubuf[i])) {
            i++;
        }
        if (i >= ulen) {
            break;
        }
 
        /* find the next whitespace */
        for (end = i + 1; end < nbytes; end++) {
            if (ISSPC(ubuf[end])) {
                break;
            }
        }
 
        /* compare the word thus isolated against the token list */
        for (p = names; p < names + NNAMES; p++) {
            if (ascmatch((const ut8 *)p->name, ubuf + i,
                    end - i)) {
                subtype = types[p->type].human;
                subtype_mime = types[p->type].mime;
                goto subtype_identified;
            }
        }
 
        i = end;
    }
 
subtype_identified:
 
    /* Now try to discover other details about the file. */
    for (i = 0; i < ulen; i++) {
        if (ubuf[i] == '\n') {
            if (seen_cr) {
                n_crlf++;
            } else {
                n_lf++;
            }
            last_line_end = i;
        } else if (seen_cr) {
            n_cr++;
        }
 
        seen_cr = (ubuf[i] == '\r');
        if (seen_cr) {
            last_line_end = i;
        }
 
        if (ubuf[i] == 0x85) { /* X3.64/ECMA-43 "next line" character */
            n_nel++;
            last_line_end = i;
        }
        /* If this line is _longer_ than MAXLINELEN, remember it. */
        if (i > last_line_end + MAXLINELEN) {
            has_long_lines = 1;
        }
 
        if (ubuf[i] == '\033') {
            has_escapes = 1;
        }
        if (ubuf[i] == '\b') {
            has_backspace = 1;
        }
    }
 
    /* Beware, if the data has been truncated, the final CR could have
       been followed by a LF.  If we have HOWMANY bytes, it indicates
       that the data might have been truncated, probably even before
       this function was called. */
    if (seen_cr && nbytes < HOWMANY) {
        n_cr++;
    }
 
    if (mime) {
        if (mime & RZ_MAGIC_MIME_TYPE) {
            if (subtype_mime) {
                if (file_printf(ms, subtype_mime) == -1) {
                    goto done;
                }
            } else {
                if (file_printf(ms, "text/plain") == -1) {
                    goto done;
                }
            }
        }
 
        if ((mime == 0 || mime == RZ_MAGIC_MIME) && code_mime) {
            if ((mime & RZ_MAGIC_MIME_TYPE) &&
                file_printf(ms, " charset=") == -1) {
                goto done;
            }
            if (file_printf(ms, code_mime) == -1) {
                goto done;
            }
        }
 
        if (mime == RZ_MAGIC_MIME_ENCODING) {
            if (file_printf(ms, "binary") == -1) {
                rv = 1;
                goto done;
            }
        }
    } else {
        if (file_printf(ms, code) == -1) {
            goto done;
        }
 
        if (subtype) {
            if (file_printf(ms, " ") == -1) {
                goto done;
            }
            if (file_printf(ms, subtype) == -1) {
                goto done;
            }
        }
 
        if (file_printf(ms, " ") == -1) {
            goto done;
        }
        if (file_printf(ms, type) == -1) {
            goto done;
        }
 
        if (has_long_lines) {
            if (file_printf(ms, ", with very long lines") == -1) {
                goto done;
            }
        }
 
        /*
         * Only report line terminators if we find one other than LF,
         * or if we find none at all.
         */
        if ((n_crlf == 0 && n_cr == 0 && n_nel == 0 && n_lf == 0) ||
            (n_crlf != 0 || n_cr != 0 || n_nel != 0)) {
            if (file_printf(ms, ", with") == -1) {
                goto done;
            }
 
            if (n_crlf == 0 && n_cr == 0 && n_nel == 0 && n_lf == 0) {
                if (file_printf(ms, " no") == -1) {
                    goto done;
                }
            } else {
                if (n_crlf) {
                    if (file_printf(ms, " CRLF") == -1) {
                        goto done;
                    }
                    if (n_cr || n_lf || n_nel) {
                        if (file_printf(ms, ",") == -1) {
                            goto done;
                        }
                    }
                }
                if (n_cr) {
                    if (file_printf(ms, " CR") == -1) {
                        goto done;
                    }
                    if (n_lf || n_nel) {
                        if (file_printf(ms, ",") == -1) {
                            goto done;
                        }
                    }
                }
                if (n_lf) {
                    if (file_printf(ms, " LF") == -1) {
                        goto done;
                    }
                    if (n_nel) {
                        if (file_printf(ms, ",") == -1) {
                            goto done;
                        }
                    }
                }
                if (n_nel) {
                    if (file_printf(ms, " NEL") == -1) {
                        goto done;
                    }
                }
            }
 
            if (file_printf(ms, " line terminators") == -1) {
                goto done;
            }
        }
 
        if (has_escapes) {
            if (file_printf(ms, ", with escape sequences") == -1) {
                goto done;
            }
        }
        if (has_backspace) {
            if (file_printf(ms, ", with overstriking") == -1) {
                goto done;
            }
        }
    }
    rv = 1;
done:
    free(nbuf);
    free(ubuf);
    free(utf8_buf);
    return rv;
}

References ascmatch(), calloc(), done, encode_utf8(), test_evm::end, file_looks_utf8(), file_oomem(), file_printf(), file_softmagic(), free(), from_ebcdic(), i, ISSPC, looks_ascii(), looks_extended(), looks_latin1(), looks_ucs16(), looks_utf8_with_BOM(), malloc(), MAXLINELEN, mime, nbytes, NNAMES, NULL, p, type, and types.

Referenced by file_buffer().

file_looks_utf8()

int file_looks_utf8	(	const ut8 *	buf,
		size_t	nbytes,
		unichar *	ubuf,
		size_t *	ulen
	)

Definition at line 605 of file ascmagic.c.

                                                                                {
    size_t i;
    int n;
    unichar c;
    int gotone = 0, ctrl = 0;
 
    if (ubuf) {
        *ulen = 0;
    }
 
    for (i = 0; i < nbytes; i++) {
        if ((buf[i] & 0x80) == 0) { /* 0xxxxxxx is plain ASCII */
            /*
             * Even if the whole file is valid UTF-8 sequences,
             * still reject it if it uses weird control characters.
             */
 
            if (text_chars[buf[i]] != T) {
                ctrl = 1;
            }
 
            if (ubuf) {
                ubuf[(*ulen)++] = buf[i];
            }
        } else if ((buf[i] & 0x40) == 0) { /* 10xxxxxx never 1st byte */
            return -1;
        } else { /* 11xxxxxx begins UTF-8 */
            int following;
 
            if ((buf[i] & 0x20) == 0) { /* 110xxxxx */
                c = buf[i] & 0x1f;
                following = 1;
            } else if ((buf[i] & 0x10) == 0) { /* 1110xxxx */
                c = buf[i] & 0x0f;
                following = 2;
            } else if ((buf[i] & 0x08) == 0) { /* 11110xxx */
                c = buf[i] & 0x07;
                following = 3;
            } else if ((buf[i] & 0x04) == 0) { /* 111110xx */
                c = buf[i] & 0x03;
                following = 4;
            } else if ((buf[i] & 0x02) == 0) { /* 1111110x */
                c = buf[i] & 0x01;
                following = 5;
            } else {
                return -1;
            }
 
            for (n = 0; n < following; n++) {
                i++;
                if (i >= nbytes) {
                    goto done;
                }
 
                if ((buf[i] & 0x80) == 0 || (buf[i] & 0x40)) {
                    return -1;
                }
 
                c = (c << 6) + (buf[i] & 0x3f);
            }
 
            if (ubuf) {
                ubuf[(*ulen)++] = c;
            }
            gotone = 1;
        }
    }
done:
    return ctrl ? 0 : (gotone ? 2 : 1);
}

References c, done, i, n, nbytes, T, and text_chars.

Referenced by file_ascmagic(), looks_utf8_with_BOM(), and set_test_type().

from_ebcdic()

static void from_ebcdic ( const ut8 *  buf, size_t  nbytes, ut8 *  out  )

static

Definition at line 809 of file ascmagic.c.

                                                                 {
    size_t i;
    for (i = 0; i < nbytes; i++) {
        out[i] = ebcdic_to_ascii[buf[i]];
    }
}

References ebcdic_to_ascii, i, nbytes, and out.

Referenced by file_ascmagic().

looks_ascii()

static int looks_ascii ( const ut8 *  buf, size_t  nbytes, unichar *  ubuf, size_t *  ulen  )

static

Definition at line 491 of file ascmagic.c.

                                                                                   {
    size_t i;
    *ulen = 0;
    for (i = 0; i < nbytes; i++) {
        int t = text_chars[buf[i]];
        if (t != T) {
            return 0;
        }
        ubuf[(*ulen)++] = buf[i];
    }
    return 1;
}

References i, nbytes, T, and text_chars.

Referenced by file_ascmagic().

looks_extended()

static int looks_extended ( const ut8 *  buf, size_t  nbytes, unichar *  ubuf, size_t *  ulen  )

static

Definition at line 518 of file ascmagic.c.

                                                                                      {
    size_t i;
    *ulen = 0;
    for (i = 0; i < nbytes; i++) {
        int t = text_chars[buf[i]];
        if (t != T && t != I && t != X) {
            return 0;
        }
        ubuf[(*ulen)++] = buf[i];
    }
    return 1;
}

References I, i, nbytes, T, text_chars, and X.

Referenced by file_ascmagic().

looks_latin1()

static int looks_latin1 ( const ut8 *  buf, size_t  nbytes, unichar *  ubuf, size_t *  ulen  )

static

Definition at line 504 of file ascmagic.c.

                                                                                    {
    size_t i;
    *ulen = 0;
 
    for (i = 0; i < nbytes; i++) {
        int t = text_chars[buf[i]];
        if (t != T && t != I) {
            return 0;
        }
        ubuf[(*ulen)++] = buf[i];
    }
    return 1;
}

References I, i, nbytes, T, and text_chars.

Referenced by file_ascmagic().

looks_ucs16()

static int looks_ucs16 ( const ut8 *  buf, size_t  nbytes, unichar *  ubuf, size_t *  ulen  )

static

Definition at line 688 of file ascmagic.c.

                                                                                   {
    int bigend;
    size_t i;
 
    if (nbytes < 2) {
        return 0;
    }
 
    if (buf[0] == 0xff && buf[1] == 0xfe) {
        bigend = 0;
    } else if (buf[0] == 0xfe && buf[1] == 0xff) {
        bigend = 1;
    } else {
        return 0;
    }
 
    *ulen = 0;
 
    for (i = 2; i + 1 < nbytes; i += 2) {
        /* XXX fix to properly handle chars > 65536 */
 
        if (bigend) {
            ubuf[(*ulen)++] = buf[i + 1] + 256 * buf[i];
        } else {
            ubuf[(*ulen)++] = buf[i] + 256 * buf[i + 1];
        }
 
        if (ubuf[*ulen - 1] == 0xfffe) {
            return 0;
        }
        if (ubuf[*ulen - 1] < 128 && text_chars[(size_t)ubuf[*ulen - 1]] != T) {
            return 0;
        }
    }
    return 1 + bigend;
}

References i, nbytes, T, and text_chars.

Referenced by file_ascmagic().

looks_utf8_with_BOM()

static int looks_utf8_with_BOM ( const ut8 *  buf, size_t  nbytes, unichar *  ubuf, size_t *  ulen  )

static

Definition at line 681 of file ascmagic.c.

                                                                                           {
    if (nbytes > 3 && buf[0] == 0xef && buf[1] == 0xbb && buf[2] == 0xbf) {
        return file_looks_utf8(buf + 3, nbytes - 3, ubuf, ulen);
    }
    return -1;
}

References file_looks_utf8(), and nbytes.

Referenced by file_ascmagic().

Variable Documentation

ebcdic_to_ascii

ut8 ebcdic_to_ascii[]

static

Initial value:

= {
    0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15,
    16, 17, 18, 19, 157, 133, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31,
    128, 129, 130, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7,
    144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26,
    ' ', 160, 161, 162, 163, 164, 165, 166, 167, 168, 213, '.', '<', '(', '+', '|',
    '&', 169, 170, 171, 172, 173, 174, 175, 176, 177, '!', '$', '*', ')', ';', '~',
    '-', '/', 178, 179, 180, 181, 182, 183, 184, 185, 203, ',', '%', '_', '>', '?',
    186, 187, 188, 189, 190, 191, 192, 193, 194, '`', ':', '#', '@', '\'', '=', '"',
    195, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 196, 197, 198, 199, 200, 201,
    202, 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', '^', 204, 205, 206, 207, 208,
    209, 229, 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 210, 211, 212, '[', 214, 215,
    216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, ']', 230, 231,
    '{', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 232, 233, 234, 235, 236, 237,
    '}', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 238, 239, 240, 241, 242, 243,
    '\\', 159, 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 244, 245, 246, 247, 248, 249,
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 250, 251, 252, 253, 254, 255
}

Definition at line 752 of file ascmagic.c.

Referenced by from_ebcdic().

text_chars

char text_chars[256]

static

Initial value:

= {
    
    F, F, F, F, F, F, F, T, T, T, T, F, T, T, F, F, 
    
    F, F, F, F, F, F, F, F, F, F, F, T, F, F, F, F, 
    T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, 
    T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, 
    T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, 
    T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, 
    T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, 
    T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, F, 
    
    X, X, X, X, X, T, X, X, X, X, X, X, X, X, X, X, 
    X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, 
    I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, 
    I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, 
    I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, 
    I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, 
    I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, 
    I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I 
}

Definition at line 469 of file ascmagic.c.

Referenced by file_looks_utf8(), looks_ascii(), looks_extended(), looks_latin1(), and looks_ucs16().