mirror of
https://github.com/letic/terraform-provider-google.git
synced 2024-09-07 01:26:43 +00:00
![Paddy](/assets/img/avatar_default.png)
Switch to using Go modules. This migrates our vendor.json to use Go 1.11's modules system, and replaces the vendor folder with the output of go mod vendor. The vendored code should remain basically the same; I believe some tree shaking of packages and support scripts/licenses/READMEs/etc. happened. This also fixes Travis and our Makefile to no longer use govendor.
308 lines
7.7 KiB
Go
308 lines
7.7 KiB
Go
// Copyright (c) 2014 Couchbase, Inc.
|
|
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
|
|
// except in compliance with the License. You may obtain a copy of the License at
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
// Unless required by applicable law or agreed to in writing, software distributed under the
|
|
// License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
|
|
// either express or implied. See the License for the specific language governing permissions
|
|
// and limitations under the License.
|
|
|
|
// Modified by Martin Atkins to serve the needs of package textseg.
|
|
|
|
// +build ignore
|
|
|
|
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"os/exec"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"unicode"
|
|
)
|
|
|
|
var url = flag.String("url",
|
|
"http://www.unicode.org/Public/"+unicode.Version+"/ucd/auxiliary/",
|
|
"URL of Unicode database directory")
|
|
var verbose = flag.Bool("verbose",
|
|
false,
|
|
"write data to stdout as it is parsed")
|
|
var localFiles = flag.Bool("local",
|
|
false,
|
|
"data files have been copied to the current directory; for debugging only")
|
|
var outputFile = flag.String("output",
|
|
"",
|
|
"output file for generated tables; default stdout")
|
|
|
|
var output *bufio.Writer
|
|
|
|
func main() {
|
|
flag.Parse()
|
|
setupOutput()
|
|
|
|
graphemePropertyRanges := make(map[string]*unicode.RangeTable)
|
|
loadUnicodeData("GraphemeBreakProperty.txt", graphemePropertyRanges)
|
|
wordPropertyRanges := make(map[string]*unicode.RangeTable)
|
|
loadUnicodeData("WordBreakProperty.txt", wordPropertyRanges)
|
|
sentencePropertyRanges := make(map[string]*unicode.RangeTable)
|
|
loadUnicodeData("SentenceBreakProperty.txt", sentencePropertyRanges)
|
|
|
|
fmt.Fprintf(output, fileHeader, *url)
|
|
generateTables("Grapheme", graphemePropertyRanges)
|
|
generateTables("Word", wordPropertyRanges)
|
|
generateTables("Sentence", sentencePropertyRanges)
|
|
|
|
flushOutput()
|
|
}
|
|
|
|
// WordBreakProperty.txt has the form:
|
|
// 05F0..05F2 ; Hebrew_Letter # Lo [3] HEBREW LIGATURE YIDDISH DOUBLE VAV..HEBREW LIGATURE YIDDISH DOUBLE YOD
|
|
// FB1D ; Hebrew_Letter # Lo HEBREW LETTER YOD WITH HIRIQ
|
|
func openReader(file string) (input io.ReadCloser) {
|
|
if *localFiles {
|
|
f, err := os.Open(file)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
input = f
|
|
} else {
|
|
path := *url + file
|
|
resp, err := http.Get(path)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
if resp.StatusCode != 200 {
|
|
log.Fatal("bad GET status for "+file, resp.Status)
|
|
}
|
|
input = resp.Body
|
|
}
|
|
return
|
|
}
|
|
|
|
func loadUnicodeData(filename string, propertyRanges map[string]*unicode.RangeTable) {
|
|
f := openReader(filename)
|
|
defer f.Close()
|
|
bufioReader := bufio.NewReader(f)
|
|
line, err := bufioReader.ReadString('\n')
|
|
for err == nil {
|
|
parseLine(line, propertyRanges)
|
|
line, err = bufioReader.ReadString('\n')
|
|
}
|
|
// if the err was EOF still need to process last value
|
|
if err == io.EOF {
|
|
parseLine(line, propertyRanges)
|
|
}
|
|
}
|
|
|
|
const comment = "#"
|
|
const sep = ";"
|
|
const rnge = ".."
|
|
|
|
func parseLine(line string, propertyRanges map[string]*unicode.RangeTable) {
|
|
if strings.HasPrefix(line, comment) {
|
|
return
|
|
}
|
|
line = strings.TrimSpace(line)
|
|
if len(line) == 0 {
|
|
return
|
|
}
|
|
commentStart := strings.Index(line, comment)
|
|
if commentStart > 0 {
|
|
line = line[0:commentStart]
|
|
}
|
|
pieces := strings.Split(line, sep)
|
|
if len(pieces) != 2 {
|
|
log.Printf("unexpected %d pieces in %s", len(pieces), line)
|
|
return
|
|
}
|
|
|
|
propertyName := strings.TrimSpace(pieces[1])
|
|
|
|
rangeTable, ok := propertyRanges[propertyName]
|
|
if !ok {
|
|
rangeTable = &unicode.RangeTable{
|
|
LatinOffset: 0,
|
|
}
|
|
propertyRanges[propertyName] = rangeTable
|
|
}
|
|
|
|
codepointRange := strings.TrimSpace(pieces[0])
|
|
rngeIndex := strings.Index(codepointRange, rnge)
|
|
|
|
if rngeIndex < 0 {
|
|
// single codepoint, not range
|
|
codepointInt, err := strconv.ParseUint(codepointRange, 16, 64)
|
|
if err != nil {
|
|
log.Printf("error parsing int: %v", err)
|
|
return
|
|
}
|
|
if codepointInt < 0x10000 {
|
|
r16 := unicode.Range16{
|
|
Lo: uint16(codepointInt),
|
|
Hi: uint16(codepointInt),
|
|
Stride: 1,
|
|
}
|
|
addR16ToTable(rangeTable, r16)
|
|
} else {
|
|
r32 := unicode.Range32{
|
|
Lo: uint32(codepointInt),
|
|
Hi: uint32(codepointInt),
|
|
Stride: 1,
|
|
}
|
|
addR32ToTable(rangeTable, r32)
|
|
}
|
|
} else {
|
|
rngeStart := codepointRange[0:rngeIndex]
|
|
rngeEnd := codepointRange[rngeIndex+2:]
|
|
rngeStartInt, err := strconv.ParseUint(rngeStart, 16, 64)
|
|
if err != nil {
|
|
log.Printf("error parsing int: %v", err)
|
|
return
|
|
}
|
|
rngeEndInt, err := strconv.ParseUint(rngeEnd, 16, 64)
|
|
if err != nil {
|
|
log.Printf("error parsing int: %v", err)
|
|
return
|
|
}
|
|
if rngeStartInt < 0x10000 && rngeEndInt < 0x10000 {
|
|
r16 := unicode.Range16{
|
|
Lo: uint16(rngeStartInt),
|
|
Hi: uint16(rngeEndInt),
|
|
Stride: 1,
|
|
}
|
|
addR16ToTable(rangeTable, r16)
|
|
} else if rngeStartInt >= 0x10000 && rngeEndInt >= 0x10000 {
|
|
r32 := unicode.Range32{
|
|
Lo: uint32(rngeStartInt),
|
|
Hi: uint32(rngeEndInt),
|
|
Stride: 1,
|
|
}
|
|
addR32ToTable(rangeTable, r32)
|
|
} else {
|
|
log.Printf("unexpected range")
|
|
}
|
|
}
|
|
}
|
|
|
|
func addR16ToTable(r *unicode.RangeTable, r16 unicode.Range16) {
|
|
if r.R16 == nil {
|
|
r.R16 = make([]unicode.Range16, 0, 1)
|
|
}
|
|
r.R16 = append(r.R16, r16)
|
|
if r16.Hi <= unicode.MaxLatin1 {
|
|
r.LatinOffset++
|
|
}
|
|
}
|
|
|
|
func addR32ToTable(r *unicode.RangeTable, r32 unicode.Range32) {
|
|
if r.R32 == nil {
|
|
r.R32 = make([]unicode.Range32, 0, 1)
|
|
}
|
|
r.R32 = append(r.R32, r32)
|
|
}
|
|
|
|
func generateTables(prefix string, propertyRanges map[string]*unicode.RangeTable) {
|
|
prNames := make([]string, 0, len(propertyRanges))
|
|
for k := range propertyRanges {
|
|
prNames = append(prNames, k)
|
|
}
|
|
sort.Strings(prNames)
|
|
for _, key := range prNames {
|
|
rt := propertyRanges[key]
|
|
fmt.Fprintf(output, "var _%s%s = %s\n", prefix, key, generateRangeTable(rt))
|
|
}
|
|
fmt.Fprintf(output, "type _%sRuneRange unicode.RangeTable\n", prefix)
|
|
|
|
fmt.Fprintf(output, "func _%sRuneType(r rune) *_%sRuneRange {\n", prefix, prefix)
|
|
fmt.Fprintf(output, "\tswitch {\n")
|
|
for _, key := range prNames {
|
|
fmt.Fprintf(output, "\tcase unicode.Is(_%s%s, r):\n\t\treturn (*_%sRuneRange)(_%s%s)\n", prefix, key, prefix, prefix, key)
|
|
}
|
|
fmt.Fprintf(output, "\tdefault:\n\t\treturn nil\n")
|
|
fmt.Fprintf(output, "\t}\n")
|
|
fmt.Fprintf(output, "}\n")
|
|
|
|
fmt.Fprintf(output, "func (rng *_%sRuneRange) String() string {\n", prefix)
|
|
fmt.Fprintf(output, "\tswitch (*unicode.RangeTable)(rng) {\n")
|
|
for _, key := range prNames {
|
|
fmt.Fprintf(output, "\tcase _%s%s:\n\t\treturn %q\n", prefix, key, key)
|
|
}
|
|
fmt.Fprintf(output, "\tdefault:\n\t\treturn \"Other\"\n")
|
|
fmt.Fprintf(output, "\t}\n")
|
|
fmt.Fprintf(output, "}\n")
|
|
}
|
|
|
|
func generateRangeTable(rt *unicode.RangeTable) string {
|
|
rv := "&unicode.RangeTable{\n"
|
|
if rt.R16 != nil {
|
|
rv += "\tR16: []unicode.Range16{\n"
|
|
for _, r16 := range rt.R16 {
|
|
rv += fmt.Sprintf("\t\t%#v,\n", r16)
|
|
}
|
|
rv += "\t},\n"
|
|
}
|
|
if rt.R32 != nil {
|
|
rv += "\tR32: []unicode.Range32{\n"
|
|
for _, r32 := range rt.R32 {
|
|
rv += fmt.Sprintf("\t\t%#v,\n", r32)
|
|
}
|
|
rv += "\t},\n"
|
|
}
|
|
rv += fmt.Sprintf("\t\tLatinOffset: %d,\n", rt.LatinOffset)
|
|
rv += "}\n"
|
|
return rv
|
|
}
|
|
|
|
const fileHeader = `// Generated by running
|
|
// maketables --url=%s
|
|
// DO NOT EDIT
|
|
|
|
package textseg
|
|
|
|
import(
|
|
"unicode"
|
|
)
|
|
`
|
|
|
|
func setupOutput() {
|
|
output = bufio.NewWriter(startGofmt())
|
|
}
|
|
|
|
// startGofmt connects output to a gofmt process if -output is set.
|
|
func startGofmt() io.Writer {
|
|
if *outputFile == "" {
|
|
return os.Stdout
|
|
}
|
|
stdout, err := os.Create(*outputFile)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
// Pipe output to gofmt.
|
|
gofmt := exec.Command("gofmt")
|
|
fd, err := gofmt.StdinPipe()
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
gofmt.Stdout = stdout
|
|
gofmt.Stderr = os.Stderr
|
|
err = gofmt.Start()
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
return fd
|
|
}
|
|
|
|
func flushOutput() {
|
|
err := output.Flush()
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
}
|