2b39f9f4b2
Among others, this updates minio-go, so that the new "eu-west-3" zone for AWS is supported.
310 lines
8.5 KiB
Go
310 lines
8.5 KiB
Go
// Copyright 2015 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// Unicode table generator.
|
|
// Data read from the web.
|
|
|
|
// +build ignore
|
|
|
|
package main
|
|
|
|
import (
|
|
"flag"
|
|
"log"
|
|
"unicode"
|
|
"unicode/utf8"
|
|
|
|
"golang.org/x/text/internal/gen"
|
|
"golang.org/x/text/internal/triegen"
|
|
"golang.org/x/text/internal/ucd"
|
|
"golang.org/x/text/unicode/norm"
|
|
"golang.org/x/text/unicode/rangetable"
|
|
)
|
|
|
|
var outputFile = flag.String("output", "tables.go", "output file for generated tables; default tables.go")
|
|
|
|
var assigned, disallowedRunes *unicode.RangeTable
|
|
|
|
var runeCategory = map[rune]category{}
|
|
|
|
var overrides = map[category]category{
|
|
viramaModifier: viramaJoinT,
|
|
greek: greekJoinT,
|
|
hebrew: hebrewJoinT,
|
|
}
|
|
|
|
func setCategory(r rune, cat category) {
|
|
if c, ok := runeCategory[r]; ok {
|
|
if override, ok := overrides[c]; cat == joiningT && ok {
|
|
cat = override
|
|
} else {
|
|
log.Fatalf("%U: multiple categories for rune (%v and %v)", r, c, cat)
|
|
}
|
|
}
|
|
runeCategory[r] = cat
|
|
}
|
|
|
|
func init() {
|
|
if numCategories > 1<<propShift {
|
|
log.Fatalf("Number of categories is %d; may at most be %d", numCategories, 1<<propShift)
|
|
}
|
|
}
|
|
|
|
func main() {
|
|
gen.Init()
|
|
|
|
// Load data
|
|
runes := []rune{}
|
|
// PrecisIgnorableProperties: https://tools.ietf.org/html/rfc7564#section-9.13
|
|
ucd.Parse(gen.OpenUCDFile("DerivedCoreProperties.txt"), func(p *ucd.Parser) {
|
|
if p.String(1) == "Default_Ignorable_Code_Point" {
|
|
runes = append(runes, p.Rune(0))
|
|
}
|
|
})
|
|
ucd.Parse(gen.OpenUCDFile("PropList.txt"), func(p *ucd.Parser) {
|
|
switch p.String(1) {
|
|
case "Noncharacter_Code_Point":
|
|
runes = append(runes, p.Rune(0))
|
|
}
|
|
})
|
|
// OldHangulJamo: https://tools.ietf.org/html/rfc5892#section-2.9
|
|
ucd.Parse(gen.OpenUCDFile("HangulSyllableType.txt"), func(p *ucd.Parser) {
|
|
switch p.String(1) {
|
|
case "L", "V", "T":
|
|
runes = append(runes, p.Rune(0))
|
|
}
|
|
})
|
|
|
|
disallowedRunes = rangetable.New(runes...)
|
|
assigned = rangetable.Assigned(unicode.Version)
|
|
|
|
// Load category data.
|
|
runeCategory['l'] = latinSmallL
|
|
ucd.Parse(gen.OpenUCDFile("UnicodeData.txt"), func(p *ucd.Parser) {
|
|
const cccVirama = 9
|
|
if p.Int(ucd.CanonicalCombiningClass) == cccVirama {
|
|
setCategory(p.Rune(0), viramaModifier)
|
|
}
|
|
})
|
|
ucd.Parse(gen.OpenUCDFile("Scripts.txt"), func(p *ucd.Parser) {
|
|
switch p.String(1) {
|
|
case "Greek":
|
|
setCategory(p.Rune(0), greek)
|
|
case "Hebrew":
|
|
setCategory(p.Rune(0), hebrew)
|
|
case "Hiragana", "Katakana", "Han":
|
|
setCategory(p.Rune(0), japanese)
|
|
}
|
|
})
|
|
|
|
// Set the rule categories associated with exceptions. This overrides any
|
|
// previously set categories. The original categories are manually
|
|
// reintroduced in the categoryTransitions table.
|
|
for r, e := range exceptions {
|
|
if e.cat != 0 {
|
|
runeCategory[r] = e.cat
|
|
}
|
|
}
|
|
cat := map[string]category{
|
|
"L": joiningL,
|
|
"D": joiningD,
|
|
"T": joiningT,
|
|
|
|
"R": joiningR,
|
|
}
|
|
ucd.Parse(gen.OpenUCDFile("extracted/DerivedJoiningType.txt"), func(p *ucd.Parser) {
|
|
switch v := p.String(1); v {
|
|
case "L", "D", "T", "R":
|
|
setCategory(p.Rune(0), cat[v])
|
|
}
|
|
})
|
|
|
|
writeTables()
|
|
gen.Repackage("gen_trieval.go", "trieval.go", "precis")
|
|
}
|
|
|
|
type exception struct {
|
|
prop property
|
|
cat category
|
|
}
|
|
|
|
func init() {
|
|
// Programmatically add the Arabic and Indic digits to the exceptions map.
|
|
// See comment in the exceptions map below why these are marked disallowed.
|
|
for i := rune(0); i <= 9; i++ {
|
|
exceptions[0x0660+i] = exception{
|
|
prop: disallowed,
|
|
cat: arabicIndicDigit,
|
|
}
|
|
exceptions[0x06F0+i] = exception{
|
|
prop: disallowed,
|
|
cat: extendedArabicIndicDigit,
|
|
}
|
|
}
|
|
}
|
|
|
|
// The Exceptions class as defined in RFC 5892
|
|
// https://tools.ietf.org/html/rfc5892#section-2.6
|
|
var exceptions = map[rune]exception{
|
|
0x00DF: {prop: pValid},
|
|
0x03C2: {prop: pValid},
|
|
0x06FD: {prop: pValid},
|
|
0x06FE: {prop: pValid},
|
|
0x0F0B: {prop: pValid},
|
|
0x3007: {prop: pValid},
|
|
|
|
// ContextO|J rules are marked as disallowed, taking a "guilty until proven
|
|
// innocent" approach. The main reason for this is that the check for
|
|
// whether a context rule should be applied can be moved to the logic for
|
|
// handing disallowed runes, taken it off the common path. The exception to
|
|
// this rule is for katakanaMiddleDot, as the rule logic is handled without
|
|
// using a rule function.
|
|
|
|
// ContextJ (Join control)
|
|
0x200C: {prop: disallowed, cat: zeroWidthNonJoiner},
|
|
0x200D: {prop: disallowed, cat: zeroWidthJoiner},
|
|
|
|
// ContextO
|
|
0x00B7: {prop: disallowed, cat: middleDot},
|
|
0x0375: {prop: disallowed, cat: greekLowerNumeralSign},
|
|
0x05F3: {prop: disallowed, cat: hebrewPreceding}, // punctuation Geresh
|
|
0x05F4: {prop: disallowed, cat: hebrewPreceding}, // punctuation Gershayim
|
|
0x30FB: {prop: pValid, cat: katakanaMiddleDot},
|
|
|
|
// These are officially ContextO, but the implementation does not require
|
|
// special treatment of these, so we simply mark them as valid.
|
|
0x0660: {prop: pValid},
|
|
0x0661: {prop: pValid},
|
|
0x0662: {prop: pValid},
|
|
0x0663: {prop: pValid},
|
|
0x0664: {prop: pValid},
|
|
0x0665: {prop: pValid},
|
|
0x0666: {prop: pValid},
|
|
0x0667: {prop: pValid},
|
|
0x0668: {prop: pValid},
|
|
0x0669: {prop: pValid},
|
|
0x06F0: {prop: pValid},
|
|
0x06F1: {prop: pValid},
|
|
0x06F2: {prop: pValid},
|
|
0x06F3: {prop: pValid},
|
|
0x06F4: {prop: pValid},
|
|
0x06F5: {prop: pValid},
|
|
0x06F6: {prop: pValid},
|
|
0x06F7: {prop: pValid},
|
|
0x06F8: {prop: pValid},
|
|
0x06F9: {prop: pValid},
|
|
|
|
0x0640: {prop: disallowed},
|
|
0x07FA: {prop: disallowed},
|
|
0x302E: {prop: disallowed},
|
|
0x302F: {prop: disallowed},
|
|
0x3031: {prop: disallowed},
|
|
0x3032: {prop: disallowed},
|
|
0x3033: {prop: disallowed},
|
|
0x3034: {prop: disallowed},
|
|
0x3035: {prop: disallowed},
|
|
0x303B: {prop: disallowed},
|
|
}
|
|
|
|
// LetterDigits: https://tools.ietf.org/html/rfc5892#section-2.1
|
|
// r in {Ll, Lu, Lo, Nd, Lm, Mn, Mc}.
|
|
func isLetterDigits(r rune) bool {
|
|
return unicode.In(r,
|
|
unicode.Ll, unicode.Lu, unicode.Lm, unicode.Lo, // Letters
|
|
unicode.Mn, unicode.Mc, // Modifiers
|
|
unicode.Nd, // Digits
|
|
)
|
|
}
|
|
|
|
func isIdDisAndFreePVal(r rune) bool {
|
|
return unicode.In(r,
|
|
// OtherLetterDigits: https://tools.ietf.org/html/rfc7564#section-9.18
|
|
// r in in {Lt, Nl, No, Me}
|
|
unicode.Lt, unicode.Nl, unicode.No, // Other letters / numbers
|
|
unicode.Me, // Modifiers
|
|
|
|
// Spaces: https://tools.ietf.org/html/rfc7564#section-9.14
|
|
// r in in {Zs}
|
|
unicode.Zs,
|
|
|
|
// Symbols: https://tools.ietf.org/html/rfc7564#section-9.15
|
|
// r in {Sm, Sc, Sk, So}
|
|
unicode.Sm, unicode.Sc, unicode.Sk, unicode.So,
|
|
|
|
// Punctuation: https://tools.ietf.org/html/rfc7564#section-9.16
|
|
// r in {Pc, Pd, Ps, Pe, Pi, Pf, Po}
|
|
unicode.Pc, unicode.Pd, unicode.Ps, unicode.Pe,
|
|
unicode.Pi, unicode.Pf, unicode.Po,
|
|
)
|
|
}
|
|
|
|
// HasCompat: https://tools.ietf.org/html/rfc7564#section-9.17
|
|
func hasCompat(r rune) bool {
|
|
return !norm.NFKC.IsNormalString(string(r))
|
|
}
|
|
|
|
// From https://tools.ietf.org/html/rfc5892:
|
|
//
|
|
// If .cp. .in. Exceptions Then Exceptions(cp);
|
|
// Else If .cp. .in. BackwardCompatible Then BackwardCompatible(cp);
|
|
// Else If .cp. .in. Unassigned Then UNASSIGNED;
|
|
// Else If .cp. .in. ASCII7 Then PVALID;
|
|
// Else If .cp. .in. JoinControl Then CONTEXTJ;
|
|
// Else If .cp. .in. OldHangulJamo Then DISALLOWED;
|
|
// Else If .cp. .in. PrecisIgnorableProperties Then DISALLOWED;
|
|
// Else If .cp. .in. Controls Then DISALLOWED;
|
|
// Else If .cp. .in. HasCompat Then ID_DIS or FREE_PVAL;
|
|
// Else If .cp. .in. LetterDigits Then PVALID;
|
|
// Else If .cp. .in. OtherLetterDigits Then ID_DIS or FREE_PVAL;
|
|
// Else If .cp. .in. Spaces Then ID_DIS or FREE_PVAL;
|
|
// Else If .cp. .in. Symbols Then ID_DIS or FREE_PVAL;
|
|
// Else If .cp. .in. Punctuation Then ID_DIS or FREE_PVAL;
|
|
// Else DISALLOWED;
|
|
|
|
func writeTables() {
|
|
propTrie := triegen.NewTrie("derivedProperties")
|
|
w := gen.NewCodeWriter()
|
|
defer w.WriteVersionedGoFile(*outputFile, "precis")
|
|
gen.WriteUnicodeVersion(w)
|
|
|
|
// Iterate over all the runes...
|
|
for i := rune(0); i < unicode.MaxRune; i++ {
|
|
r := rune(i)
|
|
|
|
if !utf8.ValidRune(r) {
|
|
continue
|
|
}
|
|
|
|
e, ok := exceptions[i]
|
|
p := e.prop
|
|
switch {
|
|
case ok:
|
|
case !unicode.In(r, assigned):
|
|
p = unassigned
|
|
case r >= 0x0021 && r <= 0x007e: // Is ASCII 7
|
|
p = pValid
|
|
case unicode.In(r, disallowedRunes, unicode.Cc):
|
|
p = disallowed
|
|
case hasCompat(r):
|
|
p = idDisOrFreePVal
|
|
case isLetterDigits(r):
|
|
p = pValid
|
|
case isIdDisAndFreePVal(r):
|
|
p = idDisOrFreePVal
|
|
default:
|
|
p = disallowed
|
|
}
|
|
cat := runeCategory[r]
|
|
// Don't set category for runes that are disallowed.
|
|
if p == disallowed {
|
|
cat = exceptions[r].cat
|
|
}
|
|
propTrie.Insert(r, uint64(p)|uint64(cat))
|
|
}
|
|
sz, err := propTrie.Gen(w)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
w.Size += sz
|
|
}
|