2.1 Digits

Digits and other characters used in CJK numbers are defined by the following table. Each character in the table has its value shown in the value column of the same row and belongs to the categories shown in the categories column of the same row. If the value column's content is "-", the character has no value.

There are following categories: CJK digit, CJK zero, CJK non-zero digit, CJK ten, CJK multiple tens, CJK hundred, CJK multiple hundreds, CJK thousand, CJK ten thousand, CJK hundred million, CJK trillion, CJK ten quadrillion, CJK hundred quintillion, CJK septillion, CJK ten octillion, CJK and separator, CJK digit group separator, and CJK decimal separator.

2.2 Parsing CJK numbers

To parse a CJK number string, the implementation MUST run these steps:

1. Let input be a copy of string.
2. If input is the empty string, return null and abort these steps.
3. Set value to the result of applying the rules for parsing a large CJK number.
4. If input is not the empty string, return null and abort these steps.
5. Return value.

These steps returns either a number or null. The null value represents an error.

The rules for parsing a large CJK number are these steps, which share the same input with the steps that invoke these steps:

1. Let value be zero.
2. Let large digits flag be false.
3. If input starts with four or more CJK digits, or one or more CJK digits followed by one or more groups of a CJK digit group separator followed by three CJK digits:
   1. Let digits be the found substring.
   2. Remove them from input.
   3. Remove any CJK digit group separator from digits.
   4. Replace each character in digits by the ASCII digit representing its value.
   5. Set v to the value obtained by interpreting digits as a decimal number.
   6. Set large digits flag to true.
4. Otherwise, let v be the result of applying the rules for parsing a small CJK number.
5. If v is null, return null and abort these steps.
6. If input starts with a CJK decimal separator followed by one or more CJK digits:
   1. Let digits be the found substring.
   2. Remove them from input.
   3. Replace the first character from digits by 0..
   4. Replace each other character in digits by the ASCII digit representing its value.
   5. Add the value obtained by interpreting digits as a decimal number to v.
7. If input starts with a CJK ten octillion, remove it from input and run these steps:
   1. Let m be the value of the removed character.
   2. Add v × m to value.
   3. Set v to the result of applying the rules for parsing a small CJK number.
   4. If v is null, return value.
8. If input starts with a CJK septillion, remove it from input and run these steps:
   1. Let m be the value of the removed character.
   2. Add v × m to value.
   3. Set v to the result of applying the rules for parsing a small CJK number.
   4. If v is null, return value.
9. If input starts with a CJK hundred quintillion, remove it from input and run these steps:
   1. Let m be the value of the removed character.
   2. Add v × m to value.
   3. Set v to the result of applying the rules for parsing a small CJK number.
   4. If v is null, return value.
10. If input starts with a CJK ten quadrillion, remove it from input and run these steps:
    1. Let m be the value of the removed character.
    2. Add v × m to value.
    3. Set v to the result of applying the rules for parsing a small CJK number.
    4. If v is null, return value.
11. If input starts with a CJK trillion, remove it from input and run these steps:
    1. Let m be the value of the removed character.
    2. Add v × m to value.
    3. Set v to the result of applying the rules for parsing a small CJK number.
    4. If v is null, return value.
12. If input starts with a CJK hundred million, remove it from input and run these steps:
    1. Let m be the value of the removed character.
    2. Add v × m to value.
    3. Set v to the result of applying the rules for parsing a small CJK number.
    4. If v is null, return value.
13. If input starts with a CJK hundred followed by a CJK ten thousand:
    1. Let m be the value of the first character of input.
    2. Let n be the value of the second character of input.
    3. Remove first two characters from input.
    4. Add v × m × n to value.
    5. Set v to the result of applying the rules for parsing a small CJK number.
    6. If v is null, return value.
14. Otherwise, if input starts with a CJK ten thousand, remove it from input and run these steps:
    1. Let m be the value of the removed character.
    2. Add v × m to value.
    3. Set v to the result of applying the rules for parsing a small CJK number.
    4. If v is null, return value.
15. If large digits flag is true and input starts with a CJK thousand followed by zero, one, two, or three CJK digits:
    1. Let m be the value of the first character of input.
    2. Let digits be the found CJK digits.
    3. Remove them from input.
    4. Add v × m to value.
    5. Replace each character in digits by the ASCII digit representing its value.
    6. If digits is the empty string, set v to 0. Otherwise, set v to the value obtained by interpreting digits as a decimal number.
16. Add v to value.
17. Return value.

The rules for parsing a small CJK number are these steps, which share the same input with the steps that invoke these steps:

