Github User Fetcher 1.0.0
C Application with Server and GUI
Loading...
Searching...
No Matches
Macros | Functions | Variables
duk_unicode.h File Reference

Go to the source code of this file.

Macros

#define DUK_UNICODE_MAX_XUTF8_LENGTH   7 /* up to 36 bit codepoints */
 
#define DUK_UNICODE_MAX_XUTF8_BMP_LENGTH   3 /* all codepoints up to U+FFFF */
 
#define DUK_UNICODE_MAX_CESU8_LENGTH   6 /* all codepoints up to U+10FFFF */
 
#define DUK_UNICODE_MAX_CESU8_BMP_LENGTH   3 /* all codepoints up to U+FFFF */
 
#define DUK_UNICODE_CP_ZWNJ   0x200cL /* zero-width non-joiner */
 
#define DUK_UNICODE_CP_ZWJ   0x200dL /* zero-width joiner */
 
#define DUK_UNICODE_CP_REPLACEMENT_CHARACTER   0xfffdL /* http://en.wikipedia.org/wiki/Replacement_character#Replacement_character */
 
#define DUK_ASC_NUL   0x00
 
#define DUK_ASC_SOH   0x01
 
#define DUK_ASC_STX   0x02
 
#define DUK_ASC_ETX   0x03
 
#define DUK_ASC_EOT   0x04
 
#define DUK_ASC_ENQ   0x05
 
#define DUK_ASC_ACK   0x06
 
#define DUK_ASC_BEL   0x07
 
#define DUK_ASC_BS   0x08
 
#define DUK_ASC_HT   0x09
 
#define DUK_ASC_LF   0x0a
 
#define DUK_ASC_VT   0x0b
 
#define DUK_ASC_FF   0x0c
 
#define DUK_ASC_CR   0x0d
 
#define DUK_ASC_SO   0x0e
 
#define DUK_ASC_SI   0x0f
 
#define DUK_ASC_DLE   0x10
 
#define DUK_ASC_DC1   0x11
 
#define DUK_ASC_DC2   0x12
 
#define DUK_ASC_DC3   0x13
 
#define DUK_ASC_DC4   0x14
 
#define DUK_ASC_NAK   0x15
 
#define DUK_ASC_SYN   0x16
 
#define DUK_ASC_ETB   0x17
 
#define DUK_ASC_CAN   0x18
 
#define DUK_ASC_EM   0x19
 
#define DUK_ASC_SUB   0x1a
 
#define DUK_ASC_ESC   0x1b
 
#define DUK_ASC_FS   0x1c
 
#define DUK_ASC_GS   0x1d
 
#define DUK_ASC_RS   0x1e
 
#define DUK_ASC_US   0x1f
 
#define DUK_ASC_SPACE   0x20
 
#define DUK_ASC_EXCLAMATION   0x21
 
#define DUK_ASC_DOUBLEQUOTE   0x22
 
#define DUK_ASC_HASH   0x23
 
#define DUK_ASC_DOLLAR   0x24
 
#define DUK_ASC_PERCENT   0x25
 
#define DUK_ASC_AMP   0x26
 
#define DUK_ASC_SINGLEQUOTE   0x27
 
#define DUK_ASC_LPAREN   0x28
 
#define DUK_ASC_RPAREN   0x29
 
#define DUK_ASC_STAR   0x2a
 
#define DUK_ASC_PLUS   0x2b
 
#define DUK_ASC_COMMA   0x2c
 
#define DUK_ASC_MINUS   0x2d
 
#define DUK_ASC_PERIOD   0x2e
 
#define DUK_ASC_SLASH   0x2f
 
#define DUK_ASC_0   0x30
 
#define DUK_ASC_1   0x31
 
#define DUK_ASC_2   0x32
 
#define DUK_ASC_3   0x33
 
#define DUK_ASC_4   0x34
 
#define DUK_ASC_5   0x35
 
#define DUK_ASC_6   0x36
 
#define DUK_ASC_7   0x37
 
#define DUK_ASC_8   0x38
 
#define DUK_ASC_9   0x39
 
#define DUK_ASC_COLON   0x3a
 
#define DUK_ASC_SEMICOLON   0x3b
 
#define DUK_ASC_LANGLE   0x3c
 
#define DUK_ASC_EQUALS   0x3d
 
#define DUK_ASC_RANGLE   0x3e
 
#define DUK_ASC_QUESTION   0x3f
 
#define DUK_ASC_ATSIGN   0x40
 
#define DUK_ASC_UC_A   0x41
 
#define DUK_ASC_UC_B   0x42
 
#define DUK_ASC_UC_C   0x43
 
#define DUK_ASC_UC_D   0x44
 
#define DUK_ASC_UC_E   0x45
 
#define DUK_ASC_UC_F   0x46
 
#define DUK_ASC_UC_G   0x47
 
#define DUK_ASC_UC_H   0x48
 
#define DUK_ASC_UC_I   0x49
 
#define DUK_ASC_UC_J   0x4a
 
#define DUK_ASC_UC_K   0x4b
 
#define DUK_ASC_UC_L   0x4c
 
#define DUK_ASC_UC_M   0x4d
 
#define DUK_ASC_UC_N   0x4e
 
#define DUK_ASC_UC_O   0x4f
 
#define DUK_ASC_UC_P   0x50
 
#define DUK_ASC_UC_Q   0x51
 
#define DUK_ASC_UC_R   0x52
 
#define DUK_ASC_UC_S   0x53
 
#define DUK_ASC_UC_T   0x54
 
#define DUK_ASC_UC_U   0x55
 
#define DUK_ASC_UC_V   0x56
 
#define DUK_ASC_UC_W   0x57
 
#define DUK_ASC_UC_X   0x58
 
#define DUK_ASC_UC_Y   0x59
 
#define DUK_ASC_UC_Z   0x5a
 
#define DUK_ASC_LBRACKET   0x5b
 
#define DUK_ASC_BACKSLASH   0x5c
 
#define DUK_ASC_RBRACKET   0x5d
 
#define DUK_ASC_CARET   0x5e
 
#define DUK_ASC_UNDERSCORE   0x5f
 
#define DUK_ASC_GRAVE   0x60
 
#define DUK_ASC_LC_A   0x61
 
#define DUK_ASC_LC_B   0x62
 
#define DUK_ASC_LC_C   0x63
 
#define DUK_ASC_LC_D   0x64
 
#define DUK_ASC_LC_E   0x65
 
#define DUK_ASC_LC_F   0x66
 
#define DUK_ASC_LC_G   0x67
 
#define DUK_ASC_LC_H   0x68
 
#define DUK_ASC_LC_I   0x69
 
#define DUK_ASC_LC_J   0x6a
 
#define DUK_ASC_LC_K   0x6b
 
#define DUK_ASC_LC_L   0x6c
 
#define DUK_ASC_LC_M   0x6d
 
#define DUK_ASC_LC_N   0x6e
 
#define DUK_ASC_LC_O   0x6f
 
#define DUK_ASC_LC_P   0x70
 
#define DUK_ASC_LC_Q   0x71
 
#define DUK_ASC_LC_R   0x72
 
#define DUK_ASC_LC_S   0x73
 
#define DUK_ASC_LC_T   0x74
 
#define DUK_ASC_LC_U   0x75
 
#define DUK_ASC_LC_V   0x76
 
#define DUK_ASC_LC_W   0x77
 
#define DUK_ASC_LC_X   0x78
 
#define DUK_ASC_LC_Y   0x79
 
#define DUK_ASC_LC_Z   0x7a
 
#define DUK_ASC_LCURLY   0x7b
 
#define DUK_ASC_PIPE   0x7c
 
#define DUK_ASC_RCURLY   0x7d
 
#define DUK_ASC_TILDE   0x7e
 
#define DUK_ASC_DEL   0x7f
 

Functions

DUK_INTERNAL_DECL duk_small_int_t duk_unicode_get_xutf8_length (duk_ucodepoint_t cp)
 
DUK_INTERNAL_DECL duk_small_int_t duk_unicode_encode_xutf8 (duk_ucodepoint_t cp, duk_uint8_t *out)
 
DUK_INTERNAL_DECL duk_small_int_t duk_unicode_encode_cesu8 (duk_ucodepoint_t cp, duk_uint8_t *out)
 
