27 |
return n; |
return n; |
28 |
} |
} |
29 |
|
|
30 |
function gb_to_index(b0,b1,b2,b3) { |
function gb_to_index(gb) { |
31 |
return ((((b0 - 129) * 10 + (b1 - 48)) * 126 + (b2 - 129)) * 10 + b3 - 48); |
b0 = int(gb / 256); |
32 |
|
b1 = gb % 256; |
33 |
|
idx = (((b0 - 129)) * 191 + b1 - 64); |
34 |
|
# if (b1 >= 127) |
35 |
|
# idx--; |
36 |
|
return idx |
37 |
} |
} |
38 |
|
|
39 |
function index_to_gb(idx) { |
function index_to_gb(idx) { |
40 |
b3 = (idx % 10) + 48; |
b3 = (idx % 10) + 48; |
41 |
idx /= 10; |
idx = int(idx / 10); |
42 |
b2 = (idx % 126) + 129; |
b2 = (idx % 126) + 129; |
43 |
idx /= 126; |
idx = int(idx / 126); |
44 |
b1 = (idx % 10) + 48; |
b1 = (idx % 10) + 48; |
45 |
b0 = (idx / 10) + 129; |
b0 = int(idx / 10) + 129; |
46 |
return sprintf("%02X%02X%02X%02X", b0, b1, b2, b3); |
return sprintf("%02X%02X%02X%02X", b0, b1, b2, b3); |
47 |
} |
} |
48 |
|
|
49 |
function decode_gb(str) { |
/^\#/ { |
50 |
b0 = decode_hex(substr(str, 3, 2)); |
print; |
51 |
b1 = decode_hex(substr(str, 7, 2)); |
next; |
|
b2 = decode_hex(substr(str, 11, 2)); |
|
|
b3 = decode_hex(substr(str, 15, 2)); |
|
|
return gb_to_index(b0, b1, b2, b3); |
|
|
} |
|
|
|
|
|
function printline(from, to) { |
|
|
fromgb = index_to_gb(from); |
|
|
fromuni = gbtable[from]; |
|
|
if (from == to) |
|
|
printf ("0x%s 0x%04X\n", fromgb, fromuni); |
|
|
else |
|
|
printf ("0x%s-0x%s 0x%04X\n", fromgb, index_to_gb(to), fromuni); |
|
|
} |
|
|
|
|
|
/^<U[0-9A-F][0-9A-F][0-9A-F][0-9A-F]>/ { |
|
|
unicode = decode_hex(substr($1, 3, 4)); |
|
|
if ($2 ~ /\\x8[1-4]\\x3[0-9]\\x[8-9A-F][0-9A-F]\\x3[0-9]/) |
|
|
unitable[unicode] = decode_gb($2); |
|
|
else |
|
|
unitable[unicode] = -1; |
|
52 |
} |
} |
53 |
|
|
54 |
END { |
/0x....-0x..../ { |
55 |
lastgb = 0; |
gb_from = gb_to_index(decode_hex(substr($1, 3, 4))); |
56 |
surrogate_min = decode_hex("D800"); |
gb_to = gb_to_index(decode_hex(substr($1, 10, 4))); |
57 |
surrogate_max = decode_hex("DFFF"); |
unicode = decode_hex(substr($2, 3, 4)); |
58 |
lastgb = unitable[128]; |
while (gb_from <= gb_to) |
|
gbtable[lastgb] = 128; |
|
|
for (i = 129; i < 65536; i++) |
|
59 |
{ |
{ |
60 |
if (unitable[i] == 0 && (i < surrogate_min || i > surrogate_max)) |
table[unicode++] = 1; |
61 |
{ |
gb_from++; |
|
lastgb++; |
|
|
gbtable[lastgb] = i; |
|
|
unitable[i] = lastgb; |
|
|
} |
|
|
else if (unitable[i] > 0) |
|
|
{ |
|
|
lastgb = unitable[i]; |
|
|
gbtable[lastgb] = i; |
|
|
} |
|
62 |
} |
} |
63 |
|
next; |
64 |
|
} |
65 |
|
|
66 |
fromgb = lastgb = unitable[128]; |
{ |
67 |
for (i = 129; i < 65536; i++) |
gb = decode_hex(substr($1, 3, 4)); |
68 |
|
unicode = decode_hex(substr($2, 3, 4)); |
69 |
|
table[unicode] = 1; |
70 |
|
} |
71 |
|
|
72 |
|
END { |
73 |
|
from_gb = -1; |
74 |
|
to_gb = 0; |
75 |
|
from_i = 0; |
76 |
|
table[65536] = 1; |
77 |
|
for (i = 128; i <= 65536; i++) |
78 |
{ |
{ |
79 |
if (unitable[i] > 0) |
if (table[i] == 0) |
80 |
{ |
{ |
81 |
if (lastgb + 1 == unitable[i]) |
if (i < 55296 || i >= 57344) |
|
{ |
|
|
lastgb++; |
|
|
} |
|
|
else |
|
82 |
{ |
{ |
83 |
if (lastgb >= 0) |
if (from_gb < 0) |
84 |
printline(fromgb, lastgb); |
{ |
85 |
fromgb = lastgb = unitable[i]; |
from_gb = to_gb; |
86 |
|
from_i = i; |
87 |
|
} |
88 |
|
to_gb++; |
89 |
} |
} |
90 |
} |
} |
91 |
else # i.e. (unitable[i] < 0) |
else if (from_gb >= 0) |
92 |
{ |
{ |
93 |
if (lastgb >= 0) |
if (from_gb + 1 == to_gb) |
94 |
printline(fromgb, lastgb); |
printf "0x%s\t\t0x%04X\n", |
95 |
lastgb = -1; |
index_to_gb(from_gb), from_i; |
96 |
|
else |
97 |
|
printf "0x%s-0x%s\t0x%04X\n", |
98 |
|
index_to_gb(from_gb), index_to_gb(to_gb - 1), from_i; |
99 |
|
from_gb = -1; |
100 |
} |
} |
101 |
} |
} |
|
printline(fromgb, unitable[65535]); |
|
102 |
} |
} |