map.go

Documentation: cmd/vendor/golang.org/x/text/cases

     1  // Copyright 2014 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  package cases
     6  
     7  // This file contains the definitions of case mappings for all supported
     8  // languages. The rules for the language-specific tailorings were taken and
     9  // modified from the CLDR transform definitions in common/transforms.
    10  
    11  import (
    12  	"strings"
    13  	"unicode"
    14  	"unicode/utf8"
    15  
    16  	"golang.org/x/text/internal"
    17  	"golang.org/x/text/language"
    18  	"golang.org/x/text/transform"
    19  	"golang.org/x/text/unicode/norm"
    20  )
    21  
    22  // A mapFunc takes a context set to the current rune and writes the mapped
    23  // version to the same context. It may advance the context to the next rune. It
    24  // returns whether a checkpoint is possible: whether the pDst bytes written to
    25  // dst so far won't need changing as we see more source bytes.
    26  type mapFunc func(*context) bool
    27  
    28  // A spanFunc takes a context set to the current rune and returns whether this
    29  // rune would be altered when written to the output. It may advance the context
    30  // to the next rune. It returns whether a checkpoint is possible.
    31  type spanFunc func(*context) bool
    32  
    33  // maxIgnorable defines the maximum number of ignorables to consider for
    34  // lookahead operations.
    35  const maxIgnorable = 30
    36  
    37  // supported lists the language tags for which we have tailorings.
    38  const supported = "und af az el lt nl tr"
    39  
    40  func init() {
    41  	tags := []language.Tag{}
    42  	for _, s := range strings.Split(supported, " ") {
    43  		tags = append(tags, language.MustParse(s))
    44  	}
    45  	matcher = internal.NewInheritanceMatcher(tags)
    46  	Supported = language.NewCoverage(tags)
    47  }
    48  
    49  var (
    50  	matcher *internal.InheritanceMatcher
    51  
    52  	Supported language.Coverage
    53  
    54  	// We keep the following lists separate, instead of having a single per-
    55  	// language struct, to give the compiler a chance to remove unused code.
    56  
    57  	// Some uppercase mappers are stateless, so we can precompute the
    58  	// Transformers and save a bit on runtime allocations.
    59  	upperFunc = []struct {
    60  		upper mapFunc
    61  		span  spanFunc
    62  	}{
    63  		{nil, nil},                  // und
    64  		{nil, nil},                  // af
    65  		{aztrUpper(upper), isUpper}, // az
    66  		{elUpper, noSpan},           // el
    67  		{ltUpper(upper), noSpan},    // lt
    68  		{nil, nil},                  // nl
    69  		{aztrUpper(upper), isUpper}, // tr
    70  	}
    71  
    72  	undUpper            transform.SpanningTransformer = &undUpperCaser{}
    73  	undLower            transform.SpanningTransformer = &undLowerCaser{}
    74  	undLowerIgnoreSigma transform.SpanningTransformer = &undLowerIgnoreSigmaCaser{}
    75  
    76  	lowerFunc = []mapFunc{
    77  		nil,       // und
    78  		nil,       // af
    79  		aztrLower, // az
    80  		nil,       // el
    81  		ltLower,   // lt
    82  		nil,       // nl
    83  		aztrLower, // tr
    84  	}
    85  
    86  	titleInfos = []struct {
    87  		title     mapFunc
    88  		lower     mapFunc
    89  		titleSpan spanFunc
    90  		rewrite   func(*context)
    91  	}{
    92  		{title, lower, isTitle, nil},                // und
    93  		{title, lower, isTitle, afnlRewrite},        // af
    94  		{aztrUpper(title), aztrLower, isTitle, nil}, // az
    95  		{title, lower, isTitle, nil},                // el
    96  		{ltUpper(title), ltLower, noSpan, nil},      // lt
    97  		{nlTitle, lower, nlTitleSpan, afnlRewrite},  // nl
    98  		{aztrUpper(title), aztrLower, isTitle, nil}, // tr
    99  	}
   100  )
   101  
   102  func makeUpper(t language.Tag, o options) transform.SpanningTransformer {
   103  	_, i, _ := matcher.Match(t)
   104  	f := upperFunc[i].upper
   105  	if f == nil {
   106  		return undUpper
   107  	}
   108  	return &simpleCaser{f: f, span: upperFunc[i].span}
   109  }
   110  
   111  func makeLower(t language.Tag, o options) transform.SpanningTransformer {
   112  	_, i, _ := matcher.Match(t)
   113  	f := lowerFunc[i]
   114  	if f == nil {
   115  		if o.ignoreFinalSigma {
   116  			return undLowerIgnoreSigma
   117  		}
   118  		return undLower
   119  	}
   120  	if o.ignoreFinalSigma {
   121  		return &simpleCaser{f: f, span: isLower}
   122  	}
   123  	return &lowerCaser{
   124  		first:   f,
   125  		midWord: finalSigma(f),
   126  	}
   127  }
   128  
   129  func makeTitle(t language.Tag, o options) transform.SpanningTransformer {
   130  	_, i, _ := matcher.Match(t)
   131  	x := &titleInfos[i]
   132  	lower := x.lower
   133  	if o.noLower {
   134  		lower = (*context).copy
   135  	} else if !o.ignoreFinalSigma {
   136  		lower = finalSigma(lower)
   137  	}
   138  	return &titleCaser{
   139  		title:     x.title,
   140  		lower:     lower,
   141  		titleSpan: x.titleSpan,
   142  		rewrite:   x.rewrite,
   143  	}
   144  }
   145  
   146  func noSpan(c *context) bool {
   147  	c.err = transform.ErrEndOfSpan
   148  	return false
   149  }
   150  
   151  // TODO: consider a similar special case for the fast majority lower case. This
   152  // is a bit more involved so will require some more precise benchmarking to
   153  // justify it.
   154  
   155  type undUpperCaser struct{ transform.NopResetter }
   156  
   157  // undUpperCaser implements the Transformer interface for doing an upper case
   158  // mapping for the root locale (und). It eliminates the need for an allocation
   159  // as it prevents escaping by not using function pointers.
   160  func (t undUpperCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
   161  	c := context{dst: dst, src: src, atEOF: atEOF}
   162  	for c.next() {
   163  		upper(&c)
   164  		c.checkpoint()
   165  	}
   166  	return c.ret()
   167  }
   168  
   169  func (t undUpperCaser) Span(src []byte, atEOF bool) (n int, err error) {
   170  	c := context{src: src, atEOF: atEOF}
   171  	for c.next() && isUpper(&c) {
   172  		c.checkpoint()
   173  	}
   174  	return c.retSpan()
   175  }
   176  
   177  // undLowerIgnoreSigmaCaser implements the Transformer interface for doing
   178  // a lower case mapping for the root locale (und) ignoring final sigma
   179  // handling. This casing algorithm is used in some performance-critical packages
   180  // like secure/precis and x/net/http/idna, which warrants its special-casing.
   181  type undLowerIgnoreSigmaCaser struct{ transform.NopResetter }
   182  
   183  func (t undLowerIgnoreSigmaCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
   184  	c := context{dst: dst, src: src, atEOF: atEOF}
   185  	for c.next() && lower(&c) {
   186  		c.checkpoint()
   187  	}
   188  	return c.ret()
   189  
   190  }
   191  
   192  // Span implements a generic lower-casing. This is possible as isLower works
   193  // for all lowercasing variants. All lowercase variants only vary in how they
   194  // transform a non-lowercase letter. They will never change an already lowercase
   195  // letter. In addition, there is no state.
   196  func (t undLowerIgnoreSigmaCaser) Span(src []byte, atEOF bool) (n int, err error) {
   197  	c := context{src: src, atEOF: atEOF}
   198  	for c.next() && isLower(&c) {
   199  		c.checkpoint()
   200  	}
   201  	return c.retSpan()
   202  }
   203  
   204  type simpleCaser struct {
   205  	context
   206  	f    mapFunc
   207  	span spanFunc
   208  }
   209  
   210  // simpleCaser implements the Transformer interface for doing a case operation
   211  // on a rune-by-rune basis.
   212  func (t *simpleCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
   213  	c := context{dst: dst, src: src, atEOF: atEOF}
   214  	for c.next() && t.f(&c) {
   215  		c.checkpoint()
   216  	}
   217  	return c.ret()
   218  }
   219  
   220  func (t *simpleCaser) Span(src []byte, atEOF bool) (n int, err error) {
   221  	c := context{src: src, atEOF: atEOF}
   222  	for c.next() && t.span(&c) {
   223  		c.checkpoint()
   224  	}
   225  	return c.retSpan()
   226  }
   227  
   228  // undLowerCaser implements the Transformer interface for doing a lower case
   229  // mapping for the root locale (und) ignoring final sigma handling. This casing
   230  // algorithm is used in some performance-critical packages like secure/precis
   231  // and x/net/http/idna, which warrants its special-casing.
   232  type undLowerCaser struct{ transform.NopResetter }
   233  
   234  func (t undLowerCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
   235  	c := context{dst: dst, src: src, atEOF: atEOF}
   236  
   237  	for isInterWord := true; c.next(); {
   238  		if isInterWord {
   239  			if c.info.isCased() {
   240  				if !lower(&c) {
   241  					break
   242  				}
   243  				isInterWord = false
   244  			} else if !c.copy() {
   245  				break
   246  			}
   247  		} else {
   248  			if c.info.isNotCasedAndNotCaseIgnorable() {
   249  				if !c.copy() {
   250  					break
   251  				}
   252  				isInterWord = true
   253  			} else if !c.hasPrefix("Σ") {
   254  				if !lower(&c) {
   255  					break
   256  				}
   257  			} else if !finalSigmaBody(&c) {
   258  				break
   259  			}
   260  		}
   261  		c.checkpoint()
   262  	}
   263  	return c.ret()
   264  }
   265  
   266  func (t undLowerCaser) Span(src []byte, atEOF bool) (n int, err error) {
   267  	c := context{src: src, atEOF: atEOF}
   268  	for c.next() && isLower(&c) {
   269  		c.checkpoint()
   270  	}
   271  	return c.retSpan()
   272  }
   273  
   274  // lowerCaser implements the Transformer interface. The default Unicode lower
   275  // casing requires different treatment for the first and subsequent characters
   276  // of a word, most notably to handle the Greek final Sigma.
   277  type lowerCaser struct {
   278  	undLowerIgnoreSigmaCaser
   279  
   280  	context
   281  
   282  	first, midWord mapFunc
   283  }
   284  
   285  func (t *lowerCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
   286  	t.context = context{dst: dst, src: src, atEOF: atEOF}
   287  	c := &t.context
   288  
   289  	for isInterWord := true; c.next(); {
   290  		if isInterWord {
   291  			if c.info.isCased() {
   292  				if !t.first(c) {
   293  					break
   294  				}
   295  				isInterWord = false
   296  			} else if !c.copy() {
   297  				break
   298  			}
   299  		} else {
   300  			if c.info.isNotCasedAndNotCaseIgnorable() {
   301  				if !c.copy() {
   302  					break
   303  				}
   304  				isInterWord = true
   305  			} else if !t.midWord(c) {
   306  				break
   307  			}
   308  		}
   309  		c.checkpoint()
   310  	}
   311  	return c.ret()
   312  }
   313  
   314  // titleCaser implements the Transformer interface. Title casing algorithms
   315  // distinguish between the first letter of a word and subsequent letters of the
   316  // same word. It uses state to avoid requiring a potentially infinite lookahead.
   317  type titleCaser struct {
   318  	context
   319  
   320  	// rune mappings used by the actual casing algorithms.
   321  	title     mapFunc
   322  	lower     mapFunc
   323  	titleSpan spanFunc
   324  
   325  	rewrite func(*context)
   326  }
   327  
   328  // Transform implements the standard Unicode title case algorithm as defined in
   329  // Chapter 3 of The Unicode Standard:
   330  // toTitlecase(X): Find the word boundaries in X according to Unicode Standard
   331  // Annex #29, "Unicode Text Segmentation." For each word boundary, find the
   332  // first cased character F following the word boundary. If F exists, map F to
   333  // Titlecase_Mapping(F); then map all characters C between F and the following
   334  // word boundary to Lowercase_Mapping(C).
   335  func (t *titleCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
   336  	t.context = context{dst: dst, src: src, atEOF: atEOF, isMidWord: t.isMidWord}
   337  	c := &t.context
   338  
   339  	if !c.next() {
   340  		return c.ret()
   341  	}
   342  
   343  	for {
   344  		p := c.info
   345  		if t.rewrite != nil {
   346  			t.rewrite(c)
   347  		}
   348  
   349  		wasMid := p.isMid()
   350  		// Break out of this loop on failure to ensure we do not modify the
   351  		// state incorrectly.
   352  		if p.isCased() {
   353  			if !c.isMidWord {
   354  				if !t.title(c) {
   355  					break
   356  				}
   357  				c.isMidWord = true
   358  			} else if !t.lower(c) {
   359  				break
   360  			}
   361  		} else if !c.copy() {
   362  			break
   363  		} else if p.isBreak() {
   364  			c.isMidWord = false
   365  		}
   366  
   367  		// As we save the state of the transformer, it is safe to call
   368  		// checkpoint after any successful write.
   369  		if !(c.isMidWord && wasMid) {
   370  			c.checkpoint()
   371  		}
   372  
   373  		if !c.next() {
   374  			break
   375  		}
   376  		if wasMid && c.info.isMid() {
   377  			c.isMidWord = false
   378  		}
   379  	}
   380  	return c.ret()
   381  }
   382  
   383  func (t *titleCaser) Span(src []byte, atEOF bool) (n int, err error) {
   384  	t.context = context{src: src, atEOF: atEOF, isMidWord: t.isMidWord}
   385  	c := &t.context
   386  
   387  	if !c.next() {
   388  		return c.retSpan()
   389  	}
   390  
   391  	for {
   392  		p := c.info
   393  		if t.rewrite != nil {
   394  			t.rewrite(c)
   395  		}
   396  
   397  		wasMid := p.isMid()
   398  		// Break out of this loop on failure to ensure we do not modify the
   399  		// state incorrectly.
   400  		if p.isCased() {
   401  			if !c.isMidWord {
   402  				if !t.titleSpan(c) {
   403  					break
   404  				}
   405  				c.isMidWord = true
   406  			} else if !isLower(c) {
   407  				break
   408  			}
   409  		} else if p.isBreak() {
   410  			c.isMidWord = false
   411  		}
   412  		// As we save the state of the transformer, it is safe to call
   413  		// checkpoint after any successful write.
   414  		if !(c.isMidWord && wasMid) {
   415  			c.checkpoint()
   416  		}
   417  
   418  		if !c.next() {
   419  			break
   420  		}
   421  		if wasMid && c.info.isMid() {
   422  			c.isMidWord = false
   423  		}
   424  	}
   425  	return c.retSpan()
   426  }
   427  
   428  // finalSigma adds Greek final Sigma handing to another casing function. It
   429  // determines whether a lowercased sigma should be σ or ς, by looking ahead for
   430  // case-ignorables and a cased letters.
   431  func finalSigma(f mapFunc) mapFunc {
   432  	return func(c *context) bool {
   433  		if !c.hasPrefix("Σ") {
   434  			return f(c)
   435  		}
   436  		return finalSigmaBody(c)
   437  	}
   438  }
   439  
   440  func finalSigmaBody(c *context) bool {
   441  	// Current rune must be ∑.
   442  
   443  	// ::NFD();
   444  	// # 03A3; 03C2; 03A3; 03A3; Final_Sigma; # GREEK CAPITAL LETTER SIGMA
   445  	// Σ } [:case-ignorable:]* [:cased:] → σ;
   446  	// [:cased:] [:case-ignorable:]* { Σ → ς;
   447  	// ::Any-Lower;
   448  	// ::NFC();
   449  
   450  	p := c.pDst
   451  	c.writeString("ς")
   452  
   453  	// TODO: we should do this here, but right now this will never have an
   454  	// effect as this is called when the prefix is Sigma, whereas Dutch and
   455  	// Afrikaans only test for an apostrophe.
   456  	//
   457  	// if t.rewrite != nil {
   458  	// 	t.rewrite(c)
   459  	// }
   460  
   461  	// We need to do one more iteration after maxIgnorable, as a cased
   462  	// letter is not an ignorable and may modify the result.
   463  	wasMid := false
   464  	for i := 0; i < maxIgnorable+1; i++ {
   465  		if !c.next() {
   466  			return false
   467  		}
   468  		if !c.info.isCaseIgnorable() {
   469  			// All Midword runes are also case ignorable, so we are
   470  			// guaranteed to have a letter or word break here. As we are
   471  			// unreading the run, there is no need to unset c.isMidWord;
   472  			// the title caser will handle this.
   473  			if c.info.isCased() {
   474  				// p+1 is guaranteed to be in bounds: if writing ς was
   475  				// successful, p+1 will contain the second byte of ς. If not,
   476  				// this function will have returned after c.next returned false.
   477  				c.dst[p+1]++ // ς → σ
   478  			}
   479  			c.unreadRune()
   480  			return true
   481  		}
   482  		// A case ignorable may also introduce a word break, so we may need
   483  		// to continue searching even after detecting a break.
   484  		isMid := c.info.isMid()
   485  		if (wasMid && isMid) || c.info.isBreak() {
   486  			c.isMidWord = false
   487  		}
   488  		wasMid = isMid
   489  		c.copy()
   490  	}
   491  	return true
   492  }
   493  
   494  // finalSigmaSpan would be the same as isLower.
   495  
   496  // elUpper implements Greek upper casing, which entails removing a predefined
   497  // set of non-blocked modifiers. Note that these accents should not be removed
   498  // for title casing!
   499  // Example: "Οδός" -> "ΟΔΟΣ".
   500  func elUpper(c *context) bool {
   501  	// From CLDR:
   502  	// [:Greek:] [^[:ccc=Not_Reordered:][:ccc=Above:]]*? { [\u0313\u0314\u0301\u0300\u0306\u0342\u0308\u0304] → ;
   503  	// [:Greek:] [^[:ccc=Not_Reordered:][:ccc=Iota_Subscript:]]*? { \u0345 → ;
   504  
   505  	r, _ := utf8.DecodeRune(c.src[c.pSrc:])
   506  	oldPDst := c.pDst
   507  	if !upper(c) {
   508  		return false
   509  	}
   510  	if !unicode.Is(unicode.Greek, r) {
   511  		return true
   512  	}
   513  	i := 0
   514  	// Take the properties of the uppercased rune that is already written to the
   515  	// destination. This saves us the trouble of having to uppercase the
   516  	// decomposed rune again.
   517  	if b := norm.NFD.Properties(c.dst[oldPDst:]).Decomposition(); b != nil {
   518  		// Restore the destination position and process the decomposed rune.
   519  		r, sz := utf8.DecodeRune(b)
   520  		if r <= 0xFF { // See A.6.1
   521  			return true
   522  		}
   523  		c.pDst = oldPDst
   524  		// Insert the first rune and ignore the modifiers. See A.6.2.
   525  		c.writeBytes(b[:sz])
   526  		i = len(b[sz:]) / 2 // Greek modifiers are always of length 2.
   527  	}
   528  
   529  	for ; i < maxIgnorable && c.next(); i++ {
   530  		switch r, _ := utf8.DecodeRune(c.src[c.pSrc:]); r {
   531  		// Above and Iota Subscript
   532  		case 0x0300, // U+0300 COMBINING GRAVE ACCENT
   533  			0x0301, // U+0301 COMBINING ACUTE ACCENT
   534  			0x0304, // U+0304 COMBINING MACRON
   535  			0x0306, // U+0306 COMBINING BREVE
   536  			0x0308, // U+0308 COMBINING DIAERESIS
   537  			0x0313, // U+0313 COMBINING COMMA ABOVE
   538  			0x0314, // U+0314 COMBINING REVERSED COMMA ABOVE
   539  			0x0342, // U+0342 COMBINING GREEK PERISPOMENI
   540  			0x0345: // U+0345 COMBINING GREEK YPOGEGRAMMENI
   541  			// No-op. Gobble the modifier.
   542  
   543  		default:
   544  			switch v, _ := trie.lookup(c.src[c.pSrc:]); info(v).cccType() {
   545  			case cccZero:
   546  				c.unreadRune()
   547  				return true
   548  
   549  			// We don't need to test for IotaSubscript as the only rune that
   550  			// qualifies (U+0345) was already excluded in the switch statement
   551  			// above. See A.4.
   552  
   553  			case cccAbove:
   554  				return c.copy()
   555  			default:
   556  				// Some other modifier. We're still allowed to gobble Greek
   557  				// modifiers after this.
   558  				c.copy()
   559  			}
   560  		}
   561  	}
   562  	return i == maxIgnorable
   563  }
   564  
   565  // TODO: implement elUpperSpan (low-priority: complex and infrequent).
   566  
   567  func ltLower(c *context) bool {
   568  	// From CLDR:
   569  	// # Introduce an explicit dot above when lowercasing capital I's and J's
   570  	// # whenever there are more accents above.
   571  	// # (of the accents used in Lithuanian: grave, acute, tilde above, and ogonek)
   572  	// # 0049; 0069 0307; 0049; 0049; lt More_Above; # LATIN CAPITAL LETTER I
   573  	// # 004A; 006A 0307; 004A; 004A; lt More_Above; # LATIN CAPITAL LETTER J
   574  	// # 012E; 012F 0307; 012E; 012E; lt More_Above; # LATIN CAPITAL LETTER I WITH OGONEK
   575  	// # 00CC; 0069 0307 0300; 00CC; 00CC; lt; # LATIN CAPITAL LETTER I WITH GRAVE
   576  	// # 00CD; 0069 0307 0301; 00CD; 00CD; lt; # LATIN CAPITAL LETTER I WITH ACUTE
   577  	// # 0128; 0069 0307 0303; 0128; 0128; lt; # LATIN CAPITAL LETTER I WITH TILDE
   578  	// ::NFD();
   579  	// I } [^[:ccc=Not_Reordered:][:ccc=Above:]]* [:ccc=Above:] → i \u0307;
   580  	// J } [^[:ccc=Not_Reordered:][:ccc=Above:]]* [:ccc=Above:] → j \u0307;
   581  	// I \u0328 (Į) } [^[:ccc=Not_Reordered:][:ccc=Above:]]* [:ccc=Above:] → i \u0328 \u0307;
   582  	// I \u0300 (Ì) → i \u0307 \u0300;
   583  	// I \u0301 (Í) → i \u0307 \u0301;
   584  	// I \u0303 (Ĩ) → i \u0307 \u0303;
   585  	// ::Any-Lower();
   586  	// ::NFC();
   587  
   588  	i := 0
   589  	if r := c.src[c.pSrc]; r < utf8.RuneSelf {
   590  		lower(c)
   591  		if r != 'I' && r != 'J' {
   592  			return true
   593  		}
   594  	} else {
   595  		p := norm.NFD.Properties(c.src[c.pSrc:])
   596  		if d := p.Decomposition(); len(d) >= 3 && (d[0] == 'I' || d[0] == 'J') {
   597  			// UTF-8 optimization: the decomposition will only have an above
   598  			// modifier if the last rune of the decomposition is in [U+300-U+311].
   599  			// In all other cases, a decomposition starting with I is always
   600  			// an I followed by modifiers that are not cased themselves. See A.2.
   601  			if d[1] == 0xCC && d[2] <= 0x91 { // A.2.4.
   602  				if !c.writeBytes(d[:1]) {
   603  					return false
   604  				}
   605  				c.dst[c.pDst-1] += 'a' - 'A' // lower
   606  
   607  				// Assumption: modifier never changes on lowercase. See A.1.
   608  				// Assumption: all modifiers added have CCC = Above. See A.2.3.
   609  				return c.writeString("\u0307") && c.writeBytes(d[1:])
   610  			}
   611  			// In all other cases the additional modifiers will have a CCC
   612  			// that is less than 230 (Above). We will insert the U+0307, if
   613  			// needed, after these modifiers so that a string in FCD form
   614  			// will remain so. See A.2.2.
   615  			lower(c)
   616  			i = 1
   617  		} else {
   618  			return lower(c)
   619  		}
   620  	}
   621  
   622  	for ; i < maxIgnorable && c.next(); i++ {
   623  		switch c.info.cccType() {
   624  		case cccZero:
   625  			c.unreadRune()
   626  			return true
   627  		case cccAbove:
   628  			return c.writeString("\u0307") && c.copy() // See A.1.
   629  		default:
   630  			c.copy() // See A.1.
   631  		}
   632  	}
   633  	return i == maxIgnorable
   634  }
   635  
   636  // ltLowerSpan would be the same as isLower.
   637  
   638  func ltUpper(f mapFunc) mapFunc {
   639  	return func(c *context) bool {
   640  		// Unicode:
   641  		// 0307; 0307; ; ; lt After_Soft_Dotted; # COMBINING DOT ABOVE
   642  		//
   643  		// From CLDR:
   644  		// # Remove \u0307 following soft-dotteds (i, j, and the like), with possible
   645  		// # intervening non-230 marks.
   646  		// ::NFD();
   647  		// [:Soft_Dotted:] [^[:ccc=Not_Reordered:][:ccc=Above:]]* { \u0307 → ;
   648  		// ::Any-Upper();
   649  		// ::NFC();
   650  
   651  		// TODO: See A.5. A soft-dotted rune never has an exception. This would
   652  		// allow us to overload the exception bit and encode this property in
   653  		// info. Need to measure performance impact of this.
   654  		r, _ := utf8.DecodeRune(c.src[c.pSrc:])
   655  		oldPDst := c.pDst
   656  		if !f(c) {
   657  			return false
   658  		}
   659  		if !unicode.Is(unicode.Soft_Dotted, r) {
   660  			return true
   661  		}
   662  
   663  		// We don't need to do an NFD normalization, as a soft-dotted rune never
   664  		// contains U+0307. See A.3.
   665  
   666  		i := 0
   667  		for ; i < maxIgnorable && c.next(); i++ {
   668  			switch c.info.cccType() {
   669  			case cccZero:
   670  				c.unreadRune()
   671  				return true
   672  			case cccAbove:
   673  				if c.hasPrefix("\u0307") {
   674  					// We don't do a full NFC, but rather combine runes for
   675  					// some of the common cases. (Returning NFC or
   676  					// preserving normal form is neither a requirement nor
   677  					// a possibility anyway).
   678  					if !c.next() {
   679  						return false
   680  					}
   681  					if c.dst[oldPDst] == 'I' && c.pDst == oldPDst+1 && c.src[c.pSrc] == 0xcc {
   682  						s := ""
   683  						switch c.src[c.pSrc+1] {
   684  						case 0x80: // U+0300 COMBINING GRAVE ACCENT
   685  							s = "\u00cc" // U+00CC LATIN CAPITAL LETTER I WITH GRAVE
   686  						case 0x81: // U+0301 COMBINING ACUTE ACCENT
   687  							s = "\u00cd" // U+00CD LATIN CAPITAL LETTER I WITH ACUTE
   688  						case 0x83: // U+0303 COMBINING TILDE
   689  							s = "\u0128" // U+0128 LATIN CAPITAL LETTER I WITH TILDE
   690  						case 0x88: // U+0308 COMBINING DIAERESIS
   691  							s = "\u00cf" // U+00CF LATIN CAPITAL LETTER I WITH DIAERESIS
   692  						default:
   693  						}
   694  						if s != "" {
   695  							c.pDst = oldPDst
   696  							return c.writeString(s)
   697  						}
   698  					}
   699  				}
   700  				return c.copy()
   701  			default:
   702  				c.copy()
   703  			}
   704  		}
   705  		return i == maxIgnorable
   706  	}
   707  }
   708  
   709  // TODO: implement ltUpperSpan (low priority: complex and infrequent).
   710  
   711  func aztrUpper(f mapFunc) mapFunc {
   712  	return func(c *context) bool {
   713  		// i→İ;
   714  		if c.src[c.pSrc] == 'i' {
   715  			return c.writeString("İ")
   716  		}
   717  		return f(c)
   718  	}
   719  }
   720  
   721  func aztrLower(c *context) (done bool) {
   722  	// From CLDR:
   723  	// # I and i-dotless; I-dot and i are case pairs in Turkish and Azeri
   724  	// # 0130; 0069; 0130; 0130; tr; # LATIN CAPITAL LETTER I WITH DOT ABOVE
   725  	// İ→i;
   726  	// # When lowercasing, remove dot_above in the sequence I + dot_above, which will turn into i.
   727  	// # This matches the behavior of the canonically equivalent I-dot_above
   728  	// # 0307; ; 0307; 0307; tr After_I; # COMBINING DOT ABOVE
   729  	// # When lowercasing, unless an I is before a dot_above, it turns into a dotless i.
   730  	// # 0049; 0131; 0049; 0049; tr Not_Before_Dot; # LATIN CAPITAL LETTER I
   731  	// I([^[:ccc=Not_Reordered:][:ccc=Above:]]*)\u0307 → i$1 ;
   732  	// I→ı ;
   733  	// ::Any-Lower();
   734  	if c.hasPrefix("\u0130") { // İ
   735  		return c.writeString("i")
   736  	}
   737  	if c.src[c.pSrc] != 'I' {
   738  		return lower(c)
   739  	}
   740  
   741  	// We ignore the lower-case I for now, but insert it later when we know
   742  	// which form we need.
   743  	start := c.pSrc + c.sz
   744  
   745  	i := 0
   746  Loop:
   747  	// We check for up to n ignorables before \u0307. As \u0307 is an
   748  	// ignorable as well, n is maxIgnorable-1.
   749  	for ; i < maxIgnorable && c.next(); i++ {
   750  		switch c.info.cccType() {
   751  		case cccAbove:
   752  			if c.hasPrefix("\u0307") {
   753  				return c.writeString("i") && c.writeBytes(c.src[start:c.pSrc]) // ignore U+0307
   754  			}
   755  			done = true
   756  			break Loop
   757  		case cccZero:
   758  			c.unreadRune()
   759  			done = true
   760  			break Loop
   761  		default:
   762  			// We'll write this rune after we know which starter to use.
   763  		}
   764  	}
   765  	if i == maxIgnorable {
   766  		done = true
   767  	}
   768  	return c.writeString("ı") && c.writeBytes(c.src[start:c.pSrc+c.sz]) && done
   769  }
   770  
   771  // aztrLowerSpan would be the same as isLower.
   772  
   773  func nlTitle(c *context) bool {
   774  	// From CLDR:
   775  	// # Special titlecasing for Dutch initial "ij".
   776  	// ::Any-Title();
   777  	// # Fix up Ij at the beginning of a "word" (per Any-Title, notUAX #29)
   778  	// [:^WB=ALetter:] [:WB=Extend:]* [[:WB=MidLetter:][:WB=MidNumLet:]]? { Ij } → IJ ;
   779  	if c.src[c.pSrc] != 'I' && c.src[c.pSrc] != 'i' {
   780  		return title(c)
   781  	}
   782  
   783  	if !c.writeString("I") || !c.next() {
   784  		return false
   785  	}
   786  	if c.src[c.pSrc] == 'j' || c.src[c.pSrc] == 'J' {
   787  		return c.writeString("J")
   788  	}
   789  	c.unreadRune()
   790  	return true
   791  }
   792  
   793  func nlTitleSpan(c *context) bool {
   794  	// From CLDR:
   795  	// # Special titlecasing for Dutch initial "ij".
   796  	// ::Any-Title();
   797  	// # Fix up Ij at the beginning of a "word" (per Any-Title, notUAX #29)
   798  	// [:^WB=ALetter:] [:WB=Extend:]* [[:WB=MidLetter:][:WB=MidNumLet:]]? { Ij } → IJ ;
   799  	if c.src[c.pSrc] != 'I' {
   800  		return isTitle(c)
   801  	}
   802  	if !c.next() || c.src[c.pSrc] == 'j' {
   803  		return false
   804  	}
   805  	if c.src[c.pSrc] != 'J' {
   806  		c.unreadRune()
   807  	}
   808  	return true
   809  }
   810  
   811  // Not part of CLDR, but see https://unicode.org/cldr/trac/ticket/7078.
   812  func afnlRewrite(c *context) {
   813  	if c.hasPrefix("'") || c.hasPrefix("’") {
   814  		c.isMidWord = true
   815  	}
   816  }
   817
View as plain text