DUK_INTERNAL_DECL duk_small_int_t duk_unicode_decode_xutf8 (duk_hthread *thr, const duk_uint8_t **ptr, const duk_uint8_t *ptr_start, const duk_uint8_t *ptr_end, duk_ucodepoint_t *out_cp)
 
DUK_INTERNAL_DECL duk_ucodepoint_t duk_unicode_decode_xutf8_checked (duk_hthread *thr, const duk_uint8_t **ptr, const duk_uint8_t *ptr_start, const duk_uint8_t *ptr_end)
 
DUK_INTERNAL_DECL duk_size_t duk_unicode_unvalidated_utf8_length (const duk_uint8_t *data, duk_size_t blen)
 
DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_whitespace (duk_codepoint_t cp)
 
DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_line_terminator (duk_codepoint_t cp)
 
DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_identifier_start (duk_codepoint_t cp)
 
DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_identifier_part (duk_codepoint_t cp)
 
DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_letter (duk_codepoint_t cp)
 
DUK_INTERNAL_DECL void duk_unicode_case_convert_string (duk_hthread *thr, duk_bool_t uppercase)
 
DUK_INTERNAL_DECL duk_codepoint_t duk_unicode_re_canonicalize_char (duk_hthread *thr, duk_codepoint_t cp)
 
DUK_INTERNAL_DECL duk_small_int_t duk_unicode_re_is_wordchar (duk_codepoint_t cp)
 

Variables

const duk_uint8_t duk_unicode_ids_noabmp [611]
 
const duk_uint8_t duk_unicode_ids_m_let_noabmp [24]
 
const duk_uint8_t duk_unicode_idp_m_ids_noabmp [348]
 
const duk_uint8_t duk_unicode_caseconv_uc [1288]
 
const duk_uint8_t duk_unicode_caseconv_lc [616]
 
DUK_INTERNAL_DECL const duk_uint8_t duk_unicode_xutf8_markers [7]
 
DUK_INTERNAL_DECL const duk_uint16_t duk_unicode_re_ranges_digit [2]
 
DUK_INTERNAL_DECL const duk_uint16_t duk_unicode_re_ranges_white [22]
 
DUK_INTERNAL_DECL const duk_uint16_t duk_unicode_re_ranges_wordchar [8]
 
DUK_INTERNAL_DECL const duk_uint16_t duk_unicode_re_ranges_not_digit [4]
 
DUK_INTERNAL_DECL const duk_uint16_t duk_unicode_re_ranges_not_white [24]
 
DUK_INTERNAL_DECL const duk_uint16_t duk_unicode_re_ranges_not_wordchar [10]
 
DUK_INTERNAL_DECL const duk_int8_t duk_is_idchar_tab [128]
 

Macro Definition Documentation

◆ DUK_ASC_0

#define DUK_ASC_0   0x30

Definition at line 87 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_1

#define DUK_ASC_1   0x31

Definition at line 88 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_2

#define DUK_ASC_2   0x32

Definition at line 89 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_3

#define DUK_ASC_3   0x33

Definition at line 90 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_4

#define DUK_ASC_4   0x34

Definition at line 91 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_5

#define DUK_ASC_5   0x35

Definition at line 92 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_6

#define DUK_ASC_6   0x36

Definition at line 93 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_7

#define DUK_ASC_7   0x37

Definition at line 94 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_8

#define DUK_ASC_8   0x38

Definition at line 95 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_9

#define DUK_ASC_9   0x39

Definition at line 96 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_ACK

#define DUK_ASC_ACK   0x06

Definition at line 45 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_AMP

#define DUK_ASC_AMP   0x26

Definition at line 77 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_ATSIGN

#define DUK_ASC_ATSIGN   0x40

Definition at line 103 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_BACKSLASH

#define DUK_ASC_BACKSLASH   0x5c

Definition at line 131 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_BEL

#define DUK_ASC_BEL   0x07

Definition at line 46 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_BS

#define DUK_ASC_BS   0x08

Definition at line 47 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_CAN

#define DUK_ASC_CAN   0x18

Definition at line 63 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_CARET

#define DUK_ASC_CARET   0x5e

Definition at line 133 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_COLON

#define DUK_ASC_COLON   0x3a

Definition at line 97 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_COMMA

#define DUK_ASC_COMMA   0x2c

Definition at line 83 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_CR

#define DUK_ASC_CR   0x0d

Definition at line 52 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_DC1

#define DUK_ASC_DC1   0x11

Definition at line 56 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_DC2

#define DUK_ASC_DC2   0x12

Definition at line 57 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_DC3

#define DUK_ASC_DC3   0x13

Definition at line 58 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_DC4

#define DUK_ASC_DC4   0x14

Definition at line 59 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_DEL

#define DUK_ASC_DEL   0x7f

Definition at line 166 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_DLE

#define DUK_ASC_DLE   0x10

Definition at line 55 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_DOLLAR

#define DUK_ASC_DOLLAR   0x24

Definition at line 75 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_DOUBLEQUOTE

#define DUK_ASC_DOUBLEQUOTE   0x22

Definition at line 73 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_EM

#define DUK_ASC_EM   0x19

Definition at line 64 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_ENQ

#define DUK_ASC_ENQ   0x05

Definition at line 44 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_EOT

#define DUK_ASC_EOT   0x04

Definition at line 43 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_EQUALS

#define DUK_ASC_EQUALS   0x3d

Definition at line 100 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_ESC

#define DUK_ASC_ESC   0x1b

Definition at line 66 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_ETB

#define DUK_ASC_ETB   0x17

Definition at line 62 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_ETX

#define DUK_ASC_ETX   0x03

Definition at line 42 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_EXCLAMATION

#define DUK_ASC_EXCLAMATION   0x21

Definition at line 72 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_FF

#define DUK_ASC_FF   0x0c

Definition at line 51 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_FS

#define DUK_ASC_FS   0x1c

Definition at line 67 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_GRAVE

#define DUK_ASC_GRAVE   0x60

Definition at line 135 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_GS

#define DUK_ASC_GS   0x1d

Definition at line 68 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_HASH

#define DUK_ASC_HASH   0x23

Definition at line 74 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_HT

#define DUK_ASC_HT   0x09

Definition at line 48 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LANGLE

#define DUK_ASC_LANGLE   0x3c

Definition at line 99 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LBRACKET

#define DUK_ASC_LBRACKET   0x5b

Definition at line 130 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_A

#define DUK_ASC_LC_A   0x61

Definition at line 136 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_B

#define DUK_ASC_LC_B   0x62

Definition at line 137 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_C

#define DUK_ASC_LC_C   0x63

Definition at line 138 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_D

#define DUK_ASC_LC_D   0x64

Definition at line 139 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_E

#define DUK_ASC_LC_E   0x65

Definition at line 140 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_F

#define DUK_ASC_LC_F   0x66

Definition at line 141 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_G

#define DUK_ASC_LC_G   0x67

Definition at line 142 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_H

#define DUK_ASC_LC_H   0x68

Definition at line 143 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_I

#define DUK_ASC_LC_I   0x69

Definition at line 144 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_J

#define DUK_ASC_LC_J   0x6a

Definition at line 145 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_K

#define DUK_ASC_LC_K   0x6b

Definition at line 146 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_L

#define DUK_ASC_LC_L   0x6c

Definition at line 147 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_M

#define DUK_ASC_LC_M   0x6d

Definition at line 148 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_N

#define DUK_ASC_LC_N   0x6e

Definition at line 149 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_O

#define DUK_ASC_LC_O   0x6f

Definition at line 150 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_P

#define DUK_ASC_LC_P   0x70

Definition at line 151 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_Q

#define DUK_ASC_LC_Q   0x71

Definition at line 152 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_R

#define DUK_ASC_LC_R   0x72

Definition at line 153 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_S

#define DUK_ASC_LC_S   0x73

Definition at line 154 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_T

#define DUK_ASC_LC_T   0x74

Definition at line 155 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_U

#define DUK_ASC_LC_U   0x75

Definition at line 156 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_V

#define DUK_ASC_LC_V   0x76

Definition at line 157 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_W

#define DUK_ASC_LC_W   0x77

Definition at line 158 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_X

#define DUK_ASC_LC_X   0x78

Definition at line 159 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_Y

#define DUK_ASC_LC_Y   0x79

Definition at line 160 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LC_Z

#define DUK_ASC_LC_Z   0x7a

Definition at line 161 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LCURLY

#define DUK_ASC_LCURLY   0x7b

Definition at line 162 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LF