1. If input starts with:
   • a CJK non-zero digits followed by one, two, or three CJK digits,
   • a CJK zero followed by two or three CJK digits, or
   • a CJK digit followed by a CJK digit group separator followed by three CJK digits,
   ... then:
   1. Let digits be the found substring.
   2. Remove them from input.
   3. Remove any CJK digit group separator from digits.
   4. Replace each character in digits by the ASCII digit representing its value.
   5. Return the value obtained by interpreting digits as a decimal number and abort the entire steps.
2. Let value be zero.
3. Let thousand flag be false.
4. Let removed flag be false.
5. If input starts with a CJK digit followed by a CJK thousand, remove them from input and run these steps:
   1. Let n be the value of the CJK digit.
   2. Let m be the value of the CJK thousand.
   3. Add n × m to value.
   4. Set thousand flag to true.
   5. Set removed flag to true.
6. Otherwise, if input starts with a CJK thousand:
   1. Remove it from input and add the value of it to value.
   2. Set thousand flag to true.
   3. Set removed flag to true.
7. Otherwise, if input starts with a CJK zero followed by a CJK digit:
   1. Remove the CJK zero from input.
8. If input starts with a CJK digit followed by a CJK hundred, remove them from input and run these steps:
   1. Let n be the value of the CJK digit.
   2. Let m be the value of the CJK hundred.
   3. Add n × m to value.
   4. Set thousand flag to false.
   5. Set removed flag to true.
9. Otherwise, if input starts with a CJK hundred or CJK multiple hundreds:
   1. Remove it from input and add the value of it to value.
   2. Set thousand flag to false.
   3. Set removed flag to true.
10. Otherwise, if input starts with a CJK zero followed by a CJK digit:
    1. Remove the CJK zero from input.
    2. Set thousand flag to false.
11. If input starts with a CJK digit followed by a CJK ten, remove them from input and run these steps:
    1. Let n be the value of the CJK digit.
    2. Let m be the value of the CJK ten.
    3. Add n × m to value.
    4. Set thousand flag to false.
    5. Set removed flag to true.
12. Otherwise, if input starts with a CJK ten or CJK multiple tens:
    1. Remove it from input and add the value of it to value.
    2. Set thousand flag to false.
    3. Set removed flag to true.
13. Otherwise, if input starts with a CJK zero followed by a CJK digit:
    1. Remove the CJK zero from input.
    2. Set thousand flag to false.
14. If thousand flag is true and input starts with two or three CJK digits:
    1. Let digits be them.
    2. Remove them from input.
    3. Replace each character in digits by the ASCII digit representing its value.
    4. Add the value obtained by interpreting digits as a decimal number to value.
    5. Set removed flag to true.
15. Otherwise, if input starts with a CJK digit, or if removed flag is true and input starts with a CJK and separator followed by a CJK digit:
    1. Let digit be the CJK digit.
    2. Remove it from input.
    3. Add input's value to value.
16. If removed flag is false, return null and abort these steps.
17. Return value.

2.3 Serializing CJK numbers

To serialize a number in CJK-10000-grouped number string, with an integer number, the implementation MUST run these steps:

1. Let string be the empty string.
2. If number is less than zero (0):
   1. Append a U+2212 MINUS SIGN character (−) to string.
   2. Set number to number × −1.
3. Let jou be ⌊ number / 10000000000000000000000000000 ⌋.
4. If jou is greater than zero (0):
   1. Append the result of serializing jou to string.
   2. Append "穣" to string.
5. Let jo be ⌊ (number % 10000000000000000000000000000) / 1000000000000000000000000 ⌋.
6. If jo is greater than zero (0):
   1. Append the result of serializing jo to string.
   2. Append "𥝱" to string.
7. Let gai be ⌊ (number % 1000000000000000000000000) / 100000000000000000000 ⌋.
8. If gai is greater than zero (0):
   1. Append the result of serializing gai to string.
   2. Append "垓" to string.
9. Let kei be ⌊ (number % 100000000000000000000) / 10000000000000000 ⌋.
10. If kei is greater than zero (0):
    1. Append the result of serializing kei to string.
    2. Append "京" to string.
11. Let chou be ⌊ (number % 10000000000000000) / 1000000000000 ⌋.
12. If chou is greater than zero (0):
    1. Append the result of serializing chou to string.
    2. Append "兆" to string.
13. Let oku be ⌊ (number % 1000000000000) / 100000000 ⌋.
14. If oku is greater than zero (0):
    1. Append the result of serializing oku to string.
    2. Append "億" to string.
15. Let man be ⌊ (number % 100000000) / 10000 ⌋.
16. If man is greater than zero (0):
    1. Append the result of serializing man to string.
    2. Append "万" to string.
17. Let one be number % 10000.
18. If one is greater than zero (0) or string is either the empty string or a U+2212 MINUS SIGN character (−):
    1. Append the result of serializing man to string.
19. Return string.