context.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  import "golang.org/x/text/transform"
     8  
     9  // A context is used for iterating over source bytes, fetching case info and
    10  // writing to a destination buffer.
    11  //
    12  // Casing operations may need more than one rune of context to decide how a rune
    13  // should be cased. Casing implementations should call checkpoint on context
    14  // whenever it is known to be safe to return the runes processed so far.
    15  //
    16  // It is recommended for implementations to not allow for more than 30 case
    17  // ignorables as lookahead (analogous to the limit in norm) and to use state if
    18  // unbounded lookahead is needed for cased runes.
    19  type context struct {
    20  	dst, src []byte
    21  	atEOF    bool
    22  
    23  	pDst int // pDst points past the last written rune in dst.
    24  	pSrc int // pSrc points to the start of the currently scanned rune.
    25  
    26  	// checkpoints safe to return in Transform, where nDst <= pDst and nSrc <= pSrc.
    27  	nDst, nSrc int
    28  	err        error
    29  
    30  	sz   int  // size of current rune
    31  	info info // case information of currently scanned rune
    32  
    33  	// State preserved across calls to Transform.
    34  	isMidWord bool // false if next cased letter needs to be title-cased.
    35  }
    36  
    37  func (c *context) Reset() {
    38  	c.isMidWord = false
    39  }
    40  
    41  // ret returns the return values for the Transform method. It checks whether
    42  // there were insufficient bytes in src to complete and introduces an error
    43  // accordingly, if necessary.
    44  func (c *context) ret() (nDst, nSrc int, err error) {
    45  	if c.err != nil || c.nSrc == len(c.src) {
    46  		return c.nDst, c.nSrc, c.err
    47  	}
    48  	// This point is only reached by mappers if there was no short destination
    49  	// buffer. This means that the source buffer was exhausted and that c.sz was
    50  	// set to 0 by next.
    51  	if c.atEOF && c.pSrc == len(c.src) {
    52  		return c.pDst, c.pSrc, nil
    53  	}
    54  	return c.nDst, c.nSrc, transform.ErrShortSrc
    55  }
    56  
    57  // retSpan returns the return values for the Span method. It checks whether
    58  // there were insufficient bytes in src to complete and introduces an error
    59  // accordingly, if necessary.
    60  func (c *context) retSpan() (n int, err error) {
    61  	_, nSrc, err := c.ret()
    62  	return nSrc, err
    63  }
    64  
    65  // checkpoint sets the return value buffer points for Transform to the current
    66  // positions.
    67  func (c *context) checkpoint() {
    68  	if c.err == nil {
    69  		c.nDst, c.nSrc = c.pDst, c.pSrc+c.sz
    70  	}
    71  }
    72  
    73  // unreadRune causes the last rune read by next to be reread on the next
    74  // invocation of next. Only one unreadRune may be called after a call to next.
    75  func (c *context) unreadRune() {
    76  	c.sz = 0
    77  }
    78  
    79  func (c *context) next() bool {
    80  	c.pSrc += c.sz
    81  	if c.pSrc == len(c.src) || c.err != nil {
    82  		c.info, c.sz = 0, 0
    83  		return false
    84  	}
    85  	v, sz := trie.lookup(c.src[c.pSrc:])
    86  	c.info, c.sz = info(v), sz
    87  	if c.sz == 0 {
    88  		if c.atEOF {
    89  			// A zero size means we have an incomplete rune. If we are atEOF,
    90  			// this means it is an illegal rune, which we will consume one
    91  			// byte at a time.
    92  			c.sz = 1
    93  		} else {
    94  			c.err = transform.ErrShortSrc
    95  			return false
    96  		}
    97  	}
    98  	return true
    99  }
   100  
   101  // writeBytes adds bytes to dst.
   102  func (c *context) writeBytes(b []byte) bool {
   103  	if len(c.dst)-c.pDst < len(b) {
   104  		c.err = transform.ErrShortDst
   105  		return false
   106  	}
   107  	// This loop is faster than using copy.
   108  	for _, ch := range b {
   109  		c.dst[c.pDst] = ch
   110  		c.pDst++
   111  	}
   112  	return true
   113  }
   114  
   115  // writeString writes the given string to dst.
   116  func (c *context) writeString(s string) bool {
   117  	if len(c.dst)-c.pDst < len(s) {
   118  		c.err = transform.ErrShortDst
   119  		return false
   120  	}
   121  	// This loop is faster than using copy.
   122  	for i := 0; i < len(s); i++ {
   123  		c.dst[c.pDst] = s[i]
   124  		c.pDst++
   125  	}
   126  	return true
   127  }
   128  
   129  // copy writes the current rune to dst.
   130  func (c *context) copy() bool {
   131  	return c.writeBytes(c.src[c.pSrc : c.pSrc+c.sz])
   132  }
   133  
   134  // copyXOR copies the current rune to dst and modifies it by applying the XOR
   135  // pattern of the case info. It is the responsibility of the caller to ensure
   136  // that this is a rune with a XOR pattern defined.
   137  func (c *context) copyXOR() bool {
   138  	if !c.copy() {
   139  		return false
   140  	}
   141  	if c.info&xorIndexBit == 0 {
   142  		// Fast path for 6-bit XOR pattern, which covers most cases.
   143  		c.dst[c.pDst-1] ^= byte(c.info >> xorShift)
   144  	} else {
   145  		// Interpret XOR bits as an index.
   146  		// TODO: test performance for unrolling this loop. Verify that we have
   147  		// at least two bytes and at most three.
   148  		idx := c.info >> xorShift
   149  		for p := c.pDst - 1; ; p-- {
   150  			c.dst[p] ^= xorData[idx]
   151  			idx--
   152  			if xorData[idx] == 0 {
   153  				break
   154  			}
   155  		}
   156  	}
   157  	return true
   158  }
   159  
   160  // hasPrefix returns true if src[pSrc:] starts with the given string.
   161  func (c *context) hasPrefix(s string) bool {
   162  	b := c.src[c.pSrc:]
   163  	if len(b) < len(s) {
   164  		return false
   165  	}
   166  	for i, c := range b[:len(s)] {
   167  		if c != s[i] {
   168  			return false
   169  		}
   170  	}
   171  	return true
   172  }
   173  
   174  // caseType returns an info with only the case bits, normalized to either
   175  // cLower, cUpper, cTitle or cUncased.
   176  func (c *context) caseType() info {
   177  	cm := c.info & 0x7
   178  	if cm < 4 {
   179  		return cm
   180  	}
   181  	if cm >= cXORCase {
   182  		// xor the last bit of the rune with the case type bits.
   183  		b := c.src[c.pSrc+c.sz-1]
   184  		return info(b&1) ^ cm&0x3
   185  	}
   186  	if cm == cIgnorableCased {
   187  		return cLower
   188  	}
   189  	return cUncased
   190  }
   191  
   192  // lower writes the lowercase version of the current rune to dst.
   193  func lower(c *context) bool {
   194  	ct := c.caseType()
   195  	if c.info&hasMappingMask == 0 || ct == cLower {
   196  		return c.copy()
   197  	}
   198  	if c.info&exceptionBit == 0 {
   199  		return c.copyXOR()
   200  	}
   201  	e := exceptions[c.info>>exceptionShift:]
   202  	offset := 2 + e[0]&lengthMask // size of header + fold string
   203  	if nLower := (e[1] >> lengthBits) & lengthMask; nLower != noChange {
   204  		return c.writeString(e[offset : offset+nLower])
   205  	}
   206  	return c.copy()
   207  }
   208  
   209  func isLower(c *context) bool {
   210  	ct := c.caseType()
   211  	if c.info&hasMappingMask == 0 || ct == cLower {
   212  		return true
   213  	}
   214  	if c.info&exceptionBit == 0 {
   215  		c.err = transform.ErrEndOfSpan
   216  		return false
   217  	}
   218  	e := exceptions[c.info>>exceptionShift:]
   219  	if nLower := (e[1] >> lengthBits) & lengthMask; nLower != noChange {
   220  		c.err = transform.ErrEndOfSpan
   221  		return false
   222  	}
   223  	return true
   224  }
   225  
   226  // upper writes the uppercase version of the current rune to dst.
   227  func upper(c *context) bool {
   228  	ct := c.caseType()
   229  	if c.info&hasMappingMask == 0 || ct == cUpper {
   230  		return c.copy()
   231  	}
   232  	if c.info&exceptionBit == 0 {
   233  		return c.copyXOR()
   234  	}
   235  	e := exceptions[c.info>>exceptionShift:]
   236  	offset := 2 + e[0]&lengthMask // size of header + fold string
   237  	// Get length of first special case mapping.
   238  	n := (e[1] >> lengthBits) & lengthMask
   239  	if ct == cTitle {
   240  		// The first special case mapping is for lower. Set n to the second.
   241  		if n == noChange {
   242  			n = 0
   243  		}
   244  		n, e = e[1]&lengthMask, e[n:]
   245  	}
   246  	if n != noChange {
   247  		return c.writeString(e[offset : offset+n])
   248  	}
   249  	return c.copy()
   250  }
   251  
   252  // isUpper writes the isUppercase version of the current rune to dst.
   253  func isUpper(c *context) bool {
   254  	ct := c.caseType()
   255  	if c.info&hasMappingMask == 0 || ct == cUpper {
   256  		return true
   257  	}
   258  	if c.info&exceptionBit == 0 {
   259  		c.err = transform.ErrEndOfSpan
   260  		return false
   261  	}
   262  	e := exceptions[c.info>>exceptionShift:]
   263  	// Get length of first special case mapping.
   264  	n := (e[1] >> lengthBits) & lengthMask
   265  	if ct == cTitle {
   266  		n = e[1] & lengthMask
   267  	}
   268  	if n != noChange {
   269  		c.err = transform.ErrEndOfSpan
   270  		return false
   271  	}
   272  	return true
   273  }
   274  
   275  // title writes the title case version of the current rune to dst.
   276  func title(c *context) bool {
   277  	ct := c.caseType()
   278  	if c.info&hasMappingMask == 0 || ct == cTitle {
   279  		return c.copy()
   280  	}
   281  	if c.info&exceptionBit == 0 {
   282  		if ct == cLower {
   283  			return c.copyXOR()
   284  		}
   285  		return c.copy()
   286  	}
   287  	// Get the exception data.
   288  	e := exceptions[c.info>>exceptionShift:]
   289  	offset := 2 + e[0]&lengthMask // size of header + fold string
   290  
   291  	nFirst := (e[1] >> lengthBits) & lengthMask
   292  	if nTitle := e[1] & lengthMask; nTitle != noChange {
   293  		if nFirst != noChange {
   294  			e = e[nFirst:]
   295  		}
   296  		return c.writeString(e[offset : offset+nTitle])
   297  	}
   298  	if ct == cLower && nFirst != noChange {
   299  		// Use the uppercase version instead.
   300  		return c.writeString(e[offset : offset+nFirst])
   301  	}
   302  	// Already in correct case.
   303  	return c.copy()
   304  }
   305  
   306  // isTitle reports whether the current rune is in title case.
   307  func isTitle(c *context) bool {
   308  	ct := c.caseType()
   309  	if c.info&hasMappingMask == 0 || ct == cTitle {
   310  		return true
   311  	}
   312  	if c.info&exceptionBit == 0 {
   313  		if ct == cLower {
   314  			c.err = transform.ErrEndOfSpan
   315  			return false
   316  		}
   317  		return true
   318  	}
   319  	// Get the exception data.
   320  	e := exceptions[c.info>>exceptionShift:]
   321  	if nTitle := e[1] & lengthMask; nTitle != noChange {
   322  		c.err = transform.ErrEndOfSpan
   323  		return false
   324  	}
   325  	nFirst := (e[1] >> lengthBits) & lengthMask
   326  	if ct == cLower && nFirst != noChange {
   327  		c.err = transform.ErrEndOfSpan
   328  		return false
   329  	}
   330  	return true
   331  }
   332  
   333  // foldFull writes the foldFull version of the current rune to dst.
   334  func foldFull(c *context) bool {
   335  	if c.info&hasMappingMask == 0 {
   336  		return c.copy()
   337  	}
   338  	ct := c.caseType()
   339  	if c.info&exceptionBit == 0 {
   340  		if ct != cLower || c.info&inverseFoldBit != 0 {
   341  			return c.copyXOR()
   342  		}
   343  		return c.copy()
   344  	}
   345  	e := exceptions[c.info>>exceptionShift:]
   346  	n := e[0] & lengthMask
   347  	if n == 0 {
   348  		if ct == cLower {
   349  			return c.copy()
   350  		}
   351  		n = (e[1] >> lengthBits) & lengthMask
   352  	}
   353  	return c.writeString(e[2 : 2+n])
   354  }
   355  
   356  // isFoldFull reports whether the current run is mapped to foldFull
   357  func isFoldFull(c *context) bool {
   358  	if c.info&hasMappingMask == 0 {
   359  		return true
   360  	}
   361  	ct := c.caseType()
   362  	if c.info&exceptionBit == 0 {
   363  		if ct != cLower || c.info&inverseFoldBit != 0 {
   364  			c.err = transform.ErrEndOfSpan
   365  			return false
   366  		}
   367  		return true
   368  	}
   369  	e := exceptions[c.info>>exceptionShift:]
   370  	n := e[0] & lengthMask
   371  	if n == 0 && ct == cLower {
   372  		return true
   373  	}
   374  	c.err = transform.ErrEndOfSpan
   375  	return false
   376  }
   377
View as plain text