#define DUK_ASC_LF   0x0a

Definition at line 49 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_LPAREN

#define DUK_ASC_LPAREN   0x28

Definition at line 79 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_MINUS

#define DUK_ASC_MINUS   0x2d

Definition at line 84 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_NAK

#define DUK_ASC_NAK   0x15

Definition at line 60 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_NUL

#define DUK_ASC_NUL   0x00

Definition at line 39 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_PERCENT

#define DUK_ASC_PERCENT   0x25

Definition at line 76 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_PERIOD

#define DUK_ASC_PERIOD   0x2e

Definition at line 85 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_PIPE

#define DUK_ASC_PIPE   0x7c

Definition at line 163 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_PLUS

#define DUK_ASC_PLUS   0x2b

Definition at line 82 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_QUESTION

#define DUK_ASC_QUESTION   0x3f

Definition at line 102 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_RANGLE

#define DUK_ASC_RANGLE   0x3e

Definition at line 101 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_RBRACKET

#define DUK_ASC_RBRACKET   0x5d

Definition at line 132 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_RCURLY

#define DUK_ASC_RCURLY   0x7d

Definition at line 164 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_RPAREN

#define DUK_ASC_RPAREN   0x29

Definition at line 80 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_RS

#define DUK_ASC_RS   0x1e

Definition at line 69 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_SEMICOLON

#define DUK_ASC_SEMICOLON   0x3b

Definition at line 98 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_SI

#define DUK_ASC_SI   0x0f

Definition at line 54 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_SINGLEQUOTE

#define DUK_ASC_SINGLEQUOTE   0x27

Definition at line 78 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_SLASH

#define DUK_ASC_SLASH   0x2f

Definition at line 86 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_SO

#define DUK_ASC_SO   0x0e

Definition at line 53 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_SOH

#define DUK_ASC_SOH   0x01

Definition at line 40 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_SPACE

#define DUK_ASC_SPACE   0x20

Definition at line 71 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_STAR

#define DUK_ASC_STAR   0x2a

Definition at line 81 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_STX

#define DUK_ASC_STX   0x02

Definition at line 41 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_SUB

#define DUK_ASC_SUB   0x1a

Definition at line 65 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_SYN

#define DUK_ASC_SYN   0x16

Definition at line 61 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_TILDE

#define DUK_ASC_TILDE   0x7e

Definition at line 165 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_A

#define DUK_ASC_UC_A   0x41

Definition at line 104 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_B

#define DUK_ASC_UC_B   0x42

Definition at line 105 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_C

#define DUK_ASC_UC_C   0x43

Definition at line 106 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_D

#define DUK_ASC_UC_D   0x44

Definition at line 107 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_E

#define DUK_ASC_UC_E   0x45

Definition at line 108 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_F

#define DUK_ASC_UC_F   0x46

Definition at line 109 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_G

#define DUK_ASC_UC_G   0x47

Definition at line 110 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_H

#define DUK_ASC_UC_H   0x48

Definition at line 111 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_I

#define DUK_ASC_UC_I   0x49

Definition at line 112 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_J

#define DUK_ASC_UC_J   0x4a

Definition at line 113 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_K

#define DUK_ASC_UC_K   0x4b

Definition at line 114 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_L

#define DUK_ASC_UC_L   0x4c

Definition at line 115 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_M

#define DUK_ASC_UC_M   0x4d

Definition at line 116 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_N

#define DUK_ASC_UC_N   0x4e

Definition at line 117 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_O

#define DUK_ASC_UC_O   0x4f

Definition at line 118 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_P

#define DUK_ASC_UC_P   0x50

Definition at line 119 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_Q

#define DUK_ASC_UC_Q   0x51

Definition at line 120 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_R

#define DUK_ASC_UC_R   0x52

Definition at line 121 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_S

#define DUK_ASC_UC_S   0x53

Definition at line 122 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_T

#define DUK_ASC_UC_T   0x54

Definition at line 123 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_U

#define DUK_ASC_UC_U   0x55

Definition at line 124 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_V

#define DUK_ASC_UC_V   0x56

Definition at line 125 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_W

#define DUK_ASC_UC_W   0x57

Definition at line 126 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_X

#define DUK_ASC_UC_X   0x58

Definition at line 127 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_Y

#define DUK_ASC_UC_Y   0x59

Definition at line 128 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UC_Z

#define DUK_ASC_UC_Z   0x5a

Definition at line 129 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_UNDERSCORE

#define DUK_ASC_UNDERSCORE   0x5f

Definition at line 134 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_US

#define DUK_ASC_US   0x1f

Definition at line 70 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_ASC_VT

#define DUK_ASC_VT   0x0b

Definition at line 50 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_UNICODE_CP_REPLACEMENT_CHARACTER

#define DUK_UNICODE_CP_REPLACEMENT_CHARACTER   0xfffdL /* http://en.wikipedia.org/wiki/Replacement_character#Replacement_character */

Definition at line 26 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_UNICODE_CP_ZWJ

#define DUK_UNICODE_CP_ZWJ   0x200dL /* zero-width joiner */

Definition at line 25 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_UNICODE_CP_ZWNJ

#define DUK_UNICODE_CP_ZWNJ   0x200cL /* zero-width non-joiner */

Definition at line 24 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_UNICODE_MAX_CESU8_BMP_LENGTH

#define DUK_UNICODE_MAX_CESU8_BMP_LENGTH   3 /* all codepoints up to U+FFFF */

Definition at line 15 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_UNICODE_MAX_CESU8_LENGTH

#define DUK_UNICODE_MAX_CESU8_LENGTH   6 /* all codepoints up to U+10FFFF */

Definition at line 14 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_UNICODE_MAX_XUTF8_BMP_LENGTH

#define DUK_UNICODE_MAX_XUTF8_BMP_LENGTH   3 /* all codepoints up to U+FFFF */

Definition at line 13 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ DUK_UNICODE_MAX_XUTF8_LENGTH

#define DUK_UNICODE_MAX_XUTF8_LENGTH   7 /* up to 36 bit codepoints */

Definition at line 12 of file duktape-1.5.2/src-separate/duk_unicode.h.

Function Documentation

◆ duk_unicode_case_convert_string()

DUK_INTERNAL_DECL void duk_unicode_case_convert_string ( duk_hthread * thr,
duk_bool_t uppercase )

Definition at line 10889 of file duktape-1.5.2/src-noline/duktape.c.

