mirror of
https://github.com/golang/go.git
synced 2025-12-08 06:10:04 +00:00
remove semis after statements in one-statement statement lists
R=rsc, r http://go/go-review/1025029
This commit is contained in:
Robert Griesemer
parent
18ccbc69f8
commit
40621d5c0d
408 changed files with 7859 additions and 7859 deletions
|
|
@ -141,23 +141,23 @@ const (
|
|||
func parseCategory(line string) (state State) {
|
||||
field := strings.Split(line, ";", -1);
|
||||
if len(field) != NumField {
|
||||
die.Logf("%5s: %d fields (expected %d)\n", line, len(field), NumField);
|
||||
die.Logf("%5s: %d fields (expected %d)\n", line, len(field), NumField)
|
||||
}
|
||||
point, err := strconv.Btoui64(field[FCodePoint], 16);
|
||||
if err != nil {
|
||||
die.Log("%.5s...:", err);
|
||||
die.Log("%.5s...:", err)
|
||||
}
|
||||
lastChar = uint32(point);
|
||||
if point == 0 {
|
||||
return; // not interesting and we use 0 as unset
|
||||
return // not interesting and we use 0 as unset
|
||||
}
|
||||
if point > MaxChar {
|
||||
return;
|
||||
return
|
||||
}
|
||||
char := &chars[point];
|
||||
char.field = field;
|
||||
if char.codePoint != 0 {
|
||||
die.Logf("point U+%04x reused\n");
|
||||
die.Logf("point U+%04x reused\n")
|
||||
}
|
||||
char.codePoint = lastChar;
|
||||
char.category = field[FGeneralCategory];
|
||||
|
|
@ -167,22 +167,22 @@ func parseCategory(line string) (state State) {
|
|||
// Decimal digit
|
||||
_, err := strconv.Atoi(field[FNumericValue]);
|
||||
if err != nil {
|
||||
die.Log("U+%04x: bad numeric field: %s", point, err);
|
||||
die.Log("U+%04x: bad numeric field: %s", point, err)
|
||||
}
|
||||
case "Lu":
|
||||
char.letter(field[FCodePoint], field[FSimpleLowercaseMapping], field[FSimpleTitlecaseMapping]);
|
||||
char.letter(field[FCodePoint], field[FSimpleLowercaseMapping], field[FSimpleTitlecaseMapping])
|
||||
case "Ll":
|
||||
char.letter(field[FSimpleUppercaseMapping], field[FCodePoint], field[FSimpleTitlecaseMapping]);
|
||||
char.letter(field[FSimpleUppercaseMapping], field[FCodePoint], field[FSimpleTitlecaseMapping])
|
||||
case "Lt":
|
||||
char.letter(field[FSimpleUppercaseMapping], field[FSimpleLowercaseMapping], field[FCodePoint]);
|
||||
char.letter(field[FSimpleUppercaseMapping], field[FSimpleLowercaseMapping], field[FCodePoint])
|
||||
case "Lm", "Lo":
|
||||
char.letter(field[FSimpleUppercaseMapping], field[FSimpleLowercaseMapping], field[FSimpleTitlecaseMapping]);
|
||||
char.letter(field[FSimpleUppercaseMapping], field[FSimpleLowercaseMapping], field[FSimpleTitlecaseMapping])
|
||||
}
|
||||
switch {
|
||||
case strings.Index(field[FName], ", First>") > 0:
|
||||
state = SFirst;
|
||||
state = SFirst
|
||||
case strings.Index(field[FName], ", Last>") > 0:
|
||||
state = SLast;
|
||||
state = SLast
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
|
@ -190,7 +190,7 @@ func parseCategory(line string) (state State) {
|
|||
func (char *Char) dump(s string) {
|
||||
fmt.Print(s, " ");
|
||||
for i := 0; i < len(char.field); i++ {
|
||||
fmt.Printf("%s:%q ", fieldName[i], char.field[i]);
|
||||
fmt.Printf("%s:%q ", fieldName[i], char.field[i])
|
||||
}
|
||||
fmt.Print("\n");
|
||||
}
|
||||
|
|
@ -203,7 +203,7 @@ func (char *Char) letter(u, l, t string) {
|
|||
|
||||
func (char *Char) letterValue(s string, cas string) int {
|
||||
if s == "" {
|
||||
return 0;
|
||||
return 0
|
||||
}
|
||||
v, err := strconv.Btoui64(s, 16);
|
||||
if err != nil {
|
||||
|
|
@ -239,7 +239,7 @@ func version() string {
|
|||
fields := strings.Split(*url, "/", 0);
|
||||
for _, f := range fields {
|
||||
if len(f) > 0 && '0' <= f[0] && f[0] <= '9' {
|
||||
return f;
|
||||
return f
|
||||
}
|
||||
}
|
||||
die.Log("unknown version");
|
||||
|
|
@ -249,21 +249,21 @@ func version() string {
|
|||
func letterOp(code int) bool {
|
||||
switch chars[code].category {
|
||||
case "Lu", "Ll", "Lt", "Lm", "Lo":
|
||||
return true;
|
||||
return true
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
func loadChars() {
|
||||
if *dataURL == "" {
|
||||
flag.Set("data", *url + "UnicodeData.txt");
|
||||
flag.Set("data", *url + "UnicodeData.txt")
|
||||
}
|
||||
resp, _, err := http.Get(*dataURL);
|
||||
if err != nil {
|
||||
die.Log(err);
|
||||
die.Log(err)
|
||||
}
|
||||
if resp.StatusCode != 200 {
|
||||
die.Log("bad GET status for UnicodeData.txt", resp.Status);
|
||||
die.Log("bad GET status for UnicodeData.txt", resp.Status)
|
||||
}
|
||||
input := bufio.NewReader(resp.Body);
|
||||
var first uint32 = 0;
|
||||
|
|
@ -271,23 +271,23 @@ func loadChars() {
|
|||
line, err := input.ReadString('\n');
|
||||
if err != nil {
|
||||
if err == os.EOF {
|
||||
break;
|
||||
break
|
||||
}
|
||||
die.Log(err);
|
||||
}
|
||||
switch parseCategory(line[0 : len(line)-1]) {
|
||||
case SNormal:
|
||||
if first != 0 {
|
||||
die.Logf("bad state normal at U+%04X", lastChar);
|
||||
die.Logf("bad state normal at U+%04X", lastChar)
|
||||
}
|
||||
case SFirst:
|
||||
if first != 0 {
|
||||
die.Logf("bad state first at U+%04X", lastChar);
|
||||
die.Logf("bad state first at U+%04X", lastChar)
|
||||
}
|
||||
first = lastChar;
|
||||
case SLast:
|
||||
if first == 0 {
|
||||
die.Logf("bad state last at U+%04X", lastChar);
|
||||
die.Logf("bad state last at U+%04X", lastChar)
|
||||
}
|
||||
for i := first+1; i <= lastChar; i++ {
|
||||
chars[i] = chars[first];
|
||||
|
|
@ -301,12 +301,12 @@ func loadChars() {
|
|||
|
||||
func printCategories() {
|
||||
if *tablelist == "" {
|
||||
return;
|
||||
return
|
||||
}
|
||||
// Find out which categories to dump
|
||||
list := strings.Split(*tablelist, ",", 0);
|
||||
if *tablelist == "all" {
|
||||
list = allCategories();
|
||||
list = allCategories()
|
||||
}
|
||||
if *test {
|
||||
fullCategoryTest(list);
|
||||
|
|
@ -327,7 +327,7 @@ func printCategories() {
|
|||
fmt.Println("// Categories is the set of Unicode data tables.");
|
||||
fmt.Println("var Categories = map[string] []Range {");
|
||||
for k, _ := range category {
|
||||
fmt.Printf("\t%q: %s,\n", k, k);
|
||||
fmt.Printf("\t%q: %s,\n", k, k)
|
||||
}
|
||||
fmt.Printf("}\n\n");
|
||||
}
|
||||
|
|
@ -336,7 +336,7 @@ func printCategories() {
|
|||
ndecl := 0;
|
||||
for _, name := range list {
|
||||
if _, ok := category[name]; !ok {
|
||||
die.Log("unknown category", name);
|
||||
die.Log("unknown category", name)
|
||||
}
|
||||
// We generate an UpperCase name to serve as concise documentation and an _UnderScored
|
||||
// name to store the data. This stops godoc dumping all the tables but keeps them
|
||||
|
|
@ -345,20 +345,20 @@ func printCategories() {
|
|||
varDecl := "";
|
||||
switch name {
|
||||
case "letter":
|
||||
varDecl = "\tLetter = letter; // Letter is the set of Unicode letters.\n";
|
||||
varDecl = "\tLetter = letter; // Letter is the set of Unicode letters.\n"
|
||||
case "Nd":
|
||||
varDecl = "\tDigit = _Nd; // Digit is the set of Unicode characters with the \"decimal digit\" property.\n";
|
||||
varDecl = "\tDigit = _Nd; // Digit is the set of Unicode characters with the \"decimal digit\" property.\n"
|
||||
case "Lu":
|
||||
varDecl = "\tUpper = _Lu; // Upper is the set of Unicode upper case letters.\n";
|
||||
varDecl = "\tUpper = _Lu; // Upper is the set of Unicode upper case letters.\n"
|
||||
case "Ll":
|
||||
varDecl = "\tLower = _Ll; // Lower is the set of Unicode lower case letters.\n";
|
||||
varDecl = "\tLower = _Ll; // Lower is the set of Unicode lower case letters.\n"
|
||||
case "Lt":
|
||||
varDecl = "\tTitle = _Lt; // Title is the set of Unicode title case letters.\n";
|
||||
varDecl = "\tTitle = _Lt; // Title is the set of Unicode title case letters.\n"
|
||||
}
|
||||
if name != "letter" {
|
||||
varDecl += fmt.Sprintf(
|
||||
"\t%s = _%s; // %s is the set of Unicode characters in category %s.\n",
|
||||
name, name, name, name);
|
||||
name, name, name, name)
|
||||
}
|
||||
decl[ndecl] = varDecl;
|
||||
ndecl++;
|
||||
|
|
@ -375,7 +375,7 @@ func printCategories() {
|
|||
decl.Sort();
|
||||
fmt.Println("var (");
|
||||
for _, d := range decl {
|
||||
fmt.Print(d);
|
||||
fmt.Print(d)
|
||||
}
|
||||
fmt.Println(")\n");
|
||||
}
|
||||
|
|
@ -391,11 +391,11 @@ func dumpRange(header string, inCategory Op) {
|
|||
for {
|
||||
// look for start of range
|
||||
for next < len(chars) && !inCategory(next) {
|
||||
next++;
|
||||
next++
|
||||
}
|
||||
if next >= len(chars) {
|
||||
// no characters remain
|
||||
break;
|
||||
break
|
||||
}
|
||||
|
||||
// start of range
|
||||
|
|
@ -406,7 +406,7 @@ func dumpRange(header string, inCategory Op) {
|
|||
next++;
|
||||
// look for another character to set the stride
|
||||
for next < len(chars) && !inCategory(next) {
|
||||
next++;
|
||||
next++
|
||||
}
|
||||
if next >= len(chars) {
|
||||
// no more characters
|
||||
|
|
@ -420,11 +420,11 @@ func dumpRange(header string, inCategory Op) {
|
|||
if inCategory(i) == (((i-lo)%stride) == 0) {
|
||||
// accept
|
||||
if inCategory(i) {
|
||||
hi = i;
|
||||
hi = i
|
||||
}
|
||||
} else {
|
||||
// no more characters in this run
|
||||
break;
|
||||
break
|
||||
}
|
||||
}
|
||||
fmt.Printf(format, lo, hi, stride);
|
||||
|
|
@ -437,19 +437,19 @@ func dumpRange(header string, inCategory Op) {
|
|||
func fullCategoryTest(list []string) {
|
||||
for _, name := range list {
|
||||
if _, ok := category[name]; !ok {
|
||||
die.Log("unknown category", name);
|
||||
die.Log("unknown category", name)
|
||||
}
|
||||
r, ok := unicode.Categories[name];
|
||||
if !ok {
|
||||
die.Log("unknown table", name);
|
||||
die.Log("unknown table", name)
|
||||
}
|
||||
if name == "letter" {
|
||||
verifyRange(name, letterOp, r);
|
||||
verifyRange(name, letterOp, r)
|
||||
} else {
|
||||
verifyRange(
|
||||
name,
|
||||
func(code int) bool { return chars[code].category == name },
|
||||
r);
|
||||
r)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -459,7 +459,7 @@ func verifyRange(name string, inCategory Op, table []unicode.Range) {
|
|||
web := inCategory(i);
|
||||
pkg := unicode.Is(table, i);
|
||||
if web != pkg {
|
||||
fmt.Fprintf(os.Stderr, "%s: U+%04X: web=%t pkg=%t\n", name, i, web, pkg);
|
||||
fmt.Fprintf(os.Stderr, "%s: U+%04X: web=%t pkg=%t\n", name, i, web, pkg)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -467,29 +467,29 @@ func verifyRange(name string, inCategory Op, table []unicode.Range) {
|
|||
func parseScript(line string, scripts map[string][]Script) {
|
||||
comment := strings.Index(line, "#");
|
||||
if comment >= 0 {
|
||||
line = line[0:comment];
|
||||
line = line[0:comment]
|
||||
}
|
||||
line = strings.TrimSpace(line);
|
||||
if len(line) == 0 {
|
||||
return;
|
||||
return
|
||||
}
|
||||
field := strings.Split(line, ";", -1);
|
||||
if len(field) != 2 {
|
||||
die.Logf("%s: %d fields (expected 2)\n", line, len(field));
|
||||
die.Logf("%s: %d fields (expected 2)\n", line, len(field))
|
||||
}
|
||||
matches := scriptRe.MatchStrings(line);
|
||||
if len(matches) != 4 {
|
||||
die.Logf("%s: %d matches (expected 3)\n", line, len(matches));
|
||||
die.Logf("%s: %d matches (expected 3)\n", line, len(matches))
|
||||
}
|
||||
lo, err := strconv.Btoui64(matches[1], 16);
|
||||
if err != nil {
|
||||
die.Log("%.5s...:", err);
|
||||
die.Log("%.5s...:", err)
|
||||
}
|
||||
hi := lo;
|
||||
if len(matches[2]) > 2 { // ignore leading ..
|
||||
hi, err = strconv.Btoui64(matches[2][2:len(matches[2])], 16);
|
||||
if err != nil {
|
||||
die.Log("%.5s...:", err);
|
||||
die.Log("%.5s...:", err)
|
||||
}
|
||||
}
|
||||
name := matches[3];
|
||||
|
|
@ -497,7 +497,7 @@ func parseScript(line string, scripts map[string][]Script) {
|
|||
if !ok || len(s) == cap(s) {
|
||||
ns := make([]Script, len(s), len(s)+100);
|
||||
for i, sc := range s {
|
||||
ns[i] = sc;
|
||||
ns[i] = sc
|
||||
}
|
||||
s = ns;
|
||||
}
|
||||
|
|
@ -512,7 +512,7 @@ func foldAdjacent(r []Script) []unicode.Range {
|
|||
j := 0;
|
||||
for i := 0; i < len(r); i++ {
|
||||
if j > 0 && int(r[i].lo) == s[j-1].Hi + 1 {
|
||||
s[j-1].Hi = int(r[i].hi);
|
||||
s[j-1].Hi = int(r[i].hi)
|
||||
} else {
|
||||
s = s[0 : j+1];
|
||||
s[j] = unicode.Range{int(r[i].lo), int(r[i].hi), 1};
|
||||
|
|
@ -525,16 +525,16 @@ func foldAdjacent(r []Script) []unicode.Range {
|
|||
func fullScriptTest(list []string, installed map[string][]unicode.Range, scripts map[string][]Script) {
|
||||
for _, name := range list {
|
||||
if _, ok := scripts[name]; !ok {
|
||||
die.Log("unknown script", name);
|
||||
die.Log("unknown script", name)
|
||||
}
|
||||
_, ok := installed[name];
|
||||
if !ok {
|
||||
die.Log("unknown table", name);
|
||||
die.Log("unknown table", name)
|
||||
}
|
||||
for _, script := range scripts[name] {
|
||||
for r := script.lo; r <= script.hi; r++ {
|
||||
if !unicode.Is(installed[name], int(r)) {
|
||||
fmt.Fprintf(os.Stderr, "U+%04X: not in script %s\n", r, name);
|
||||
fmt.Fprintf(os.Stderr, "U+%04X: not in script %s\n", r, name)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -556,22 +556,22 @@ func printScriptOrProperty(doProps bool) {
|
|||
installed = unicode.Properties;
|
||||
}
|
||||
if flaglist == "" {
|
||||
return;
|
||||
return
|
||||
}
|
||||
var err os.Error;
|
||||
resp, _, err := http.Get(*url + file);
|
||||
if err != nil {
|
||||
die.Log(err);
|
||||
die.Log(err)
|
||||
}
|
||||
if resp.StatusCode != 200 {
|
||||
die.Log("bad GET status for ", file, ":", resp.Status);
|
||||
die.Log("bad GET status for ", file, ":", resp.Status)
|
||||
}
|
||||
input := bufio.NewReader(resp.Body);
|
||||
for {
|
||||
line, err := input.ReadString('\n');
|
||||
if err != nil {
|
||||
if err == os.EOF {
|
||||
break;
|
||||
break
|
||||
}
|
||||
die.Log(err);
|
||||
}
|
||||
|
|
@ -582,7 +582,7 @@ func printScriptOrProperty(doProps bool) {
|
|||
// Find out which scripts to dump
|
||||
list := strings.Split(flaglist, ",", 0);
|
||||
if flaglist == "all" {
|
||||
list = all(table);
|
||||
list = all(table)
|
||||
}
|
||||
if *test {
|
||||
fullScriptTest(list, installed, table);
|
||||
|
|
@ -605,7 +605,7 @@ func printScriptOrProperty(doProps bool) {
|
|||
fmt.Println("var Scripts = map[string] []Range {");
|
||||
}
|
||||
for k, _ := range table {
|
||||
fmt.Printf("\t%q: %s,\n", k, k);
|
||||
fmt.Printf("\t%q: %s,\n", k, k)
|
||||
}
|
||||
fmt.Printf("}\n\n");
|
||||
}
|
||||
|
|
@ -616,24 +616,24 @@ func printScriptOrProperty(doProps bool) {
|
|||
if doProps {
|
||||
decl[ndecl] = fmt.Sprintf(
|
||||
"\t%s = _%s;\t// %s is the set of Unicode characters with property %s.\n",
|
||||
name, name, name, name);
|
||||
name, name, name, name)
|
||||
} else {
|
||||
decl[ndecl] = fmt.Sprintf(
|
||||
"\t%s = _%s;\t// %s is the set of Unicode characters in script %s.\n",
|
||||
name, name, name, name);
|
||||
name, name, name, name)
|
||||
}
|
||||
ndecl++;
|
||||
fmt.Printf("var _%s = []Range {\n", name);
|
||||
ranges := foldAdjacent(table[name]);
|
||||
for _, s := range ranges {
|
||||
fmt.Printf(format, s.Lo, s.Hi, s.Stride);
|
||||
fmt.Printf(format, s.Lo, s.Hi, s.Stride)
|
||||
}
|
||||
fmt.Printf("}\n\n");
|
||||
}
|
||||
decl.Sort();
|
||||
fmt.Println("var (");
|
||||
for _, d := range decl {
|
||||
fmt.Print(d);
|
||||
fmt.Print(d)
|
||||
}
|
||||
fmt.Println(")\n");
|
||||
}
|
||||
|
|
@ -657,23 +657,23 @@ type caseState struct {
|
|||
// Is d a continuation of the state of c?
|
||||
func (c *caseState) adjacent(d *caseState) bool {
|
||||
if d.point < c.point {
|
||||
c, d = d, c;
|
||||
c, d = d, c
|
||||
}
|
||||
switch {
|
||||
case d.point != c.point + 1: // code points not adjacent (shouldn't happen)
|
||||
return false;
|
||||
return false
|
||||
case d._case != c._case: // different cases
|
||||
return c.upperLowerAdjacent(d);
|
||||
return c.upperLowerAdjacent(d)
|
||||
case c._case == CaseNone:
|
||||
return false;
|
||||
return false
|
||||
case c._case == CaseMissing:
|
||||
return false;
|
||||
return false
|
||||
case d.deltaToUpper != c.deltaToUpper:
|
||||
return false;
|
||||
return false
|
||||
case d.deltaToLower != c.deltaToLower:
|
||||
return false;
|
||||
return false
|
||||
case d.deltaToTitle != c.deltaToTitle:
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
|
@ -684,30 +684,30 @@ func (c *caseState) upperLowerAdjacent(d *caseState) bool {
|
|||
// check they're a matched case pair. we know they have adjacent values
|
||||
switch {
|
||||
case c._case == CaseUpper && d._case != CaseLower:
|
||||
return false;
|
||||
return false
|
||||
case c._case == CaseLower && d._case != CaseUpper:
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
// matched pair (at least in upper/lower). make the order Upper Lower
|
||||
if c._case == CaseLower {
|
||||
c, d = d, c;
|
||||
c, d = d, c
|
||||
}
|
||||
// for an Upper Lower sequence the deltas have to be in order
|
||||
// c: 0 1 0
|
||||
// d: -1 0 -1
|
||||
switch {
|
||||
case c.deltaToUpper != 0:
|
||||
return false;
|
||||
return false
|
||||
case c.deltaToLower != 1:
|
||||
return false;
|
||||
return false
|
||||
case c.deltaToTitle != 0:
|
||||
return false;
|
||||
return false
|
||||
case d.deltaToUpper != -1:
|
||||
return false;
|
||||
return false
|
||||
case d.deltaToLower != 0:
|
||||
return false;
|
||||
return false
|
||||
case d.deltaToTitle != -1:
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
|
@ -718,11 +718,11 @@ func (c *caseState) isUpperLower() bool {
|
|||
// c: 0 1 0
|
||||
switch {
|
||||
case c.deltaToUpper != 0:
|
||||
return false;
|
||||
return false
|
||||
case c.deltaToLower != 1:
|
||||
return false;
|
||||
return false
|
||||
case c.deltaToTitle != 0:
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
|
@ -733,11 +733,11 @@ func (c *caseState) isLowerUpper() bool {
|
|||
// c: -1 0 -1
|
||||
switch {
|
||||
case c.deltaToUpper != -1:
|
||||
return false;
|
||||
return false
|
||||
case c.deltaToLower != 0:
|
||||
return false;
|
||||
return false
|
||||
case c.deltaToTitle != -1:
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
|
@ -750,27 +750,27 @@ func getCaseState(i int) (c *caseState) {
|
|||
c._case = CaseMissing; // Will get NUL wrong but that doesn't matter
|
||||
return;
|
||||
case ch.upperCase:
|
||||
c._case = CaseUpper;
|
||||
c._case = CaseUpper
|
||||
case ch.lowerCase:
|
||||
c._case = CaseLower;
|
||||
c._case = CaseLower
|
||||
case ch.titleCase:
|
||||
c._case = CaseTitle;
|
||||
c._case = CaseTitle
|
||||
}
|
||||
if ch.upperCase != 0 {
|
||||
c.deltaToUpper = ch.upperCase - i;
|
||||
c.deltaToUpper = ch.upperCase - i
|
||||
}
|
||||
if ch.lowerCase != 0 {
|
||||
c.deltaToLower = ch.lowerCase - i;
|
||||
c.deltaToLower = ch.lowerCase - i
|
||||
}
|
||||
if ch.titleCase != 0 {
|
||||
c.deltaToTitle = ch.titleCase - i;
|
||||
c.deltaToTitle = ch.titleCase - i
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
func printCases() {
|
||||
if !*cases {
|
||||
return;
|
||||
return
|
||||
}
|
||||
if *test {
|
||||
fullCaseTest();
|
||||
|
|
@ -798,7 +798,7 @@ func printCases() {
|
|||
printCaseRange(startState, prevState);
|
||||
startState = nil;
|
||||
if state._case != CaseMissing && state._case != CaseNone {
|
||||
startState = state;
|
||||
startState = state
|
||||
}
|
||||
prevState = state;
|
||||
}
|
||||
|
|
@ -807,16 +807,16 @@ func printCases() {
|
|||
|
||||
func printCaseRange(lo, hi *caseState) {
|
||||
if lo == nil {
|
||||
return;
|
||||
return
|
||||
}
|
||||
if lo.deltaToUpper == 0 && lo.deltaToLower == 0 && lo.deltaToTitle == 0 {
|
||||
// character represents itself in all cases - no need to mention it
|
||||
return;
|
||||
return
|
||||
}
|
||||
switch {
|
||||
case hi.point > lo.point && lo.isUpperLower():
|
||||
fmt.Printf("\tCaseRange{0x%04X, 0x%04X, d{UpperLower, UpperLower, UpperLower}},\n",
|
||||
lo.point, hi.point);
|
||||
lo.point, hi.point)
|
||||
case hi.point > lo.point && lo.isLowerUpper():
|
||||
die.Log("LowerUpper sequence: should not happen: U+%04X. If it's real, need to fix To()", lo.point);
|
||||
fmt.Printf("\tCaseRange{0x%04X, 0x%04X, d{LowerUpper, LowerUpper, LowerUpper}},\n",
|
||||
|
|
@ -824,14 +824,14 @@ func printCaseRange(lo, hi *caseState) {
|
|||
default:
|
||||
fmt.Printf("\tCaseRange{0x%04X, 0x%04X, d{%d, %d, %d}},\n",
|
||||
lo.point, hi.point,
|
||||
lo.deltaToUpper, lo.deltaToLower, lo.deltaToTitle);
|
||||
lo.deltaToUpper, lo.deltaToLower, lo.deltaToTitle)
|
||||
}
|
||||
}
|
||||
|
||||
// If the cased value in the Char is 0, it means use the rune itself.
|
||||
func caseIt(rune, cased int) int {
|
||||
if cased == 0 {
|
||||
return rune;
|
||||
return rune
|
||||
}
|
||||
return cased;
|
||||
}
|
||||
|
|
@ -841,17 +841,17 @@ func fullCaseTest() {
|
|||
lower := unicode.ToLower(i);
|
||||
want := caseIt(i, c.lowerCase);
|
||||
if lower != want {
|
||||
fmt.Fprintf(os.Stderr, "lower U+%04X should be U+%04X is U+%04X\n", i, want, lower);
|
||||
fmt.Fprintf(os.Stderr, "lower U+%04X should be U+%04X is U+%04X\n", i, want, lower)
|
||||
}
|
||||
upper := unicode.ToUpper(i);
|
||||
want = caseIt(i, c.upperCase);
|
||||
if upper != want {
|
||||
fmt.Fprintf(os.Stderr, "upper U+%04X should be U+%04X is U+%04X\n", i, want, upper);
|
||||
fmt.Fprintf(os.Stderr, "upper U+%04X should be U+%04X is U+%04X\n", i, want, upper)
|
||||
}
|
||||
title := unicode.ToTitle(i);
|
||||
want = caseIt(i, c.titleCase);
|
||||
if title != want {
|
||||
fmt.Fprintf(os.Stderr, "title U+%04X should be U+%04X is U+%04X\n", i, want, title);
|
||||
fmt.Fprintf(os.Stderr, "title U+%04X should be U+%04X is U+%04X\n", i, want, title)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue