YourWishes/jerryscript
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Improve toLowerCase and toUpperCase functions. (#1575)

Browse Source 
Language-sensitive mappings are not processed now.

Fixes #323

JerryScript-DCO-1.0-Signed-off-by: Robert Sipka rsipka.uszeged@partner.samsung.com
This commit is contained in:
Robert Sipka
2017-02-15 15:57:55 +01:00
committed by László Langó
parent 025a99ccbb
commit 1b5f839db9
5 changed files with 1163 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files
jerry-core/lit/lit-char-helpers.c
+253 -4
View File
@@ -17,6 +17,10 @@
#include "lit/lit-unicode-ranges.inc.h"
#include "lit-strings.h"
#ifndef CONFIG_DISABLE_UNICODE_CASE_CONVERSION
#include "lit-unicode-conversions.inc.h"
#endif /* !CONFIG_DISABLE_UNICODE_CASE_CONVERSION */
#define NUM_OF_ELEMENTS(array) (sizeof (array) / sizeof ((array)[0]))
/**
@@ -458,6 +462,184 @@ lit_char_is_word_char (ecma_char_t c) /**< code unit */
|| c == LIT_CHAR_UNDERSCORE);
} /* lit_char_is_word_char */
#ifndef CONFIG_DISABLE_UNICODE_CASE_CONVERSION
/**
* Check if the specified character is in one of those tables which contain bidirectional conversions.
*
* @return the mapped character sequence of an ecma character, if it's in the table.
* 0 - otherwise.
*/
static ecma_length_t
search_in_bidirectional_conversion_tables (ecma_char_t character, /**< code unit */
ecma_char_t *output_buffer_p, /**< [out] buffer for the result characters */
bool is_lowercase) /**< is lowercase conversion */
{
/* 1, Check if the specified character is part of the jerry_character_case_ranges table. */
int number_of_case_ranges = NUM_OF_ELEMENTS (jerry_character_case_ranges);
int conv_counter = 0;
for (int i = 0; i < number_of_case_ranges; i++)
{
if (i % 2 == 0 && i > 0)
{
conv_counter++;
}
int range_length = jerry_character_case_range_lengths[conv_counter];
ecma_char_t start_point = jerry_character_case_ranges[i];
if (start_point > character || character >= start_point + range_length)
{
continue;
}
int char_dist = character - start_point;
if (i % 2 == 0)
{
output_buffer_p[0] = is_lowercase ? (ecma_char_t) (jerry_character_case_ranges[i + 1] + char_dist) : character;
}
else
{
output_buffer_p[0] = is_lowercase ? character : (ecma_char_t) (jerry_character_case_ranges[i - 1] + char_dist);
}
return 1;
}
/* 2, Check if the specified character is part of the character_pair_ranges table. */
int bottom = 0;
int top = NUM_OF_ELEMENTS (jerry_character_pair_ranges) - 1;
while (bottom <= top)
{
int middle = (bottom + top) / 2;
ecma_char_t current_sp = jerry_character_pair_ranges[middle];
if (current_sp <= character && character < current_sp + jerry_character_pair_range_lengths[middle])
{
int char_dist = character - current_sp;
if ((character - current_sp) % 2 == 0)
{
output_buffer_p[0] = is_lowercase ? (ecma_char_t) (current_sp + char_dist + 1) : character;
}
else
{
output_buffer_p[0] = is_lowercase ? character : (ecma_char_t) (current_sp + char_dist - 1);
}
return 1;
}
if (character > current_sp)
{
bottom = middle + 1;
}
else
{
top = middle - 1;
}
}
/* 3, Check if the specified character is part of the character_pairs table. */
int number_of_character_pairs = NUM_OF_ELEMENTS (jerry_character_pairs);
for (int i = 0; i < number_of_character_pairs; i++)
{
if (character != jerry_character_pairs[i])
{
continue;
}
if (i % 2 == 0)
{
output_buffer_p[0] = is_lowercase ? jerry_character_pairs[i + 1] : character;
}
else
{
output_buffer_p[0] = is_lowercase ? character : jerry_character_pairs[i - 1];
}
return 1;
}
return 0;
} /* search_in_bidirectional_conversion_tables */
/**
* Check if the specified character is in the given conversion table.
*
* @return the mapped character sequence of an ecma character, if it's in the table.
* 0 - otherwise.
*/
static ecma_length_t
search_in_conversion_table (ecma_char_t character, /**< code unit */
ecma_char_t *output_buffer_p, /**< [out] buffer for the result characters */
const ecma_char_t *array, /**< array */
const uint8_t *counters) /**< case_values counter */
{
int end_point = 0;
for (int i = 0; i < 3; i++)
{
int start_point = end_point;
int size_of_case_value = i + 1;
end_point += counters[i] * (size_of_case_value + 1);
int bottom = start_point;
int top = end_point - size_of_case_value;
while (bottom <= top)
{
int middle = (bottom + top) / 2;
middle -= ((middle - bottom) % (size_of_case_value + 1));
ecma_char_t current = array[middle];
if (current == character)
{
ecma_length_t char_sequence = 1;
switch (size_of_case_value)
{
case 3:
{
output_buffer_p[2] = array[middle + 3];
char_sequence++;
/* FALLTHRU */
}
case 2:
{
output_buffer_p[1] = array[middle + 2];
char_sequence++;
/* FALLTHRU */
}
default:
{
output_buffer_p[0] = array[middle + 1];
return char_sequence;
}
}
}
if (character < current)
{
top = middle - (size_of_case_value + 1);
}
else
{
bottom = middle + (size_of_case_value + 1);
}
}
}
return 0;
} /* search_in_conversion_table */
#endif /* !CONFIG_DISABLE_UNICODE_CASE_CONVERSION */
/**
* Returns the lowercase character sequence of an ecma character.
*
@@ -471,8 +653,6 @@ lit_char_to_lower_case (ecma_char_t character, /**< input character value */
ecma_char_t *output_buffer_p, /**< [out] buffer for the result characters */
ecma_length_t buffer_size) /**< buffer size */
{
/* TODO: Needs a proper lower case implementation. See issue #323. */
JERRY_ASSERT (buffer_size >= LIT_MAXIMUM_OTHER_CASE_LENGTH);
if (character >= LIT_CHAR_UPPERCASE_A && character <= LIT_CHAR_UPPERCASE_Z)
@@ -481,6 +661,41 @@ lit_char_to_lower_case (ecma_char_t character, /**< input character value */
return 1;
}
#ifndef CONFIG_DISABLE_UNICODE_CASE_CONVERSION
ecma_length_t lowercase_sequence = search_in_bidirectional_conversion_tables (character, output_buffer_p, true);
if (lowercase_sequence != 0)
{
return lowercase_sequence;
}
int num_of_lowercase_ranges = NUM_OF_ELEMENTS (jerry_lower_case_ranges);
for (int i = 0, j = 0; i < num_of_lowercase_ranges; i += 2, j++)
{
int range_length = jerry_lower_case_range_lengths[j] - 1;
ecma_char_t start_point = jerry_lower_case_ranges[i];
if (start_point <= character && character <= start_point + range_length)
{
output_buffer_p[0] = (ecma_char_t) (jerry_lower_case_ranges[i + 1] + (character - start_point));
return 1;
}
}
lowercase_sequence = search_in_conversion_table (character,
output_buffer_p,
jerry_lower_case_conversions,
jerry_lower_case_conversion_counters);
if (lowercase_sequence != 0)
{
return lowercase_sequence;
}
#endif /* !CONFIG_DISABLE_UNICODE_CASE_CONVERSION */
output_buffer_p[0] = character;
return 1;
} /* lit_char_to_lower_case */
@@ -498,8 +713,6 @@ lit_char_to_upper_case (ecma_char_t character, /**< input character value */
ecma_char_t *output_buffer_p, /**< buffer for the result characters */
ecma_length_t buffer_size) /**< buffer size */
{
/* TODO: Needs a proper upper case implementation. See issue #323. */
JERRY_ASSERT (buffer_size >= LIT_MAXIMUM_OTHER_CASE_LENGTH);
if (character >= LIT_CHAR_LOWERCASE_A && character <= LIT_CHAR_LOWERCASE_Z)
@@ -508,6 +721,42 @@ lit_char_to_upper_case (ecma_char_t character, /**< input character value */
return 1;
}
#ifndef CONFIG_DISABLE_UNICODE_CASE_CONVERSION
ecma_length_t uppercase_sequence = search_in_bidirectional_conversion_tables (character, output_buffer_p, false);
if (uppercase_sequence != 0)
{
return uppercase_sequence;
}
int num_of_upper_case_special_ranges = NUM_OF_ELEMENTS (jerry_upper_case_special_ranges);
for (int i = 0, j = 0; i < num_of_upper_case_special_ranges; i += 3, j++)
{
int range_length = jerry_upper_case_special_range_lengths[j];
ecma_char_t start_point = jerry_upper_case_special_ranges[i];
if (start_point <= character && character <= start_point + range_length)
{
output_buffer_p[0] = (ecma_char_t) (jerry_upper_case_special_ranges[i + 1] + (character - start_point));
output_buffer_p[1] = (ecma_char_t) (jerry_upper_case_special_ranges[i + 2]);
return 2;
}
}
uppercase_sequence = search_in_conversion_table (character,
output_buffer_p,
jerry_upper_case_conversions,
jerry_upper_case_conversion_counters);
if (uppercase_sequence != 0)
{
return uppercase_sequence;
}
#endif /* !CONFIG_DISABLE_UNICODE_CASE_CONVERSION */
output_buffer_p[0] = character;
return 1;
} /* lit_char_to_upper_case */
jerry-core/lit/lit-unicode-conversions.inc.h
+162
View File
@@ -0,0 +1,162 @@
/* Copyright JS Foundation and other contributors, http://js.foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* This file is automatically generated by the unicode_case_conversion.py script. Do not edit!
*/
/* Contains start points of character case ranges (these are bidirectional conversions). */
static const uint16_t jerry_character_case_ranges[] JERRY_CONST_DATA =
{
0x00c0, 0x00e0, 0x00d8, 0x00f8, 0x0189, 0x0256, 0x01b1, 0x028a, 0x0388, 0x03ad,
0x038e, 0x03cd, 0x0391, 0x03b1, 0x03a3, 0x03c3, 0x03fd, 0x037b, 0x0400, 0x0450,
0x0410, 0x0430, 0x0531, 0x0561, 0x10a0, 0x2d00, 0x13a0, 0xab70, 0x13f0, 0x13f8,
0x1f08, 0x1f00, 0x1f18, 0x1f10, 0x1f28, 0x1f20, 0x1f38, 0x1f30, 0x1f48, 0x1f40,
0x1f68, 0x1f60, 0x1fb8, 0x1fb0, 0x1fba, 0x1f70, 0x1fc8, 0x1f72, 0x1fd8, 0x1fd0,
0x1fda, 0x1f76, 0x1fe8, 0x1fe0, 0x1fea, 0x1f7a, 0x1ff8, 0x1f78, 0x1ffa, 0x1f7c,
0x2160, 0x2170, 0x24b6, 0x24d0, 0x2c00, 0x2c30, 0x2c7e, 0x023f, 0xff21, 0xff41
};
/* Interval lengths of start points in `character_case_ranges` table. */
static const uint8_t jerry_character_case_range_lengths[] JERRY_CONST_DATA =
{
0x0017, 0x0007, 0x0002, 0x0002, 0x0003, 0x0002, 0x0011, 0x0009, 0x0003, 0x0010,
0x0020, 0x0026, 0x0026, 0x0050, 0x0006, 0x0008, 0x0006, 0x0008, 0x0008, 0x0006,
0x0008, 0x0002, 0x0002, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
0x0010, 0x001a, 0x002f, 0x0002, 0x001a
};
/* Contains the start points of bidirectional conversion ranges. */
static const uint16_t jerry_character_pair_ranges[] JERRY_CONST_DATA =
{
0x0100, 0x0132, 0x0139, 0x014a, 0x0179, 0x0182, 0x0187, 0x018b, 0x0191, 0x0198,
0x01a0, 0x01a7, 0x01ac, 0x01af, 0x01b3, 0x01b8, 0x01bc, 0x01cd, 0x01de, 0x01f4,
0x01f8, 0x0222, 0x023b, 0x0241, 0x0246, 0x0370, 0x0376, 0x03d8, 0x03f7, 0x03fa,
0x0460, 0x048a, 0x04c1, 0x04d0, 0x1e00, 0x1ea0, 0x2183, 0x2c60, 0x2c67, 0x2c72,
0x2c75, 0x2c80, 0x2ceb, 0x2cf2, 0xa640, 0xa680, 0xa722, 0xa732, 0xa779, 0xa77e,
0xa78b, 0xa790, 0xa796, 0xa7b4
};
/* Interval lengths of start points in `character_pair_ranges` table. */
static const uint8_t jerry_character_pair_range_lengths[] JERRY_CONST_DATA =
{
0x0030, 0x0006, 0x0010, 0x002e, 0x0006, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002,
0x0006, 0x0002, 0x0002, 0x0002, 0x0004, 0x0002, 0x0002, 0x0010, 0x0012, 0x0002,
0x0028, 0x0012, 0x0002, 0x0002, 0x000a, 0x0004, 0x0002, 0x0018, 0x0002, 0x0002,
0x0022, 0x0036, 0x000e, 0x0060, 0x0096, 0x0060, 0x0002, 0x0002, 0x0006, 0x0002,
0x0002, 0x0064, 0x0004, 0x0002, 0x002e, 0x001c, 0x000e, 0x003e, 0x0004, 0x000a,
0x0002, 0x0004, 0x0014, 0x0004
};
/* Contains lower/upper case bidirectional conversion pairs. */
static const uint16_t jerry_character_pairs[] JERRY_CONST_DATA =
{
0x0178, 0x00ff, 0x0181, 0x0253, 0x0186, 0x0254, 0x018e, 0x01dd, 0x018f, 0x0259,
0x0190, 0x025b, 0x0193, 0x0260, 0x0194, 0x0263, 0x0196, 0x0269, 0x0197, 0x0268,
0x019c, 0x026f, 0x019d, 0x0272, 0x019f, 0x0275, 0x01a6, 0x0280, 0x01a9, 0x0283,
0x01ae, 0x0288, 0x01b7, 0x0292, 0x01c4, 0x01c6, 0x01c7, 0x01c9, 0x01ca, 0x01cc,
0x01f1, 0x01f3, 0x01f6, 0x0195, 0x01f7, 0x01bf, 0x0220, 0x019e, 0x023a, 0x2c65,
0x023d, 0x019a, 0x023e, 0x2c66, 0x0243, 0x0180, 0x0244, 0x0289, 0x0245, 0x028c,
0x037f, 0x03f3, 0x0386, 0x03ac, 0x038c, 0x03cc, 0x03cf, 0x03d7, 0x03f9, 0x03f2,
0x04c0, 0x04cf, 0x10c7, 0x2d27, 0x10cd, 0x2d2d, 0x1f59, 0x1f51, 0x1f5b, 0x1f53,
0x1f5d, 0x1f55, 0x1f5f, 0x1f57, 0x1fec, 0x1fe5, 0x2132, 0x214e, 0x2c62, 0x026b,
0x2c63, 0x1d7d, 0x2c64, 0x027d, 0x2c6d, 0x0251, 0x2c6e, 0x0271, 0x2c6f, 0x0250,
0x2c70, 0x0252, 0xa77d, 0x1d79, 0xa78d, 0x0265, 0xa7aa, 0x0266, 0xa7ab, 0x025c,
0xa7ac, 0x0261, 0xa7ad, 0x026c, 0xa7ae, 0x026a, 0xa7b0, 0x029e, 0xa7b1, 0x0287,
0xa7b2, 0x029d, 0xa7b3, 0xab53
};
/* Contains start points of one-to-two uppercase ranges where the second character
* is always the same.
*/
static const uint16_t jerry_upper_case_special_ranges[] JERRY_CONST_DATA =
{
0x1f80, 0x1f08, 0x0399, 0x1f88, 0x1f08, 0x0399, 0x1f90, 0x1f28, 0x0399, 0x1f98,
0x1f28, 0x0399, 0x1fa0, 0x1f68, 0x0399, 0x1fa8, 0x1f68, 0x0399
};
/* Interval lengths for start points in `upper_case_special_ranges` table. */
static const uint8_t jerry_upper_case_special_range_lengths[] JERRY_CONST_DATA =
{
0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007
};
/* Contains start points of lowercase ranges. */
static const uint16_t jerry_lower_case_ranges[] JERRY_CONST_DATA =
{
0x1e96, 0x1e96, 0x1f80, 0x1f80, 0x1f88, 0x1f80, 0x1f90, 0x1f90, 0x1f98, 0x1f90,
0x1fa0, 0x1fa0, 0x1fa8, 0x1fa0, 0x1fb2, 0x1fb2, 0x1fb6, 0x1fb6, 0x1fc2, 0x1fc2,
0x1fc6, 0x1fc6, 0x1fd2, 0x1fd2, 0x1fd6, 0x1fd6, 0x1fe2, 0x1fe2, 0x1fe6, 0x1fe6,
0x1ff2, 0x1ff2, 0x1ff6, 0x1ff6, 0xfb00, 0xfb00, 0xfb13, 0xfb13
};
/* Interval lengths for start points in `lower_case_ranges` table. */
static const uint8_t jerry_lower_case_range_lengths[] JERRY_CONST_DATA =
{
0x0005, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0003, 0x0002, 0x0003,
0x0002, 0x0002, 0x0002, 0x0003, 0x0002, 0x0003, 0x0002, 0x0007, 0x0005
};
/* The remaining lowercase conversions. The lowercase variant can be one-to-three character long. */
static const uint16_t jerry_lower_case_conversions[] JERRY_CONST_DATA =
{
0x00df, 0x00df, 0x0149, 0x0149, 0x01c5, 0x01c6, 0x01c8, 0x01c9, 0x01cb, 0x01cc,
0x01f0, 0x01f0, 0x01f2, 0x01f3, 0x0390, 0x0390, 0x03b0, 0x03b0, 0x03f4, 0x03b8,
0x0587, 0x0587, 0x1e9e, 0x00df, 0x1f50, 0x1f50, 0x1f52, 0x1f52, 0x1f54, 0x1f54,
0x1f56, 0x1f56, 0x1fbc, 0x1fb3, 0x1fcc, 0x1fc3, 0x1ffc, 0x1ff3, 0x2126, 0x03c9,
0x212a, 0x006b, 0x212b, 0x00e5, 0x0130, 0x0069, 0x0307
};
/* Number of one-to-one, one-to-two, and one-to-three lowercase conversions. */
static const uint8_t jerry_lower_case_conversion_counters[] JERRY_CONST_DATA =
{
0x0016, 0x0001, 0x0000
};
/* The remaining uppercase conversions. The uppercase variant can be one-to-three character long. */
static const uint16_t jerry_upper_case_conversions[] JERRY_CONST_DATA =
{
0x00b5, 0x039c, 0x0130, 0x0130, 0x0131, 0x0049, 0x017f, 0x0053, 0x01c5, 0x01c4,
0x01c8, 0x01c7, 0x01cb, 0x01ca, 0x01f2, 0x01f1, 0x0345, 0x0399, 0x03c2, 0x03a3,
0x03d0, 0x0392, 0x03d1, 0x0398, 0x03d5, 0x03a6, 0x03d6, 0x03a0, 0x03f0, 0x039a,
0x03f1, 0x03a1, 0x03f5, 0x0395, 0x1c80, 0x0412, 0x1c81, 0x0414, 0x1c82, 0x041e,
0x1c83, 0x0421, 0x1c84, 0x0422, 0x1c85, 0x0422, 0x1c86, 0x042a, 0x1c87, 0x0462,
0x1c88, 0xa64a, 0x1e9b, 0x1e60, 0x1fbe, 0x0399, 0x00df, 0x0053, 0x0053, 0x0149,
0x02bc, 0x004e, 0x01f0, 0x004a, 0x030c, 0x0587, 0x0535, 0x0552, 0x1e96, 0x0048,
0x0331, 0x1e97, 0x0054, 0x0308, 0x1e98, 0x0057, 0x030a, 0x1e99, 0x0059, 0x030a,
0x1e9a, 0x0041, 0x02be, 0x1f50, 0x03a5, 0x0313, 0x1f87, 0x1f0f, 0x0399, 0x1f8f,
0x1f0f, 0x0399, 0x1f97, 0x1f2f, 0x0399, 0x1f9f, 0x1f2f, 0x0399, 0x1fa7, 0x1f6f,
0x0399, 0x1faf, 0x1f6f, 0x0399, 0x1fb2, 0x1fba, 0x0399, 0x1fb3, 0x0391, 0x0399,
0x1fb4, 0x0386, 0x0399, 0x1fb6, 0x0391, 0x0342, 0x1fbc, 0x0391, 0x0399, 0x1fc2,
0x1fca, 0x0399, 0x1fc3, 0x0397, 0x0399, 0x1fc4, 0x0389, 0x0399, 0x1fc6, 0x0397,
0x0342, 0x1fcc, 0x0397, 0x0399, 0x1fd6, 0x0399, 0x0342, 0x1fe4, 0x03a1, 0x0313,
0x1fe6, 0x03a5, 0x0342, 0x1ff2, 0x1ffa, 0x0399, 0x1ff3, 0x03a9, 0x0399, 0x1ff4,
0x038f, 0x0399, 0x1ff6, 0x03a9, 0x0342, 0x1ffc, 0x03a9, 0x0399, 0xfb00, 0x0046,
0x0046, 0xfb01, 0x0046, 0x0049, 0xfb02, 0x0046, 0x004c, 0xfb05, 0x0053, 0x0054,
0xfb06, 0x0053, 0x0054, 0xfb13, 0x0544, 0x0546, 0xfb14, 0x0544, 0x0535, 0xfb15,
0x0544, 0x053b, 0xfb16, 0x054e, 0x0546, 0xfb17, 0x0544, 0x053d, 0x0390, 0x0399,
0x0308, 0x0301, 0x03b0, 0x03a5, 0x0308, 0x0301, 0x1f52, 0x03a5, 0x0313, 0x0300,
0x1f54, 0x03a5, 0x0313, 0x0301, 0x1f56, 0x03a5, 0x0313, 0x0342, 0x1fb7, 0x0391,
0x0342, 0x0399, 0x1fc7, 0x0397, 0x0342, 0x0399, 0x1fd2, 0x0399, 0x0308, 0x0300,
0x1fd3, 0x0399, 0x0308, 0x0301, 0x1fd7, 0x0399, 0x0308, 0x0342, 0x1fe2, 0x03a5,
0x0308, 0x0300, 0x1fe3, 0x03a5, 0x0308, 0x0301, 0x1fe7, 0x03a5, 0x0308, 0x0342,
0x1ff7, 0x03a9, 0x0342, 0x0399, 0xfb03, 0x0046, 0x0046, 0x0049, 0xfb04, 0x0046,
0x0046, 0x004c
};
/* Number of one-to-one, one-to-two, and one-to-three lowercase conversions. */
static const uint8_t jerry_upper_case_conversion_counters[] JERRY_CONST_DATA =
{
0x001c, 0x002c, 0x0010
};
jerry-core/profiles/minimal.profile
+1
View File
@@ -10,4 +10,5 @@ CONFIG_DISABLE_NUMBER_BUILTIN
CONFIG_DISABLE_REGEXP_BUILTIN
CONFIG_DISABLE_STRING_BUILTIN
CONFIG_DISABLE_TYPEDARRAY_BUILTIN
CONFIG_DISABLE_UNICODE_CASE_CONVERSION