10889 :
10890 if (bw != NULL) {
10891 DUK_BW_WRITE_RAW_XUTF8(thr, bw, (duk_ucodepoint_t) cp);
10892 }
10893 return cp;
10894
10895 /* unused now, not needed until Turkish/Azeri */
10896#if 0
10897 nochar:
10898 return -1;
10899#endif
10900}
10901
10902/*
10903 * Replace valstack top with case converted version.
10904 */
10905
10906DUK_INTERNAL void duk_unicode_case_convert_string(duk_hthread *thr, duk_small_int_t uppercase) {
10907 duk_context *ctx = (duk_context *) thr;
10908 duk_hstring *h_input;
10909 duk_bufwriter_ctx bw_alloc;
10910 duk_bufwriter_ctx *bw;
10911 const duk_uint8_t *p, *p_start, *p_end;
10912 duk_codepoint_t prev, curr, next;
10913
10914 h_input = duk_require_hstring(ctx, -1);
10915 DUK_ASSERT(h_input != NULL);
10916
10917 bw = &bw_alloc;
10918 DUK_BW_INIT_PUSHBUF(thr, bw, DUK_HSTRING_GET_BYTELEN(h_input));
10919
10920 /* [ ... input buffer ] */
10921
10922 p_start = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input);
10923 p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input);
10924 p = p_start;
10925
10926 prev = -1; DUK_UNREF(prev);
10927 curr = -1;
10928 next = -1;
10929 for (;;) {
10930 prev = curr;
10931 curr = next;
10932 next = -1;
10933 if (p < p_end) {
10934 next = (int) duk_unicode_decode_xutf8_checked(thr, &p, p_start, p_end);
10935 } else {
10936 /* end of input and last char has been processed */
10937 if (curr < 0) {
10938 break;
10939 }
10940 }
10941
10942 /* on first round, skip */
10943 if (curr >= 0) {
10944 /* XXX: could add a fast path to process chunks of input codepoints,
10945 * but relative benefit would be quite small.
10946 */
duk_small_int_t
int duk_small_int_t
Definition duktape-1.5.2/src-noline/duk_config.h:1807
DUK_INTERNAL
#define DUK_INTERNAL
Definition duktape-1.5.2/src-noline/duk_config.h:2548
duk_ucodepoint_t
duk_uint_t duk_ucodepoint_t
Definition duktape-1.5.2/src-noline/duk_config.h:1869
duk_codepoint_t
duk_int_t duk_codepoint_t
Definition duktape-1.5.2/src-noline/duk_config.h:1868
DUK_UNREF
#define DUK_UNREF(x)
Definition duktape-1.5.2/src-noline/duk_config.h:2494
DUK_HSTRING_GET_DATA
#define DUK_HSTRING_GET_DATA(x)
Definition duktape-1.5.2/src-noline/duktape.c:4522
DUK_HSTRING_GET_BYTELEN
#define DUK_HSTRING_GET_BYTELEN(x)
Definition duktape-1.5.2/src-noline/duktape.c:4505
DUK_BW_INIT_PUSHBUF
#define DUK_BW_INIT_PUSHBUF(thr, bw_ctx, sz)
Definition duktape-1.5.2/src-noline/duktape.c:1852
DUK_BW_WRITE_RAW_XUTF8
#define DUK_BW_WRITE_RAW_XUTF8(thr, bw_ctx, cp)
Definition duktape-1.5.2/src-noline/duktape.c:2006
duk_require_hstring
DUK_INTERNAL_DECL duk_hstring * duk_require_hstring(duk_context *ctx, duk_idx_t index)
Definition duktape-1.5.2/src-noline/duktape.c:16292
duk_unicode_case_convert_string
DUK_INTERNAL_DECL void duk_unicode_case_convert_string(duk_hthread *thr, duk_bool_t uppercase)
Definition duktape-1.5.2/src-noline/duktape.c:10889
duk_unicode_decode_xutf8_checked
DUK_INTERNAL_DECL duk_ucodepoint_t duk_unicode_decode_xutf8_checked(duk_hthread *thr, const duk_uint8_t **ptr, const duk_uint8_t *ptr_start, const duk_uint8_t *ptr_end)
Definition duktape-1.5.2/src-noline/duktape.c:10153
NULL
#define NULL
Definition gmacros.h:924
next
#define next(ls)
Definition lua-5.1.5/src/llex.c:28
duk_bufwriter_ctx
Definition duktape-1.5.2/src-noline/duktape.c:1840
duk_hstring
Definition duktape-1.5.2/src-noline/duktape.c:4546
duk_hthread
Definition duktape-1.5.2/src-noline/duktape.c:6190

◆ duk_unicode_decode_xutf8()

DUK_INTERNAL_DECL duk_small_int_t duk_unicode_decode_xutf8 ( duk_hthread * thr,
const duk_uint8_t ** ptr,
const duk_uint8_t * ptr_start,
const duk_uint8_t * ptr_end,
duk_ucodepoint_t * out_cp )

Definition at line 10069 of file duktape-1.5.2/src-noline/duktape.c.

10086 {
10087 const duk_uint8_t *p;
10088 duk_uint32_t res;
10089 duk_uint_fast8_t ch;
10090 duk_small_int_t n;
10091
10092 DUK_UNREF(thr);
10093
10094 p = *ptr;
10095 if (p < ptr_start || p >= ptr_end) {
10096 goto fail;
10097 }
10098
10099 /*
10100 * UTF-8 decoder which accepts longer than standard byte sequences.
10101 * This allows full 32-bit code points to be used.
10102 */
10103
10104 ch = (duk_uint_fast8_t) (*p++);
10105 if (ch < 0x80) {
10106 /* 0xxx xxxx [7 bits] */
10107 res = (duk_uint32_t) (ch & 0x7f);
10108 n = 0;
10109 } else if (ch < 0xc0) {
10110 /* 10xx xxxx -> invalid */
10111 goto fail;
10112 } else if (ch < 0xe0) {
10113 /* 110x xxxx 10xx xxxx [11 bits] */
10114 res = (duk_uint32_t) (ch & 0x1f);
10115 n = 1;
10116 } else if (ch < 0xf0) {
10117 /* 1110 xxxx 10xx xxxx 10xx xxxx [16 bits] */
10118 res = (duk_uint32_t) (ch & 0x0f);
10119 n = 2;
10120 } else if (ch < 0xf8) {
10121 /* 1111 0xxx 10xx xxxx 10xx xxxx 10xx xxxx [21 bits] */
10122 res = (duk_uint32_t) (ch & 0x07);
10123 n = 3;
10124 } else if (ch < 0xfc) {
10125 /* 1111 10xx 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx [26 bits] */
10126 res = (duk_uint32_t) (ch & 0x03);
10127 n = 4;
10128 } else if (ch < 0xfe) {
10129 /* 1111 110x 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx [31 bits] */
10130 res = (duk_uint32_t) (ch & 0x01);
10131 n = 5;
10132 } else if (ch < 0xff) {
10133 /* 1111 1110 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx [36 bits] */
10134 res = (duk_uint32_t) (0);
10135 n = 6;
10136 } else {
10137 /* 8-byte format could be:
10138 * 1111 1111 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx 10xx xxxx [41 bits]
10139 *
10140 * However, this format would not have a zero bit following the
10141 * leading one bits and would not allow 0xFF to be used as an
10142 * "invalid xutf-8" marker for internal keys. Further, 8-byte
10143 * encodings (up to 41 bit code points) are not currently needed.
10144 */
10145 goto fail;
10146 }
10147
10148 DUK_ASSERT(p >= ptr_start); /* verified at beginning */
10149 if (p + n > ptr_end) {
10150 /* check pointer at end */
duk_uint_fast8_t
duk_uint8_t duk_uint_fast8_t
Definition duktape-1.5.2/src-noline/duk_config.h:1627

◆ duk_unicode_decode_xutf8_checked()

DUK_INTERNAL_DECL duk_ucodepoint_t duk_unicode_decode_xutf8_checked ( duk_hthread * thr,
const duk_uint8_t ** ptr,
const duk_uint8_t * ptr_start,
const duk_uint8_t * ptr_end )

Definition at line 10153 of file duktape-1.5.2/src-noline/duktape.c.

10154 {
10155 DUK_ASSERT(p >= ptr_start && p < ptr_end);
10156 res = res << 6;
10157 res += (duk_uint32_t) ((*p++) & 0x3f);
10158 n--;
10159 }
10160
10161 *ptr = p;
10162 *out_cp = res;

◆ duk_unicode_encode_cesu8()

DUK_INTERNAL_DECL duk_small_int_t duk_unicode_encode_cesu8 ( duk_ucodepoint_t cp,
duk_uint8_t * out )

Definition at line 10009 of file duktape-1.5.2/src-noline/duktape.c.

10010 {
10011 /* Note: masking of 'x' is not necessary because of
10012 * range check and shifting -> no bits overlapping
10013 * the marker should be set.
10014 */
10015 out[0] = (duk_uint8_t) (marker + x);
10016 }
10017 } while (i > 0);
10018
10019 return len;
10020}
10021
10022/* Encode to CESU-8; 'out' must have space for at least
10023 * DUK_UNICODE_MAX_CESU8_LENGTH bytes; codepoints above U+10FFFF
10024 * will encode to garbage but won't overwrite the output buffer.
10025 */
10026DUK_INTERNAL duk_small_int_t duk_unicode_encode_cesu8(duk_ucodepoint_t cp, duk_uint8_t *out) {
10027 duk_uint_fast32_t x = (duk_uint_fast32_t) cp;
10028 duk_small_int_t len;
10029
10030 if (x < 0x80UL) {
10031 out[0] = (duk_uint8_t) x;
10032 len = 1;
10033 } else if (x < 0x800UL) {
10034 out[0] = (duk_uint8_t) (0xc0 + ((x >> 6) & 0x1f));
10035 out[1] = (duk_uint8_t) (0x80 + (x & 0x3f));
10036 len = 2;
10037 } else if (x < 0x10000UL) {
10038 /* surrogate pairs get encoded here */
10039 out[0] = (duk_uint8_t) (0xe0 + ((x >> 12) & 0x0f));
10040 out[1] = (duk_uint8_t) (0x80 + ((x >> 6) & 0x3f));
10041 out[2] = (duk_uint8_t) (0x80 + (x & 0x3f));
10042 len = 3;
10043 } else {
10044 /*
10045 * Unicode codepoints above U+FFFF are encoded as surrogate
10046 * pairs here. This ensures that all CESU-8 codepoints are
10047 * 16-bit values as expected in Ecmascript. The surrogate
10048 * pairs always get a 3-byte encoding (each) in CESU-8.
10049 * See: http://en.wikipedia.org/wiki/Surrogate_pair
10050 *
10051 * 20-bit codepoint, 10 bits (A and B) per surrogate pair:
10052 *
10053 * x = 0b00000000 0000AAAA AAAAAABB BBBBBBBB
10054 * sp1 = 0b110110AA AAAAAAAA (0xd800 + ((x >> 10) & 0x3ff))
10055 * sp2 = 0b110111BB BBBBBBBB (0xdc00 + (x & 0x3ff))
10056 *
10057 * Encoded into CESU-8:
10058 *
10059 * sp1 -> 0b11101101 (0xe0 + ((sp1 >> 12) & 0x0f))
10060 * -> 0b1010AAAA (0x80 + ((sp1 >> 6) & 0x3f))
10061 * -> 0b10AAAAAA (0x80 + (sp1 & 0x3f))
10062 * sp2 -> 0b11101101 (0xe0 + ((sp2 >> 12) & 0x0f))
10063 * -> 0b1011BBBB (0x80 + ((sp2 >> 6) & 0x3f))
10064 * -> 0b10BBBBBB (0x80 + (sp2 & 0x3f))
10065 *
10066 * Note that 0x10000 must be subtracted first. The code below
duk_uint_fast32_t
duk_uint32_t duk_uint_fast32_t
Definition duktape-1.5.2/src-noline/duk_config.h:1631
duk_unicode_encode_cesu8
DUK_INTERNAL_DECL duk_small_int_t duk_unicode_encode_cesu8(duk_ucodepoint_t cp, duk_uint8_t *out)
Definition duktape-1.5.2/src-noline/duktape.c:10009

◆ duk_unicode_encode_xutf8()

DUK_INTERNAL_DECL duk_small_int_t duk_unicode_encode_xutf8 ( duk_ucodepoint_t cp,
duk_uint8_t * out )

Definition at line 9975 of file duktape-1.5.2/src-noline/duktape.c.

9984 {
9985 0x00, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe
9986};
9987
9988/* Encode to extended UTF-8; 'out' must have space for at least
9989 * DUK_UNICODE_MAX_XUTF8_LENGTH bytes. Allows encoding of any
9990 * 32-bit (unsigned) codepoint.
9991 */
9992DUK_INTERNAL duk_small_int_t duk_unicode_encode_xutf8(duk_ucodepoint_t cp, duk_uint8_t *out) {
9993 duk_uint_fast32_t x = (duk_uint_fast32_t) cp;
9994 duk_small_int_t len;
9995 duk_uint8_t marker;
9996 duk_small_int_t i;
9997
9998 len = duk_unicode_get_xutf8_length(cp);
9999 DUK_ASSERT(len > 0);
10000
10001 marker = duk_unicode_xutf8_markers[len - 1]; /* 64-bit OK because always >= 0 */
10002
10003 i = len;
duk_unicode_encode_xutf8
DUK_INTERNAL_DECL duk_small_int_t duk_unicode_encode_xutf8(duk_ucodepoint_t cp, duk_uint8_t *out)
Definition duktape-1.5.2/src-noline/duktape.c:9975
duk_unicode_get_xutf8_length
DUK_INTERNAL_DECL duk_small_int_t duk_unicode_get_xutf8_length(duk_ucodepoint_t cp)
Definition duktape-1.5.2/src-noline/duktape.c:9919
duk_unicode_xutf8_markers
DUK_INTERNAL const duk_uint8_t duk_unicode_xutf8_markers[7]
Definition duktape-1.5.2/src-noline/duktape.c:9967

◆ duk_unicode_get_xutf8_length()

DUK_INTERNAL_DECL duk_small_int_t duk_unicode_get_xutf8_length ( duk_ucodepoint_t cp)

Definition at line 9919 of file duktape-1.5.2/src-noline/duktape.c.

9919 : IdentifierPart only
9920 */
9921 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x00...0x0f */
9922 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10...0x1f */
9923 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20...0x2f */
9924 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, /* 0x30...0x3f */
9925 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x40...0x4f */
9926 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, /* 0x50...0x5f */
9927 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x60...0x6f */
9928 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 /* 0x70...0x7f */
9929};
9930#endif
9931
9932/*
9933 * XUTF-8 and CESU-8 encoding/decoding
9934 */
9935
9936DUK_INTERNAL duk_small_int_t duk_unicode_get_xutf8_length(duk_ucodepoint_t cp) {
9937 duk_uint_fast32_t x = (duk_uint_fast32_t) cp;
9938 if (x < 0x80UL) {
9939 /* 7 bits */
9940 return 1;
9941 } else if (x < 0x800UL) {
9942 /* 11 bits */
9943 return 2;

◆ duk_unicode_is_identifier_part()

DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_identifier_part ( duk_codepoint_t cp)

Definition at line 10522 of file duktape-1.5.2/src-noline/duktape.c.

10522 {
10523 return 1;
10524 }
10525 return 0;
10526 } else {
10527 /* without explicit non-BMP support, assume non-BMP characters
10528 * are always accepted as identifier characters.
10529 */
10530 return 1;
10531 }
10532#endif
10533}
10534
10535/*
10536 * "IdentifierPart" production check.
10537 */
10538
10539DUK_INTERNAL duk_small_int_t duk_unicode_is_identifier_part(duk_codepoint_t cp) {
10540 /*
10541 * E5 Section 7.6:
10542 *
10543 * IdentifierPart:
10544 * IdentifierStart
10545 * UnicodeCombiningMark
10546 * UnicodeDigit
10547 * UnicodeConnectorPunctuation
10548 * <ZWNJ> [U+200C]
10549 * <ZWJ> [U+200D]
10550 *
10551 * IdentifierPart production has one multi-character production
10552 * as part of its IdentifierStart alternative. The '\' character
10553 * of an escape sequence is not matched here, see discussion in
10554 * duk_unicode_is_identifier_start().
10555 *
10556 * To match non-ASCII characters (codepoints >= 0x80), a very slow
10557 * linear range-by-range scan is used. The codepoint is first compared
10558 * to the IdentifierStart ranges, and if it doesn't match, then to a
10559 * set consisting of code points in IdentifierPart but not in
10560 * IdentifierStart. This is done to keep the unicode range data small,
10561 * at the expense of speed.
10562 *
10563 * The ASCII fast path consists of:
10564 *
10565 * 0x0030 ... 0x0039 ['0' ... '9', UnicodeDigit]
10566 * 0x0041 ... 0x005a ['A' ... 'Z', IdentifierStart]
10567 * 0x0061 ... 0x007a ['a' ... 'z', IdentifierStart]
10568 * 0x0024 ['$', IdentifierStart]
10569 * 0x005f ['_', IdentifierStart and
10570 * UnicodeConnectorPunctuation]
10571 *
10572 * UnicodeCombiningMark has no code points <= 0x7f.
10573 *
10574 * The matching code reuses the "identifier start" tables, and then
10575 * consults a separate range set for characters in "identifier part"
10576 * but not in "identifier start". These can be extracted with the
10577 * "src/extract_chars.py" script.
10578 *
10579 * UnicodeCombiningMark -> categories Mn, Mc
10580 * UnicodeDigit -> categories Nd
10581 * UnicodeConnectorPunctuation -> categories Pc
10582 */
10583
10584 /* ASCII (and EOF) fast path -- quick accept and reject */
10585 if (cp <= 0x7fL) {
10586#if defined(DUK_USE_IDCHAR_FASTPATH)
10587 return (cp >= 0) && (duk_is_idchar_tab[cp] != 0);
10588#else
10589 if ((cp >= 'a' && cp <= 'z') ||
10590 (cp >= 'A' && cp <= 'Z') ||
10591 (cp >= '0' && cp <= '9') ||
10592 cp == '_' || cp == '$') {
10593 return 1;
10594 }
10595 return 0;
10596#endif
10597 }
10598
10599 /* Non-ASCII slow path (range-by-range linear comparison), very slow */
10600
10601#ifdef DUK_USE_SOURCE_NONBMP
10602 if (duk__uni_range_match(duk_unicode_ids_noa,
10603 sizeof(duk_unicode_ids_noa),
10604 (duk_codepoint_t) cp) ||
10605 duk__uni_range_match(duk_unicode_idp_m_ids_noa,
10606 sizeof(duk_unicode_idp_m_ids_noa),
10607 (duk_codepoint_t) cp)) {
10608 return 1;
10609 }
10610 return 0;
10611#else
10612 if (cp < 0x10000L) {
duk_unicode_is_identifier_part
DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_identifier_part(duk_codepoint_t cp)
Definition duktape-1.5.2/src-noline/duktape.c:10522
duk_unicode_ids_noa
const duk_uint8_t duk_unicode_ids_noa[791]
Definition duktape-1.5.2/src-noline/duktape.c:79867
duk__uni_range_match
DUK_LOCAL duk_small_int_t duk__uni_range_match(const duk_uint8_t *unitab, duk_size_t unilen, duk_codepoint_t cp)
Definition duktape-1.5.2/src-noline/duktape.c:10306
duk_unicode_idp_m_ids_noa
const duk_uint8_t duk_unicode_idp_m_ids_noa[397]
Definition duktape-1.5.2/src-noline/duktape.c:79974
duk_is_idchar_tab
DUK_INTERNAL const duk_int8_t duk_is_idchar_tab[128]
Definition duktape-1.5.2/src-noline/duktape.c:9899

◆ duk_unicode_is_identifier_start()

DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_identifier_start ( duk_codepoint_t cp)

Definition at line 10443 of file duktape-1.5.2/src-noline/duktape.c.

10449 {
10450 return 1;
10451 }
10452
10453 return 0;
10454}
10455
10456/*
10457 * "IdentifierStart" production check.
10458 */
10459
10460DUK_INTERNAL duk_small_int_t duk_unicode_is_identifier_start(duk_codepoint_t cp) {
10461 /*
10462 * E5 Section 7.6:
10463 *
10464 * IdentifierStart:
10465 * UnicodeLetter
10466 * $
10467 * _
10468 * \ UnicodeEscapeSequence
10469 *
10470 * IdentifierStart production has one multi-character production:
10471 *
10472 * \ UnicodeEscapeSequence
10473 *
10474 * The '\' character is -not- matched by this function. Rather, the caller
10475 * should decode the escape and then call this function to check whether the
10476 * decoded character is acceptable (see discussion in E5 Section 7.6).
10477 *
10478 * The "UnicodeLetter" alternative of the production allows letters
10479 * from various Unicode categories. These can be extracted with the
10480 * "src/extract_chars.py" script.
10481 *
10482 * Because the result has hundreds of Unicode codepoint ranges, matching
10483 * for any values >= 0x80 are done using a very slow range-by-range scan
10484 * and a packed range format.
10485 *
10486 * The ASCII portion (codepoints 0x00 ... 0x7f) is fast-pathed below because
10487 * it matters the most. The ASCII related ranges of IdentifierStart are:
10488 *
10489 * 0x0041 ... 0x005a ['A' ... 'Z']
10490 * 0x0061 ... 0x007a ['a' ... 'z']
10491 * 0x0024 ['$']
10492 * 0x005f ['_']
10493 */
10494
10495 /* ASCII (and EOF) fast path -- quick accept and reject */
10496 if (cp <= 0x7fL) {
10497#if defined(DUK_USE_IDCHAR_FASTPATH)
10498 return (cp >= 0) && (duk_is_idchar_tab[cp] > 0);
10499#else
10500 if ((cp >= 'a' && cp <= 'z') ||
10501 (cp >= 'A' && cp <= 'Z') ||
10502 cp == '_' || cp == '$') {
10503 return 1;
10504 }
10505 return 0;
10506#endif
10507 }
10508
10509 /* Non-ASCII slow path (range-by-range linear comparison), very slow */
10510
10511#ifdef DUK_USE_SOURCE_NONBMP
10512 if (duk__uni_range_match(duk_unicode_ids_noa,
10513 (duk_size_t) sizeof(duk_unicode_ids_noa),
10514 (duk_codepoint_t) cp)) {
10515 return 1;
10516 }
duk_size_t
size_t duk_size_t
Definition duktape-1.5.2/src-noline/duk_config.h:1770
duk_unicode_is_identifier_start
DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_identifier_start(duk_codepoint_t cp)
Definition duktape-1.5.2/src-noline/duktape.c:10443

◆ duk_unicode_is_letter()

DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_letter ( duk_codepoint_t cp)

Definition at line 10618 of file duktape-1.5.2/src-noline/duktape.c.

10618 {
10619 return 1;
10620 }
10621 return 0;
10622 } else {
10623 /* without explicit non-BMP support, assume non-BMP characters
10624 * are always accepted as identifier characters.
10625 */
10626 return 1;
10627 }
10628#endif
10629}
10630
10631/*
10632 * Unicode letter check.
10633 */
10634
10635DUK_INTERNAL duk_small_int_t duk_unicode_is_letter(duk_codepoint_t cp) {
10636 /*
10637 * Unicode letter is now taken to be the categories:
10638 *
10639 * Lu, Ll, Lt, Lm, Lo
10640 *
10641 * (Not sure if this is exactly correct.)
10642 *
10643 * The ASCII fast path consists of:
10644 *
10645 * 0x0041 ... 0x005a ['A' ... 'Z']
10646 * 0x0061 ... 0x007a ['a' ... 'z']
10647 */
10648
10649 /* ASCII (and EOF) fast path -- quick accept and reject */
10650 if (cp <= 0x7fL) {
10651 if ((cp >= 'a' && cp <= 'z') ||
10652 (cp >= 'A' && cp <= 'Z')) {
10653 return 1;
10654 }
10655 return 0;
10656 }
10657
10658 /* Non-ASCII slow path (range-by-range linear comparison), very slow */
10659
10660#ifdef DUK_USE_SOURCE_NONBMP
10661 if (duk__uni_range_match(duk_unicode_ids_noa,
10662 sizeof(duk_unicode_ids_noa),
10663 (duk_codepoint_t) cp) &&
10664 !duk__uni_range_match(duk_unicode_ids_m_let_noa,
10665 sizeof(duk_unicode_ids_m_let_noa),
10666 (duk_codepoint_t) cp)) {
10667 return 1;
10668 }
10669 return 0;
10670#else
10671 if (cp < 0x10000L) {
duk_unicode_ids_m_let_noa
const duk_uint8_t duk_unicode_ids_m_let_noa[42]
Definition duktape-1.5.2/src-noline/duktape.c:79950
duk_unicode_is_letter
DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_letter(duk_codepoint_t cp)
Definition duktape-1.5.2/src-noline/duktape.c:10618

◆ duk_unicode_is_line_terminator()

DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_line_terminator ( duk_codepoint_t cp)

Definition at line 10423 of file duktape-1.5.2/src-noline/duktape.c.

10424 {
10425 if (lo <= 0x0aU || lo == 0x2fU || lo == 0x5fU) {
10426 return 1;
10427 }
10428 } else if (cp == 0x1680L || cp == 0x180eL || cp == 0x3000L ||
10429 cp == 0xfeffL) {
10430 return 1;
10431 }
10432
10433 return 0;
10434}
10435
10436/*
10437 * "LineTerminator" production check.

◆ duk_unicode_is_whitespace()

DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_whitespace ( duk_codepoint_t cp)

Definition at line 10343 of file duktape-1.5.2/src-noline/duktape.c.

10346 : cp=%06lx range=[0x%06lx,0x%06lx]",
10347 (unsigned long) cp, (unsigned long) r1, (unsigned long) r2));
10348 if (cp >= r1 && cp <= r2) {
10349 return 1;
10350 }
10351 }
10352
10353 return 0;
10354}
10355
10356/*
10357 * "WhiteSpace" production check.
10358 */
10359
10360DUK_INTERNAL duk_small_int_t duk_unicode_is_whitespace(duk_codepoint_t cp) {
10361 /*
10362 * E5 Section 7.2 specifies six characters specifically as
10363 * white space:
10364 *
10365 * 0009;<control>;Cc;0;S;;;;;N;CHARACTER TABULATION;;;;
10366 * 000B;<control>;Cc;0;S;;;;;N;LINE TABULATION;;;;
10367 * 000C;<control>;Cc;0;WS;;;;;N;FORM FEED (FF);;;;
10368 * 0020;SPACE;Zs;0;WS;;;;;N;;;;;
10369 * 00A0;NO-BREAK SPACE;Zs;0;CS;<noBreak> 0020;;;;N;NON-BREAKING SPACE;;;;
10370 * FEFF;ZERO WIDTH NO-BREAK SPACE;Cf;0;BN;;;;;N;BYTE ORDER MARK;;;;
10371 *
10372 * It also specifies any Unicode category 'Zs' characters as white
10373 * space. These can be extracted with the "src/extract_chars.py" script.
10374 * Current result:
10375 *
10376 * RAW OUTPUT:
10377 * ===========
10378 * 0020;SPACE;Zs;0;WS;;;;;N;;;;;
10379 * 00A0;NO-BREAK SPACE;Zs;0;CS;<noBreak> 0020;;;;N;NON-BREAKING SPACE;;;;
10380 * 1680;OGHAM SPACE MARK;Zs;0;WS;;;;;N;;;;;
10381 * 180E;MONGOLIAN VOWEL SEPARATOR;Zs;0;WS;;;;;N;;;;;
10382 * 2000;EN QUAD;Zs;0;WS;2002;;;;N;;;;;
10383 * 2001;EM QUAD;Zs;0;WS;2003;;;;N;;;;;
10384 * 2002;EN SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
10385 * 2003;EM SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
10386 * 2004;THREE-PER-EM SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
10387 * 2005;FOUR-PER-EM SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
10388 * 2006;SIX-PER-EM SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
10389 * 2007;FIGURE SPACE;Zs;0;WS;<noBreak> 0020;;;;N;;;;;
10390 * 2008;PUNCTUATION SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
10391 * 2009;THIN SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
10392 * 200A;HAIR SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
10393 * 202F;NARROW NO-BREAK SPACE;Zs;0;CS;<noBreak> 0020;;;;N;;;;;
10394 * 205F;MEDIUM MATHEMATICAL SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
10395 * 3000;IDEOGRAPHIC SPACE;Zs;0;WS;<wide> 0020;;;;N;;;;;
10396 *
10397 * RANGES:
10398 * =======
10399 * 0x0020
10400 * 0x00a0
10401 * 0x1680
10402 * 0x180e
10403 * 0x2000 ... 0x200a
10404 * 0x202f
10405 * 0x205f
10406 * 0x3000
10407 *
10408 * A manual decoder (below) is probably most compact for this.
10409 */
10410
10411 duk_uint_fast8_t lo;
10412 duk_uint_fast32_t hi;
10413
10414 /* cp == -1 (EOF) never matches and causes return value 0 */
10415
10416 lo = (duk_uint_fast8_t) (cp & 0xff);
10417 hi = (duk_uint_fast32_t) (cp >> 8); /* does not fit into an uchar */

◆ duk_unicode_re_canonicalize_char()

DUK_INTERNAL_DECL duk_codepoint_t duk_unicode_re_canonicalize_char ( duk_hthread * thr,
duk_codepoint_t cp )

Definition at line 10957 of file duktape-1.5.2/src-noline/duktape.c.

10974 {
10975#if defined(DUK_USE_REGEXP_CANON_WORKAROUND)
10976 /* Fast canonicalization lookup at the cost of 128kB footprint. */
10977 DUK_ASSERT(cp >= 0);
10978 DUK_UNREF(thr);
10979 if (DUK_LIKELY(cp < 0x10000L)) {
10980 return (duk_codepoint_t) duk_unicode_re_canon_lookup[cp];
10981 }
10982 return cp;
10983#else /* DUK_USE_REGEXP_CANON_WORKAROUND */
10984 duk_codepoint_t y;
10985
DUK_LIKELY
#define DUK_LIKELY(x)
Definition duktape-1.5.2/src-noline/duk_config.h:2515

◆ duk_unicode_re_is_wordchar()

DUK_INTERNAL_DECL duk_small_int_t duk_unicode_re_is_wordchar ( duk_codepoint_t cp)

Definition at line 10992 of file duktape-1.5.2/src-noline/duktape.c.

10993 {
10994 /* multiple codepoint conversion or non-ASCII mapped to ASCII
10995 * --> leave as is.
10996 */
10997 return cp;
10998 }
10999
11000 return y;
11001#endif /* DUK_USE_REGEXP_CANON_WORKAROUND */
11002}
11003
11004/*

◆ duk_unicode_unvalidated_utf8_length()

DUK_INTERNAL_DECL duk_size_t duk_unicode_unvalidated_utf8_length ( const duk_uint8_t * data,
duk_size_t blen )

Definition at line 10205 of file duktape-1.5.2/src-noline/duktape.c.

10205 {
10206 duk_uint8_t x;
10207 x = *p++;
10208 if (DUK_UNLIKELY(x >= 0x80 && x <= 0xbf)) {
10209 ncont++;
10210 }
10211 }
10212
10213 DUK_ASSERT(ncont <= blen);
10214 clen = blen - ncont;
10215 DUK_ASSERT(clen <= blen);
10216 return clen;
10217}
10218#else /* DUK_USE_PREFER_SIZE */
10219/* This seems like a good overall approach. Fast path for ASCII in 4 byte
10220 * blocks.
10221 */
10222DUK_INTERNAL duk_size_t duk_unicode_unvalidated_utf8_length(const duk_uint8_t *data, duk_size_t blen) {
10223 const duk_uint8_t *p;
10224 const duk_uint8_t *p_end;
10225 const duk_uint32_t *p32_end;
10226 const duk_uint32_t *p32;
10227 duk_size_t ncont;
10228 duk_size_t clen;
10229
10230 ncont = 0; /* number of continuation (non-initial) bytes in [0x80,0xbf] */
10231 p = data;
10232 p_end = data + blen;
10233 if (blen < 16) {
10234 goto skip_fastpath;
10235 }
10236
10237 /* Align 'p' to 4; the input data may have arbitrary alignment.
10238 * End of string check not needed because blen >= 16.
10239 */
10240 while (((duk_size_t) (const void *) p) & 0x03U) {
10241 duk_uint8_t x;
10242 x = *p++;
10243 if (DUK_UNLIKELY(x >= 0x80 && x <= 0xbf)) {
10244 ncont++;
10245 }
10246 }
10247
10248 /* Full, aligned 4-byte reads. */
10249 p32_end = (const duk_uint32_t *) (const void *) (p + ((duk_size_t) (p_end - p) & (duk_size_t) (~0x03)));
10250 p32 = (const duk_uint32_t *) (const void *) p;
10251 while (p32 != (const duk_uint32_t *) p32_end) {
10252 duk_uint32_t x;
10253 x = *p32++;
10254 if (DUK_LIKELY((x & 0x80808080UL) == 0)) {
10255 ; /* ASCII fast path */
10256 } else {
10257 /* Flip highest bit of each byte which changes
10258 * the bit pattern 10xxxxxx into 00xxxxxx which
10259 * allows an easy bit mask test.
10260 */
10261 x ^= 0x80808080UL;
10262 if (DUK_UNLIKELY(!(x & 0xc0000000UL))) {
10263 ncont++;
10264 }
10265 if (DUK_UNLIKELY(!(x & 0x00c00000UL))) {
10266 ncont++;
10267 }
10268 if (DUK_UNLIKELY(!(x & 0x0000c000UL))) {
10269 ncont++;
10270 }
10271 if (DUK_UNLIKELY(!(x & 0x000000c0UL))) {
10272 ncont++;
10273 }
10274 }
10275 }
DUK_UNLIKELY
#define DUK_UNLIKELY(x)
Definition duktape-1.5.2/src-noline/duk_config.h:2518
duk_unicode_unvalidated_utf8_length
DUK_INTERNAL_DECL duk_size_t duk_unicode_unvalidated_utf8_length(const duk_uint8_t *data, duk_size_t blen)
Definition duktape-1.5.2/src-noline/duktape.c:10205

Variable Documentation

◆ duk_is_idchar_tab

DUK_INTERNAL_DECL const duk_int8_t duk_is_idchar_tab[128]

Definition at line 242 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ duk_unicode_caseconv_lc

const duk_uint8_t duk_unicode_caseconv_lc[616]
extern

Definition at line 80095 of file duktape-1.5.2/src-noline/duktape.c.

80112 {
80113144,3,0,3,128,184,6,192,7,192,112,24,144,37,96,64,54,32,81,64,128,226,0,
80114235,65,129,199,1,230,130,3,145,3,177,34,7,70,7,134,36,15,244,13,236,24,32,
801150,34,129,0,65,0,67,4,0,166,32,172,41,132,40,11,64,19,15,132,15,128,8,31,24,
8011631,16,12,62,80,62,64,32,124,224,124,192,64,250,64,250,0,97,246,129,246,1,3,
80117241,3,240,2,7,230,7,228,4,15,212,15,208,8,31,184,31,176,4,63,116,62,224,8,
80118127,32,125,200,32,254,192,254,128,33,253,161,247,96,67,253,3,252,0,135,250,
80119135,222,129,15,252,15,188,2,31,250,31,124,4,66,192,66,224,64,146,216,147,
8012064,209,96,1,97,130,242,199,224,35,240,95,228,63,232,38,161,1,0,1,1,48,2,
80121100,2,102,12,4,228,4,232,64,10,80,10,89,112,23,144,23,160,96,48,64,48,96,
80122128,104,0,104,65,128,217,128,218,2,1,203,1,204,18,3,188,3,190,36,7,200,7,
80123204,16,15,192,15,201,64,34,32,34,49,32,72,192,72,225,64,220,0,220,65,1,236,

◆ duk_unicode_caseconv_uc

const duk_uint8_t duk_unicode_caseconv_uc[1288]
extern

Definition at line 80034 of file duktape-1.5.2/src-noline/duktape.c.

80051 {
80052132,3,128,3,0,184,7,192,6,192,112,35,242,199,224,64,74,192,49,32,128,162,
80053128,108,65,1,189,129,254,131,3,173,3,136,6,7,98,7,34,68,15,12,14,140,72,30,
80054104,28,112,32,67,0,65,4,0,138,0,128,4,1,88,65,76,83,15,128,15,132,8,31,16,
8005531,24,12,62,64,62,80,32,124,192,124,224,64,250,0,250,64,97,246,1,246,129,3,
80056238,3,247,64,135,220,135,242,2,15,187,15,237,2,31,120,31,248,4,62,244,63,
80057212,8,125,240,127,232,16,253,128,253,192,33,253,1,253,128,67,252,3,253,0,
80058136,92,8,88,8,18,104,18,91,26,44,48,44,0,94,90,0,33,64,155,253,7,252,132,
80059212,0,32,32,32,6,0,76,192,76,129,128,157,0,156,136,1,75,1,74,46,2,244,2,
80060242,12,6,12,6,8,16,13,8,13,0,48,27,64,27,48,64,57,192,57,162,0,119,192,119,
80061132,128,252,128,252,20,2,35,2,34,18,4,142,4,140,20,13,196,13,192,16,30,200,
8006230,192,192,70,16,70,2,32,145,96,145,70,193,48,129,48,67,130,104,130,104,44,
8006330,1,30,0,150,61,66,61,64,192,125,68,125,100,33,99,65,99,56,50,200,18,200,
800646,69,157,133,157,96,169,144,105,144,11,211,64,211,64,12,167,35,167,34,15,
8006578,103,78,100,126,157,234,157,228,21,59,253,59,240,90,122,26,122,0,163,128,
80066214,128,214,2,1,197,1,196,6,3,140,3,136,12,7,200,7,196,16,20,0,13,48,32,63,
80067128,63,112,69,142,101,142,64,130,1,136,1,135,4,3,114,3,112,8,26,120,202,
80068120,176,65,1,30,1,29,130,2,105,1,150,5,255,96,22,160,115,128,31,224,47,0,
8006938,32,9,32,47,224,10,96,48,0,72,96,50,64,50,32,50,160,62,192,51,32,51,0,51,
8007064,71,160,51,192,68,0,53,0,52,224,55,224,62,224,59,160,49,192,62,96,62,32,
8007174,5,141,224,74,37,141,160,74,69,142,0,74,96,48,32,74,128,48,192,75,32,49,
80072224,75,96,50,0,76,0,50,96,76,96,50,128,76,180,241,160,77,0,50,224,77,101,
80073140,64,78,37,141,192,78,64,51,160,78,160,51,224,79,165,140,128,81,0,53,192,
8007481,32,72,128,81,128,72,160,82,64,54,224,104,160,115,32,110,224,110,192,117,
80075128,112,192,120,64,116,96,121,128,113,128,122,0,114,64,122,32,115,0,122,
80076160,116,192,122,192,116,0,122,224,121,224,126,0,115,64,126,32,116,32,126,
8007764,127,32,126,160,114,160,153,224,152,3,175,52,239,163,175,165,140,99,211,
8007899,204,3,247,192,115,35,252,163,253,132,41,196,38,68,48,132,48,101,140,37,
80079140,5,140,160,71,69,140,192,71,217,128,55,224,5,48,5,48,20,152,10,240,1,56,
800807,194,0,74,3,12,3,144,192,230,64,194,0,192,64,236,48,58,80,48,128,48,16,88,
80081120,20,212,21,72,122,90,0,72,3,49,30,151,128,21,0,194,7,166,32,5,112,48,
80082161,233,152,1,100,12,40,122,106,0,65,2,190,31,80,128,233,64,196,199,212,
80083176,58,80,49,48,48,1,245,76,14,148,12,76,12,4,125,91,3,165,3,19,3,66,31,
80084128,135,194,0,230,71,224,97,240,144,57,145,248,40,124,40,14,100,126,14,31,
8008511,3,153,31,132,135,195,0,230,71,225,97,240,208,57,145,248,104,124,56,14,
80086100,126,30,31,15,3,153,31,136,135,194,0,230,71,226,97,240,144,57,145,248,
80087168,124,40,14,100,126,46,31,11,3,153,31,140,135,195,0,230,71,227,97,240,
80088208,57,145,248,232,124,56,14,100,126,62,31,15,3,153,31,144,135,202,0,230,
8008971,228,97,242,144,57,145,249,40,124,168,14,100,126,78,31,43,3,153,31,148,
80090135,203,0,230,71,229,97,242,208,57,145,249,104,124,184,14,100,126,94,31,47,
800913,153,31,152,135,202,0,230,71,230,97,242,144,57,145,249,168,124,168,14,100,
80092126,110,31,43,3,153,31,156,135,203,0,230,71,231,97,242,208,57,145,249,232,
80093124,184,14,100,126,126,31,47,3,153,31,160,135,218,0,230,71,232,97,246,144,
8009457,145,250,40,125,168,14,100,126,142,31,107,3,153,31,164,135,219,0,230,71,

◆ duk_unicode_idp_m_ids_noabmp

const duk_uint8_t duk_unicode_idp_m_ids_noabmp[348]
extern

Referenced by duk_unicode_is_identifier_part().

◆ duk_unicode_ids_m_let_noabmp

const duk_uint8_t duk_unicode_ids_m_let_noabmp[24]
extern

Referenced by duk_unicode_is_letter().

◆ duk_unicode_ids_noabmp

const duk_uint8_t duk_unicode_ids_noabmp[611]
extern

Referenced by duk_unicode_is_identifier_part(), duk_unicode_is_identifier_start(), and duk_unicode_is_letter().

◆ duk_unicode_re_ranges_digit

DUK_INTERNAL_DECL const duk_uint16_t duk_unicode_re_ranges_digit[2]

Definition at line 236 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ duk_unicode_re_ranges_not_digit

DUK_INTERNAL_DECL const duk_uint16_t duk_unicode_re_ranges_not_digit[4]

Definition at line 239 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ duk_unicode_re_ranges_not_white

DUK_INTERNAL_DECL const duk_uint16_t duk_unicode_re_ranges_not_white[24]

Definition at line 240 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ duk_unicode_re_ranges_not_wordchar

DUK_INTERNAL_DECL const duk_uint16_t duk_unicode_re_ranges_not_wordchar[10]

Definition at line 241 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ duk_unicode_re_ranges_white

DUK_INTERNAL_DECL const duk_uint16_t duk_unicode_re_ranges_white[22]

Definition at line 237 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ duk_unicode_re_ranges_wordchar

DUK_INTERNAL_DECL const duk_uint16_t duk_unicode_re_ranges_wordchar[8]

Definition at line 238 of file duktape-1.5.2/src-separate/duk_unicode.h.

◆ duk_unicode_xutf8_markers

DUK_INTERNAL_DECL const duk_uint8_t duk_unicode_xutf8_markers[7]

Definition at line 235 of file duktape-1.5.2/src-separate/duk_unicode.h.