[libyaml.git] / src / reader.c


#if HAVE_CONFIG_H
#include <config.h>
#endif

#include <yaml/yaml.h>

#include <assert.h>

/*
 * Set the reader error and return 0.
 */

int
yaml_parser_set_reader_error(yaml_parser_t *parser, const char *problem)
{
    parser->error = YAML_READER_ERROR;
    parser->problem = problem;
    parser->problem_offset = parser->offset;

    return 0;
}


/*
 * Ensure that the buffer contains at least length characters.
 * Return 1 on success, 0 on failure.
 *
 * The length is supposed to be significantly less that the buffer size.
 */

int
yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)
{
    /* If the EOF flag is set, do nothing. */

    if (parser->eof)
        return 1;

    /* Return if the buffer contains enough characters. */

    if (parser->unread >= length)
        return 1;

    /* Determine the input encoding if it is not known yet. */

    if (!parser->encoding) {
        if (!yaml_parser_determine_encoding(parser))
            return 0;
    }

    /* Move the unread characters to the beginning of the buffer. */

    if (parser->buffer < parser->pointer
            && parser->pointer < parser->buffer_end) {
        size_t size = parser->buffer_end - parser->pointer;
        memmove(parser->buffer, parser->pointer, size);
        parser->pointer = parser->buffer;
        parser->buffer_end -= size;
    }
    else if (parser->pointer == parser->buffer_end) {
        parser->pointer = parser->buffer;
        parser->buffer_end = parser->buffer;
    }

    /* Fill the buffer until it has enough characters. */

    while (parser->unread < length)
    {
        /* Fill the raw buffer. */

        if (!yaml_parser_update_raw_buffer(parser)) return 0;

        /* If the raw buffer is empty, it is EOF. */

        if (!parser->raw_unread) return 1;

        /* Decode the raw buffer. */

        while (parser->raw_unread)
        {
            unsigned int value, value2;
            int incomplete = 0;
            unsigned char utf8_octet;
            unsigned int utf8_length;
            int k, low, high;

            /* Decode the next character. */

            switch (parser->encoding)
            {
                case YAML_UTF8_ENCODING:

                    /*
                     * Decode a UTF-8 character.  Check RFC 3629
                     * (http://www.ietf.org/rfc/rfc3629.txt) for more details.
                     *
                     * The following table (taken from the RFC) is used for
                     * decoding.
                     *
                     *    Char. number range |        UTF-8 octet sequence
                     *      (hexadecimal)    |              (binary)
                     *   --------------------+------------------------------------
                     *   0000 0000-0000 007F | 0xxxxxxx
                     *   0000 0080-0000 07FF | 110xxxxx 10xxxxxx
                     *   0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
                     *   0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
                     *
                     * Additionally, the characters in the range 0xD800-0xDFFF
                     * are prohibited as they are reserved for use with UTF-16
                     * surrogate pairs.
                     */

                    /* Determine the length of the UTF-8 sequence. */

                    utf8_octet = parser->raw_pointer[0];
                    utf8_length = (
                            (utf8_octet & 0x80) == 0x00 ? 1 :
                            (utf8_octet & 0xE0) == 0xC0 ? 2 :
                            (utf8_octet & 0xF0) == 0xE0 ? 3 :
                            (utf8_octet & 0xF8) == 0xF0 ? 4 : 0);

                    /* Check if the leading octet is valid. */

                    if (!utf8_length)
                        return yaml_parser_set_reader_error(parser,
                                "Invalid leading UTF-8 octet");

                    /* Check if the raw buffer contains an incomplete character. */

                    if (utf8_length > parser->raw_unread) {
                        if (parser->eof) {
                            return yaml_parser_set_reader_error(parser,
                                    "Incomplete UTF-8 octet sequence");
                        }
                        incomplete = 1;
                        break;
                    }

                    /* Decode the leading octet. */

                    value = (
                        (utf8_octet & 0x80) == 0x00 ? utf8_octet & 0x7F :
                        (utf8_octet & 0xE0) == 0xC0 ? utf8_octet & 0x1F :
                        (utf8_octet & 0xF0) == 0xE0 ? utf8_octet & 0x0F :
                        (utf8_octet & 0xF8) == 0xF0 ? utf8_octet & 0x07 : 0);

                    /* Check and decode the trailing octets. */

                    for (k = 1; k < utf8_length; k ++)
                    {
                        utf8_octet = parser->raw_pointer[k];

                        /* Check if the octet is valid. */

                        if ((utf8_octet & 0xC0) != 0x80)
                            return yaml_parser_set_reader_error(parser,
                                    "Invalid trailing UTF-8 octet");

                        /* Decode the octet. */

                        value = (value << 6) + (utf8_octet & 0x3F);
                    }

                    /* Check the length of the sequence against the value. */

                    if (!((utf8_length == 1) ||
                            (utf8_length == 2 && value >= 0x80) ||
                            (utf8_length == 3 && value >= 0x800) ||
                            (utf8_length == 4 && value >= 0x10000)))
                        return yaml_parser_set_reader_error(parser,
                                "Invalid length of a UTF-8 sequence");

                    /* Check the range of the value. */

                    if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF)
                        return yaml_parser_set_reader_error(parser,
                                "Invalid Unicode character");

                    parser->raw_pointer += utf8_length;
                    parser->raw_unread -= utf8_length;
                    parser->offset += utf8_length;

                    break;
                
                case YAML_UTF16LE_ENCODING:
                case YAML_UTF16BE_ENCODING:

                    low = (parser->encoding == YAML_UTF16LE_ENCODING ? 0 : 1);
                    high = (parser->encoding == YAML_UTF16LE_ENCODING ? 1 : 0);

                    /*
                     * The UTF-16 encoding is not as simple as one might
                     * naively think.  Check RFC 2781
                     * (http://www.ietf.org/rfc/rfc2781.txt).
                     *
                     * Normally, two subsequent bytes describe a Unicode
                     * character.  However a special technique (called a
                     * surrogate pair) is used for specifying character
                     * values larger than 0xFFFF.
                     *
                     * A surrogate pair consists of two pseudo-characters:
                     *      high surrogate area (0xD800-0xDBFF)
                     *      low surrogate area (0xDC00-0xDFFF)
                     *
                     * The following formulas are used for decoding
                     * and encoding characters using surrogate pairs:
                     * 
                     *  U  = U' + 0x10000   (0x01 00 00 <= U <= 0x10 FF FF)
                     *  U' = yyyyyyyyyyxxxxxxxxxx   (0 <= U' <= 0x0F FF FF)
                     *  W1 = 110110yyyyyyyyyy
                     *  W2 = 110111xxxxxxxxxx
                     *
                     * where U is the character value, W1 is the high surrogate
                     * area, W2 is the low surrogate area.
                     */

                    /* Check for incomplete UTF-16 character. */

                    if (parser->raw_unread < 2) {
                        if (parser->eof) {
                            return yaml_parser_set_reader_error(parser,
                                    "Incomplete UTF-16 character");
                        }
                        incomplete = 1;
                        break;
                    }

                    /* Get the character. */

                    value = parser->raw_pointer[low]
                        + (parser->raw_pointer[high] << 8);

                    /* Check for unexpected low surrogate area. */

                    if ((value & 0xFC00) == 0xDC00)
                        return yaml_parser_set_reader_error(parser,
                                "Unexpected low surrogate area");

                    /* Check for a high surrogate area. */

                    if ((value & 0xFC00) == 0xD800) {

                        /* Check for incomplete surrogate pair. */

                        if (parser->raw_unread < 4) {
                            if (parser->eof) {
                                return yaml_parser_set_reader_error(parser,
                                        "Incomplete UTF-16 surrogate pair");
                            }
                            incomplete = 1;
                            break;
                        }

                        /* Get the next character. */

                        unsigned int value2 = parser->raw_pointer[low+2]
                            + (parser->raw_pointer[high+2] << 8);

                        /* Check for a low surrogate area. */

                        if ((value2 & 0xFC00) != 0xDC00)
                            return yaml_parser_set_reader_error(parser,
                                    "Expected low surrogate area");

                        /* Generate the value of the surrogate pair. */

                        value = 0x10000 + ((value & 0x3FF) << 10) + (value2 & 0x3FF);

                        parser->raw_pointer += 4;
                        parser->raw_unread -= 4;
                        parser->offset += 4;
                    }

                    else {
                        parser->raw_pointer += 2;
                        parser->raw_unread -= 2;
                        parser->offset += 4;
                    }

                    break;
            }

            /* Check if the raw buffer contains enough bytes to form a character. */

            if (incomplete) break;

            /*
             * Check if the character is in the allowed range:
             *      #x9 | #xA | #xD | [#x20-#x7E]               (8 bit)
             *      | #x85 | [#xA0-#xD7FF] | [#xE000-#xFFFD]    (16 bit)
             *      | [#x10000-#x10FFFF]                        (32 bit)
             */

            if (! (value == 0x09 || value == 0x0A || value == 0x0D
                        || (value >= 0x20 && value <= 0x7E)
                        || (value == 0x85) || (value >= 0xA0 && value <= 0xD7FF)
                        || (value >= 0xE000 && value <= 0xFFFD)
                        || (value >= 0x10000 && value <= 0x10FFFF)))
                return yaml_parser_set_reader_error(parser,
                        "Control characters are not allowed");

            /* Finally put the character into the buffer. */

            /* 0000 0000-0000 007F -> 0xxxxxxx */
            if (value <= 0x7F) {
                *(parser->buffer_end++) = value;
            }
            /* 0000 0080-0000 07FF -> 110xxxxx 10xxxxxx */
            else if (value <= 0x7FF) {
                *(parser->buffer_end++) = 0xC0 + (value >> 6);
                *(parser->buffer_end++) = 0x80 + value & 0x3F;
            }
            /* 0000 0800-0000 FFFF -> 1110xxxx 10xxxxxx 10xxxxxx */
            else if (value <= 0xFFFF) {
                *(parser->buffer_end++) = 0xE0 + (value >> 12);
                *(parser->buffer_end++) = 0x80 + (value >> 6) & 0x3F;
                *(parser->buffer_end++) = 0x80 + value & 0x3F;
            }
            /* 0001 0000-0010 FFFF -> 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
            else {
                *(parser->buffer_end++) = 0xF0 + (value >> 18);
                *(parser->buffer_end++) = 0x80 + (value >> 12) & 0x3F;
                *(parser->buffer_end++) = 0x80 + (value >> 6) & 0x3F;
                *(parser->buffer_end++) = 0x80 + value & 0x3F;
            }
        }
    }

    return 1;
}

/*
 * Determine the input stream encoding by checking the BOM symbol. If no BOM is
 * found, the UTF-8 encoding is assumed. Return 1 on success, 0 on failure.
 */

#define BOM_UTF8    "\xef\xbb\xbf"
#define BOM_UTF16LE "\xff\xfe"
#define BOM_UTF16BE "\xfe\xff"

int
yaml_parser_determine_encoding(yaml_parser_t *parser)
{
    /* Ensure that we had enough bytes in the raw buffer. */

    while (!parser->eof && parser->raw_unread < 3) {
        if (!yaml_parser_update_raw_buffer(parser)) {
            return 0;
        }
    }

    /* Determine the encoding. */

    if (parser->raw_unread >= 2
            && !memcmp(parser->raw_pointer, BOM_UTF16LE, 2)) {
        parser->encoding = YAML_UTF16LE_ENCODING;
        parser->raw_pointer += 2;
        parser->raw_unread -= 2;
    }
    else if (parser->raw_unread >= 2
            && !memcmp(parser->raw_pointer, BOM_UTF16BE, 2)) {
        parser->encoding = YAML_UTF16BE_ENCODING;
        parser->raw_pointer += 2;
        parser->raw_unread -= 2;
    }
    else if (parser->raw_unread >= 3
            && !memcmp(parser->raw_pointer, BOM_UTF8, 3)) {
        parser->encoding = YAML_UTF8_ENCODING;
        parser->raw_pointer += 3;
        parser->raw_unread -= 3;
    }
    else {
        parser->encoding = YAML_UTF8_ENCODING;
    }

    return 1;
}

/*
 * Update the raw buffer.
 */

int
yaml_parser_update_raw_buffer(yaml_parser_t *parser)
{
    size_t size_read = 0;

    /* Return if the raw buffer is full. */

    if (parser->raw_unread == YAML_RAW_BUFFER_SIZE) return 1;

    /* Return on EOF. */

    if (parser->eof) return 1;

    /* Move the remaining bytes in the raw buffer to the beginning. */

    if (parser->raw_unread && parser->raw_buffer < parser->raw_pointer) {
        memmove(parser->raw_buffer, parser->raw_pointer, parser->raw_unread);
    }
    parser->raw_pointer = parser->raw_buffer;

    /* Call the read handler to fill the buffer. */

    if (!parser->read_handler(parser->read_handler_data,
                parser->raw_buffer + parser->raw_unread,
                YAML_RAW_BUFFER_SIZE - parser->raw_unread,
                &size_read)) {
        return yaml_parser_set_reader_error(parser, "Input error");
    }
    parser->raw_unread += size_read;
    if (!size_read) {
        parser->eof = 1;
    }

    return 1;
}
Commit	Line	Data
95b98ba9	1
6eb1ded4 KS	2	#if HAVE_CONFIG_H
	3	#include <config.h>
	4	#endif
	5
	6	#include <yaml/yaml.h>
	7
	8	#include <assert.h>
	9
6eb1ded4	10	/*
3d790dfd	11	* Set the reader error and return 0.
6eb1ded4 KS	12	*/
6eb1ded4 KS	13
3d790dfd KS	14	int
	15	yaml_parser_set_reader_error(yaml_parser_t parser, const char problem)
	16	{
	17	parser->error = YAML_READER_ERROR;
	18	parser->problem = problem;
	19	parser->problem_offset = parser->offset;
6eb1ded4	20
3d790dfd KS	21	return 0;
3d790dfd KS	22	}
6eb1ded4	23
95b98ba9 KS	24
	25	/*
	26	* Ensure that the buffer contains at least length characters.
	27	* Return 1 on success, 0 on failure.
6eb1ded4 KS	28	*
6eb1ded4 KS	29	* The length is supposed to be significantly less that the buffer size.
95b98ba9 KS	30	*/
	31
	32	int
6eb1ded4	33	yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)
95b98ba9 KS	34	{
	35	/* If the EOF flag is set, do nothing. */
	36
	37	if (parser->eof)
	38	return 1;
	39
6eb1ded4 KS	40	/* Return if the buffer contains enough characters. */
	41
	42	if (parser->unread >= length)
	43	return 1;
	44
	45	/* Determine the input encoding if it is not known yet. */
95b98ba9	46
6eb1ded4 KS	47	if (!parser->encoding) {
6eb1ded4 KS	48	if (!yaml_parser_determine_encoding(parser))
95b98ba9	49	return 0;
95b98ba9 KS	50	}
95b98ba9 KS	51
6eb1ded4 KS	52	/* Move the unread characters to the beginning of the buffer. */
	53
	54	if (parser->buffer < parser->pointer
	55	&& parser->pointer < parser->buffer_end) {
	56	size_t size = parser->buffer_end - parser->pointer;
	57	memmove(parser->buffer, parser->pointer, size);
	58	parser->pointer = parser->buffer;
	59	parser->buffer_end -= size;
	60	}
	61	else if (parser->pointer == parser->buffer_end) {
	62	parser->pointer = parser->buffer;
	63	parser->buffer_end = parser->buffer;
	64	}
	65
	66	/* Fill the buffer until it has enough characters. */
	67
	68	while (parser->unread < length)
	69	{
	70	/* Fill the raw buffer. */
	71
	72	if (!yaml_parser_update_raw_buffer(parser)) return 0;
	73
3d790dfd KS	74	/* If the raw buffer is empty, it is EOF. */
	75
	76	if (!parser->raw_unread) return 1;
	77
6eb1ded4 KS	78	/* Decode the raw buffer. */
	79
	80	while (parser->raw_unread)
	81	{
3d790dfd	82	unsigned int value, value2;
6eb1ded4	83	int incomplete = 0;
3d790dfd KS	84	unsigned char utf8_octet;
	85	unsigned int utf8_length;
	86	int k, low, high;
6eb1ded4 KS	87
	88	/* Decode the next character. */
	89
	90	switch (parser->encoding)
	91	{
	92	case YAML_UTF8_ENCODING:
	93
3d790dfd KS	94	/*
	95	* Decode a UTF-8 character. Check RFC 3629
	96	* (http://www.ietf.org/rfc/rfc3629.txt) for more details.
	97	*
	98	* The following table (taken from the RFC) is used for
	99	* decoding.
	100	*
	101	* Char. number range \| UTF-8 octet sequence
	102	* (hexadecimal) \| (binary)
	103	* --------------------+------------------------------------
	104	* 0000 0000-0000 007F \| 0xxxxxxx
	105	* 0000 0080-0000 07FF \| 110xxxxx 10xxxxxx
	106	* 0000 0800-0000 FFFF \| 1110xxxx 10xxxxxx 10xxxxxx
	107	* 0001 0000-0010 FFFF \| 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
	108	*
	109	* Additionally, the characters in the range 0xD800-0xDFFF
	110	* are prohibited as they are reserved for use with UTF-16
	111	* surrogate pairs.
	112	*/
	113
	114	/* Determine the length of the UTF-8 sequence. */
	115
	116	utf8_octet = parser->raw_pointer[0];
	117	utf8_length = (
	118	(utf8_octet & 0x80) == 0x00 ? 1 :
	119	(utf8_octet & 0xE0) == 0xC0 ? 2 :
	120	(utf8_octet & 0xF0) == 0xE0 ? 3 :
	121	(utf8_octet & 0xF8) == 0xF0 ? 4 : 0);
	122
	123	/* Check if the leading octet is valid. */
	124
	125	if (!utf8_length)
	126	return yaml_parser_set_reader_error(parser,
	127	"Invalid leading UTF-8 octet");
6eb1ded4 KS	128
	129	/* Check if the raw buffer contains an incomplete character. */
	130
	131	if (utf8_length > parser->raw_unread) {
	132	if (parser->eof) {
3d790dfd KS	133	return yaml_parser_set_reader_error(parser,
3d790dfd KS	134	"Incomplete UTF-8 octet sequence");
6eb1ded4 KS	135	}
6eb1ded4 KS	136	incomplete = 1;
3d790dfd	137	break;
6eb1ded4 KS	138	}
6eb1ded4 KS	139
3d790dfd	140	/* Decode the leading octet. */
6eb1ded4	141
3d790dfd KS	142	value = (
	143	(utf8_octet & 0x80) == 0x00 ? utf8_octet & 0x7F :
	144	(utf8_octet & 0xE0) == 0xC0 ? utf8_octet & 0x1F :
	145	(utf8_octet & 0xF0) == 0xE0 ? utf8_octet & 0x0F :
	146	(utf8_octet & 0xF8) == 0xF0 ? utf8_octet & 0x07 : 0);
	147
	148	/* Check and decode the trailing octets. */
	149
	150	for (k = 1; k < utf8_length; k ++)
	151	{
	152	utf8_octet = parser->raw_pointer[k];
	153
	154	/* Check if the octet is valid. */
	155
	156	if ((utf8_octet & 0xC0) != 0x80)
	157	return yaml_parser_set_reader_error(parser,
	158	"Invalid trailing UTF-8 octet");
	159
	160	/* Decode the octet. */
	161
	162	value = (value << 6) + (utf8_octet & 0x3F);
6eb1ded4 KS	163	}
6eb1ded4 KS	164
3d790dfd KS	165	/* Check the length of the sequence against the value. */
	166
	167	if (!((utf8_length == 1) \|\|
	168	(utf8_length == 2 && value >= 0x80) \|\|
	169	(utf8_length == 3 && value >= 0x800) \|\|
	170	(utf8_length == 4 && value >= 0x10000)))
	171	return yaml_parser_set_reader_error(parser,
	172	"Invalid length of a UTF-8 sequence");
	173
	174	/* Check the range of the value. */
	175
	176	if ((value >= 0xD800 && value <= 0xDFFF) \|\| value > 0x10FFFF)
	177	return yaml_parser_set_reader_error(parser,
	178	"Invalid Unicode character");
	179
	180	parser->raw_pointer += utf8_length;
	181	parser->raw_unread -= utf8_length;
	182	parser->offset += utf8_length;
	183
6eb1ded4 KS	184	break;
	185
	186	case YAML_UTF16LE_ENCODING:
3d790dfd	187	case YAML_UTF16BE_ENCODING:
6eb1ded4	188
3d790dfd KS	189	low = (parser->encoding == YAML_UTF16LE_ENCODING ? 0 : 1);
	190	high = (parser->encoding == YAML_UTF16LE_ENCODING ? 1 : 0);
	191
	192	/*
	193	* The UTF-16 encoding is not as simple as one might
	194	* naively think. Check RFC 2781
	195	* (http://www.ietf.org/rfc/rfc2781.txt).
	196	*
	197	* Normally, two subsequent bytes describe a Unicode
	198	* character. However a special technique (called a
	199	* surrogate pair) is used for specifying character
	200	* values larger than 0xFFFF.
	201	*
	202	* A surrogate pair consists of two pseudo-characters:
	203	* high surrogate area (0xD800-0xDBFF)
	204	* low surrogate area (0xDC00-0xDFFF)
	205	*
	206	* The following formulas are used for decoding
	207	* and encoding characters using surrogate pairs:
	208	*
	209	* U = U' + 0x10000 (0x01 00 00 <= U <= 0x10 FF FF)
	210	* U' = yyyyyyyyyyxxxxxxxxxx (0 <= U' <= 0x0F FF FF)
	211	* W1 = 110110yyyyyyyyyy
	212	* W2 = 110111xxxxxxxxxx
	213	*
	214	* where U is the character value, W1 is the high surrogate
	215	* area, W2 is the low surrogate area.
	216	*/
	217
	218	/* Check for incomplete UTF-16 character. */
6eb1ded4 KS	219
	220	if (parser->raw_unread < 2) {
	221	if (parser->eof) {
3d790dfd KS	222	return yaml_parser_set_reader_error(parser,
3d790dfd KS	223	"Incomplete UTF-16 character");
6eb1ded4 KS	224	}
6eb1ded4 KS	225	incomplete = 1;
3d790dfd	226	break;
6eb1ded4 KS	227	}
6eb1ded4 KS	228
3d790dfd	229	/* Get the character. */
6eb1ded4	230
3d790dfd KS	231	value = parser->raw_pointer[low]
3d790dfd KS	232	+ (parser->raw_pointer[high] << 8);
6eb1ded4	233
3d790dfd	234	/* Check for unexpected low surrogate area. */
6eb1ded4	235
3d790dfd KS	236	if ((value & 0xFC00) == 0xDC00)
	237	return yaml_parser_set_reader_error(parser,
	238	"Unexpected low surrogate area");
6eb1ded4	239
3d790dfd	240	/* Check for a high surrogate area. */
6eb1ded4	241
3d790dfd KS	242	if ((value & 0xFC00) == 0xD800) {
	243
	244	/* Check for incomplete surrogate pair. */
	245
	246	if (parser->raw_unread < 4) {
	247	if (parser->eof) {
	248	return yaml_parser_set_reader_error(parser,
	249	"Incomplete UTF-16 surrogate pair");
	250	}
	251	incomplete = 1;
	252	break;
6eb1ded4	253	}
6eb1ded4	254
3d790dfd	255	/* Get the next character. */
6eb1ded4	256
3d790dfd KS	257	unsigned int value2 = parser->raw_pointer[low+2]
	258	+ (parser->raw_pointer[high+2] << 8);
	259
	260	/* Check for a low surrogate area. */
	261
	262	if ((value2 & 0xFC00) != 0xDC00)
	263	return yaml_parser_set_reader_error(parser,
	264	"Expected low surrogate area");
	265
	266	/* Generate the value of the surrogate pair. */
	267
	268	value = 0x10000 + ((value & 0x3FF) << 10) + (value2 & 0x3FF);
	269
	270	parser->raw_pointer += 4;
	271	parser->raw_unread -= 4;
	272	parser->offset += 4;
	273	}
	274
	275	else {
	276	parser->raw_pointer += 2;
	277	parser->raw_unread -= 2;
	278	parser->offset += 4;
	279	}
6eb1ded4 KS	280
	281	break;
	282	}
	283
3d790dfd KS	284	/* Check if the raw buffer contains enough bytes to form a character. */
	285
	286	if (incomplete) break;
	287
6eb1ded4 KS	288	/*
	289	* Check if the character is in the allowed range:
	290	* #x9 \| #xA \| #xD \| [#x20-#x7E] (8 bit)
	291	* \| #x85 \| [#xA0-#xD7FF] \| [#xE000-#xFFFD] (16 bit)
	292	* \| [#x10000-#x10FFFF] (32 bit)
	293	*/
	294
3d790dfd KS	295	if (! (value == 0x09 \|\| value == 0x0A \|\| value == 0x0D
	296	\|\| (value >= 0x20 && value <= 0x7E)
	297	\|\| (value == 0x85) \|\| (value >= 0xA0 && value <= 0xD7FF)
	298	\|\| (value >= 0xE000 && value <= 0xFFFD)
	299	\|\| (value >= 0x10000 && value <= 0x10FFFF)))
	300	return yaml_parser_set_reader_error(parser,
	301	"Control characters are not allowed");
6eb1ded4 KS	302
	303	/* Finally put the character into the buffer. */
	304
	305	/* 0000 0000-0000 007F -> 0xxxxxxx */
3d790dfd KS	306	if (value <= 0x7F) {
3d790dfd KS	307	*(parser->buffer_end++) = value;
6eb1ded4 KS	308	}
6eb1ded4 KS	309	/* 0000 0080-0000 07FF -> 110xxxxx 10xxxxxx */
3d790dfd KS	310	else if (value <= 0x7FF) {
	311	*(parser->buffer_end++) = 0xC0 + (value >> 6);
	312	*(parser->buffer_end++) = 0x80 + value & 0x3F;
6eb1ded4 KS	313	}
6eb1ded4 KS	314	/* 0000 0800-0000 FFFF -> 1110xxxx 10xxxxxx 10xxxxxx */
3d790dfd KS	315	else if (value <= 0xFFFF) {
	316	*(parser->buffer_end++) = 0xE0 + (value >> 12);
	317	*(parser->buffer_end++) = 0x80 + (value >> 6) & 0x3F;
	318	*(parser->buffer_end++) = 0x80 + value & 0x3F;
6eb1ded4 KS	319	}
	320	/* 0001 0000-0010 FFFF -> 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
	321	else {
3d790dfd KS	322	*(parser->buffer_end++) = 0xF0 + (value >> 18);
	323	*(parser->buffer_end++) = 0x80 + (value >> 12) & 0x3F;
	324	*(parser->buffer_end++) = 0x80 + (value >> 6) & 0x3F;
	325	*(parser->buffer_end++) = 0x80 + value & 0x3F;
6eb1ded4	326	}
95b98ba9	327	}
95b98ba9 KS	328	}
95b98ba9 KS	329
3d790dfd	330	return 1;
6eb1ded4	331	}
95b98ba9	332
6eb1ded4 KS	333	/*
	334	* Determine the input stream encoding by checking the BOM symbol. If no BOM is
	335	* found, the UTF-8 encoding is assumed. Return 1 on success, 0 on failure.
	336	*/
	337
3d790dfd KS	338	#define BOM_UTF8 "\xef\xbb\xbf"
	339	#define BOM_UTF16LE "\xff\xfe"
	340	#define BOM_UTF16BE "\xfe\xff"
	341
6eb1ded4 KS	342	int
	343	yaml_parser_determine_encoding(yaml_parser_t *parser)
	344	{
	345	/* Ensure that we had enough bytes in the raw buffer. */
	346
3d790dfd	347	while (!parser->eof && parser->raw_unread < 3) {
6eb1ded4	348	if (!yaml_parser_update_raw_buffer(parser)) {
95b98ba9	349	return 0;
6eb1ded4	350	}
95b98ba9 KS	351	}
95b98ba9 KS	352
6eb1ded4	353	/* Determine the encoding. */
95b98ba9	354
3d790dfd KS	355	if (parser->raw_unread >= 2
	356	&& !memcmp(parser->raw_pointer, BOM_UTF16LE, 2)) {
	357	parser->encoding = YAML_UTF16LE_ENCODING;
	358	parser->raw_pointer += 2;
	359	parser->raw_unread -= 2;
	360	}
	361	else if (parser->raw_unread >= 2
	362	&& !memcmp(parser->raw_pointer, BOM_UTF16BE, 2)) {
6eb1ded4	363	parser->encoding = YAML_UTF16BE_ENCODING;
3d790dfd KS	364	parser->raw_pointer += 2;
3d790dfd KS	365	parser->raw_unread -= 2;
6eb1ded4	366	}
3d790dfd KS	367	else if (parser->raw_unread >= 3
	368	&& !memcmp(parser->raw_pointer, BOM_UTF8, 3)) {
	369	parser->encoding = YAML_UTF8_ENCODING;
	370	parser->raw_pointer += 3;
	371	parser->raw_unread -= 3;
6eb1ded4 KS	372	}
	373	else {
	374	parser->encoding = YAML_UTF8_ENCODING;
	375	}
3d790dfd KS	376
3d790dfd KS	377	return 1;
95b98ba9 KS	378	}
95b98ba9 KS	379
6eb1ded4 KS	380	/*
	381	* Update the raw buffer.
	382	*/
	383
	384	int
	385	yaml_parser_update_raw_buffer(yaml_parser_t *parser)
	386	{
	387	size_t size_read = 0;
	388
	389	/* Return if the raw buffer is full. */
	390
	391	if (parser->raw_unread == YAML_RAW_BUFFER_SIZE) return 1;
95b98ba9	392
6eb1ded4 KS	393	/* Return on EOF. */
	394
	395	if (parser->eof) return 1;
	396
	397	/* Move the remaining bytes in the raw buffer to the beginning. */
	398
	399	if (parser->raw_unread && parser->raw_buffer < parser->raw_pointer) {
	400	memmove(parser->raw_buffer, parser->raw_pointer, parser->raw_unread);
	401	}
	402	parser->raw_pointer = parser->raw_buffer;
	403
	404	/* Call the read handler to fill the buffer. */
	405
	406	if (!parser->read_handler(parser->read_handler_data,
	407	parser->raw_buffer + parser->raw_unread,
	408	YAML_RAW_BUFFER_SIZE - parser->raw_unread,
	409	&size_read)) {
3d790dfd	410	return yaml_parser_set_reader_error(parser, "Input error");
6eb1ded4 KS	411	}
	412	parser->raw_unread += size_read;
	413	if (!size_read) {
	414	parser->eof = 1;
	415	}
	416
	417	return 1;
	418	}
95b98ba9	419