| 1 |
// Copyright 2017 The Go Authors. All rights reserved. |
| 2 |
// Use of this source code is governed by a BSD-style |
| 3 |
// license that can be found in the LICENSE file. |
| 4 |
|
| 5 |
//go:build ignore |
| 6 |
|
| 7 |
package main |
| 8 |
|
| 9 |
import ( |
| 10 |
"encoding/xml" |
| 11 |
"fmt" |
| 12 |
"io" |
| 13 |
"log" |
| 14 |
"sort" |
| 15 |
"strconv" |
| 16 |
"strings" |
| 17 |
|
| 18 |
"golang.org/x/text/encoding/internal/identifier" |
| 19 |
"golang.org/x/text/internal/gen" |
| 20 |
) |
| 21 |
|
| 22 |
type registry struct { |
| 23 |
XMLName xml.Name `xml:"registry"` |
| 24 |
Updated string `xml:"updated"` |
| 25 |
Registry []struct { |
| 26 |
ID string `xml:"id,attr"` |
| 27 |
Record []struct { |
| 28 |
Name string `xml:"name"` |
| 29 |
Xref []struct { |
| 30 |
Type string `xml:"type,attr"` |
| 31 |
Data string `xml:"data,attr"` |
| 32 |
} `xml:"xref"` |
| 33 |
Desc struct { |
| 34 |
Data string `xml:",innerxml"` |
| 35 |
} `xml:"description,"` |
| 36 |
MIB string `xml:"value"` |
| 37 |
Alias []string `xml:"alias"` |
| 38 |
MIME string `xml:"preferred_alias"` |
| 39 |
} `xml:"record"` |
| 40 |
} `xml:"registry"` |
| 41 |
} |
| 42 |
|
| 43 |
func main() { |
| 44 |
r := gen.OpenIANAFile("assignments/character-sets/character-sets.xml") |
| 45 |
reg := ®istry{} |
| 46 |
if err := xml.NewDecoder(r).Decode(®); err != nil && err != io.EOF { |
| 47 |
log.Fatalf("Error decoding charset registry: %v", err) |
| 48 |
} |
| 49 |
if len(reg.Registry) == 0 || reg.Registry[0].ID != "character-sets-1" { |
| 50 |
log.Fatalf("Unexpected ID %s", reg.Registry[0].ID) |
| 51 |
} |
| 52 |
|
| 53 |
x := &indexInfo{} |
| 54 |
|
| 55 |
for _, rec := range reg.Registry[0].Record { |
| 56 |
mib := identifier.MIB(parseInt(rec.MIB)) |
| 57 |
x.addEntry(mib, rec.Name) |
| 58 |
for _, a := range rec.Alias { |
| 59 |
a = strings.Split(a, " ")[0] // strip comments. |
| 60 |
x.addAlias(a, mib) |
| 61 |
// MIB name aliases are prefixed with a "cs" (character set) in the |
| 62 |
// registry to identify them as display names and to ensure that |
| 63 |
// the name starts with a lowercase letter in case it is used as |
| 64 |
// an identifier. We remove it to be left with a nice clean name. |
| 65 |
if strings.HasPrefix(a, "cs") { |
| 66 |
x.setName(2, a[2:]) |
| 67 |
} |
| 68 |
} |
| 69 |
if rec.MIME != "" { |
| 70 |
x.addAlias(rec.MIME, mib) |
| 71 |
x.setName(1, rec.MIME) |
| 72 |
} |
| 73 |
} |
| 74 |
|
| 75 |
w := gen.NewCodeWriter() |
| 76 |
|
| 77 |
fmt.Fprintln(w, `import "golang.org/x/text/encoding/internal/identifier"`) |
| 78 |
|
| 79 |
writeIndex(w, x) |
| 80 |
|
| 81 |
w.WriteGoFile("tables.go", "ianaindex") |
| 82 |
} |
| 83 |
|
| 84 |
type alias struct { |
| 85 |
name string |
| 86 |
mib identifier.MIB |
| 87 |
} |
| 88 |
|
| 89 |
type indexInfo struct { |
| 90 |
// compacted index from code to MIB |
| 91 |
codeToMIB []identifier.MIB |
| 92 |
alias []alias |
| 93 |
names [][3]string |
| 94 |
} |
| 95 |
|
| 96 |
func (ii *indexInfo) Len() int { |
| 97 |
return len(ii.codeToMIB) |
| 98 |
} |
| 99 |
|
| 100 |
func (ii *indexInfo) Less(a, b int) bool { |
| 101 |
return ii.codeToMIB[a] < ii.codeToMIB[b] |
| 102 |
} |
| 103 |
|
| 104 |
func (ii *indexInfo) Swap(a, b int) { |
| 105 |
ii.codeToMIB[a], ii.codeToMIB[b] = ii.codeToMIB[b], ii.codeToMIB[a] |
| 106 |
// Co-sort the names. |
| 107 |
ii.names[a], ii.names[b] = ii.names[b], ii.names[a] |
| 108 |
} |
| 109 |
|
| 110 |
func (ii *indexInfo) setName(i int, name string) { |
| 111 |
ii.names[len(ii.names)-1][i] = name |
| 112 |
} |
| 113 |
|
| 114 |
func (ii *indexInfo) addEntry(mib identifier.MIB, name string) { |
| 115 |
ii.names = append(ii.names, [3]string{name, name, name}) |
| 116 |
ii.addAlias(name, mib) |
| 117 |
ii.codeToMIB = append(ii.codeToMIB, mib) |
| 118 |
} |
| 119 |
|
| 120 |
func (ii *indexInfo) addAlias(name string, mib identifier.MIB) { |
| 121 |
// Don't add duplicates for the same mib. Adding duplicate aliases for |
| 122 |
// different MIBs will cause the compiler to barf on an invalid map: great!. |
| 123 |
for i := len(ii.alias) - 1; i >= 0 && ii.alias[i].mib == mib; i-- { |
| 124 |
if ii.alias[i].name == name { |
| 125 |
return |
| 126 |
} |
| 127 |
} |
| 128 |
ii.alias = append(ii.alias, alias{name, mib}) |
| 129 |
lower := strings.ToLower(name) |
| 130 |
if lower != name { |
| 131 |
ii.addAlias(lower, mib) |
| 132 |
} |
| 133 |
} |
| 134 |
|
| 135 |
const maxMIMENameLen = '0' - 1 // officially 40, but we leave some buffer. |
| 136 |
|
| 137 |
func writeIndex(w *gen.CodeWriter, x *indexInfo) { |
| 138 |
sort.Stable(x) |
| 139 |
|
| 140 |
// Write constants. |
| 141 |
fmt.Fprintln(w, "const (") |
| 142 |
for i, m := range x.codeToMIB { |
| 143 |
if i == 0 { |
| 144 |
fmt.Fprintf(w, "enc%d = iota\n", m) |
| 145 |
} else { |
| 146 |
fmt.Fprintf(w, "enc%d\n", m) |
| 147 |
} |
| 148 |
} |
| 149 |
fmt.Fprintln(w, "numIANA") |
| 150 |
fmt.Fprintln(w, ")") |
| 151 |
|
| 152 |
w.WriteVar("ianaToMIB", x.codeToMIB) |
| 153 |
|
| 154 |
var ianaNames, mibNames []string |
| 155 |
for _, names := range x.names { |
| 156 |
n := names[0] |
| 157 |
if names[0] != names[1] { |
| 158 |
// MIME names are mostly identical to IANA names. We share the |
| 159 |
// tables by setting the first byte of the string to an index into |
| 160 |
// the string itself (< maxMIMENameLen) to the IANA name. The MIME |
| 161 |
// name immediately follows the index. |
| 162 |
x := len(names[1]) + 1 |
| 163 |
if x > maxMIMENameLen { |
| 164 |
log.Fatalf("MIME name length (%d) > %d", x, maxMIMENameLen) |
| 165 |
} |
| 166 |
n = string(x) + names[1] + names[0] |
| 167 |
} |
| 168 |
ianaNames = append(ianaNames, n) |
| 169 |
mibNames = append(mibNames, names[2]) |
| 170 |
} |
| 171 |
|
| 172 |
w.WriteVar("ianaNames", ianaNames) |
| 173 |
w.WriteVar("mibNames", mibNames) |
| 174 |
|
| 175 |
w.WriteComment(` |
| 176 |
TODO: Instead of using a map, we could use binary search strings doing |
| 177 |
on-the fly lower-casing per character. This allows to always avoid |
| 178 |
allocation and will be considerably more compact.`) |
| 179 |
fmt.Fprintln(w, "var ianaAliases = map[string]int{") |
| 180 |
for _, a := range x.alias { |
| 181 |
fmt.Fprintf(w, "%q: enc%d,\n", a.name, a.mib) |
| 182 |
} |
| 183 |
fmt.Fprintln(w, "}") |
| 184 |
} |
| 185 |
|
| 186 |
func parseInt(s string) int { |
| 187 |
x, err := strconv.ParseInt(s, 10, 64) |
| 188 |
if err != nil { |
| 189 |
log.Fatalf("Could not parse integer: %v", err) |
| 190 |
} |
| 191 |
return int(x) |
| 192 |
} |