prop.go

     1  // Copyright 2016 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 bidi
     6  
     7  import "unicode/utf8"
     8  
     9  // Properties provides access to BiDi properties of runes.
    10  type Properties struct {
    11  	entry uint8
    12  	last  uint8
    13  }
    14  
    15  var trie = newBidiTrie(0)
    16  
    17  // TODO: using this for bidirule reduces the running time by about 5%. Consider
    18  // if this is worth exposing or if we can find a way to speed up the Class
    19  // method.
    20  //
    21  // // CompactClass is like Class, but maps all of the BiDi control classes
    22  // // (LRO, RLO, LRE, RLE, PDF, LRI, RLI, FSI, PDI) to the class Control.
    23  // func (p Properties) CompactClass() Class {
    24  // 	return Class(p.entry & 0x0F)
    25  // }
    26  
    27  // Class returns the Bidi class for p.
    28  func (p Properties) Class() Class {
    29  	c := Class(p.entry & 0x0F)
    30  	if c == Control {
    31  		c = controlByteToClass[p.last&0xF]
    32  	}
    33  	return c
    34  }
    35  
    36  // IsBracket reports whether the rune is a bracket.
    37  func (p Properties) IsBracket() bool { return p.entry&0xF0 != 0 }
    38  
    39  // IsOpeningBracket reports whether the rune is an opening bracket.
    40  // IsBracket must return true.
    41  func (p Properties) IsOpeningBracket() bool { return p.entry&openMask != 0 }
    42  
    43  // TODO: find a better API and expose.
    44  func (p Properties) reverseBracket(r rune) rune {
    45  	return xorMasks[p.entry>>xorMaskShift] ^ r
    46  }
    47  
    48  var controlByteToClass = [16]Class{
    49  	0xD: LRO, // U+202D LeftToRightOverride,
    50  	0xE: RLO, // U+202E RightToLeftOverride,
    51  	0xA: LRE, // U+202A LeftToRightEmbedding,
    52  	0xB: RLE, // U+202B RightToLeftEmbedding,
    53  	0xC: PDF, // U+202C PopDirectionalFormat,
    54  	0x6: LRI, // U+2066 LeftToRightIsolate,
    55  	0x7: RLI, // U+2067 RightToLeftIsolate,
    56  	0x8: FSI, // U+2068 FirstStrongIsolate,
    57  	0x9: PDI, // U+2069 PopDirectionalIsolate,
    58  }
    59  
    60  // LookupRune returns properties for r.
    61  func LookupRune(r rune) (p Properties, size int) {
    62  	var buf [4]byte
    63  	n := utf8.EncodeRune(buf[:], r)
    64  	return Lookup(buf[:n])
    65  }
    66  
    67  // TODO: these lookup methods are based on the generated trie code. The returned
    68  // sizes have slightly different semantics from the generated code, in that it
    69  // always returns size==1 for an illegal UTF-8 byte (instead of the length
    70  // of the maximum invalid subsequence). Most Transformers, like unicode/norm,
    71  // leave invalid UTF-8 untouched, in which case it has performance benefits to
    72  // do so (without changing the semantics). Bidi requires the semantics used here
    73  // for the bidirule implementation to be compatible with the Go semantics.
    74  //  They ultimately should perhaps be adopted by all trie implementations, for
    75  // convenience sake.
    76  // This unrolled code also boosts performance of the secure/bidirule package by
    77  // about 30%.
    78  // So, to remove this code:
    79  //   - add option to trie generator to define return type.
    80  //   - always return 1 byte size for ill-formed UTF-8 runes.
    81  
    82  // Lookup returns properties for the first rune in s and the width in bytes of
    83  // its encoding. The size will be 0 if s does not hold enough bytes to complete
    84  // the encoding.
    85  func Lookup(s []byte) (p Properties, sz int) {
    86  	c0 := s[0]
    87  	switch {
    88  	case c0 < 0x80: // is ASCII
    89  		return Properties{entry: bidiValues[c0]}, 1
    90  	case c0 < 0xC2:
    91  		return Properties{}, 1
    92  	case c0 < 0xE0: // 2-byte UTF-8
    93  		if len(s) < 2 {
    94  			return Properties{}, 0
    95  		}
    96  		i := bidiIndex[c0]
    97  		c1 := s[1]
    98  		if c1 < 0x80 || 0xC0 <= c1 {
    99  			return Properties{}, 1
   100  		}
   101  		return Properties{entry: trie.lookupValue(uint32(i), c1)}, 2
   102  	case c0 < 0xF0: // 3-byte UTF-8
   103  		if len(s) < 3 {
   104  			return Properties{}, 0
   105  		}
   106  		i := bidiIndex[c0]
   107  		c1 := s[1]
   108  		if c1 < 0x80 || 0xC0 <= c1 {
   109  			return Properties{}, 1
   110  		}
   111  		o := uint32(i)<<6 + uint32(c1)
   112  		i = bidiIndex[o]
   113  		c2 := s[2]
   114  		if c2 < 0x80 || 0xC0 <= c2 {
   115  			return Properties{}, 1
   116  		}
   117  		return Properties{entry: trie.lookupValue(uint32(i), c2), last: c2}, 3
   118  	case c0 < 0xF8: // 4-byte UTF-8
   119  		if len(s) < 4 {
   120  			return Properties{}, 0
   121  		}
   122  		i := bidiIndex[c0]
   123  		c1 := s[1]
   124  		if c1 < 0x80 || 0xC0 <= c1 {
   125  			return Properties{}, 1
   126  		}
   127  		o := uint32(i)<<6 + uint32(c1)
   128  		i = bidiIndex[o]
   129  		c2 := s[2]
   130  		if c2 < 0x80 || 0xC0 <= c2 {
   131  			return Properties{}, 1
   132  		}
   133  		o = uint32(i)<<6 + uint32(c2)
   134  		i = bidiIndex[o]
   135  		c3 := s[3]
   136  		if c3 < 0x80 || 0xC0 <= c3 {
   137  			return Properties{}, 1
   138  		}
   139  		return Properties{entry: trie.lookupValue(uint32(i), c3)}, 4
   140  	}
   141  	// Illegal rune
   142  	return Properties{}, 1
   143  }
   144  
   145  // LookupString returns properties for the first rune in s and the width in
   146  // bytes of its encoding. The size will be 0 if s does not hold enough bytes to
   147  // complete the encoding.
   148  func LookupString(s string) (p Properties, sz int) {
   149  	c0 := s[0]
   150  	switch {
   151  	case c0 < 0x80: // is ASCII
   152  		return Properties{entry: bidiValues[c0]}, 1
   153  	case c0 < 0xC2:
   154  		return Properties{}, 1
   155  	case c0 < 0xE0: // 2-byte UTF-8
   156  		if len(s) < 2 {
   157  			return Properties{}, 0
   158  		}
   159  		i := bidiIndex[c0]
   160  		c1 := s[1]
   161  		if c1 < 0x80 || 0xC0 <= c1 {
   162  			return Properties{}, 1
   163  		}
   164  		return Properties{entry: trie.lookupValue(uint32(i), c1)}, 2
   165  	case c0 < 0xF0: // 3-byte UTF-8
   166  		if len(s) < 3 {
   167  			return Properties{}, 0
   168  		}
   169  		i := bidiIndex[c0]
   170  		c1 := s[1]
   171  		if c1 < 0x80 || 0xC0 <= c1 {
   172  			return Properties{}, 1
   173  		}
   174  		o := uint32(i)<<6 + uint32(c1)
   175  		i = bidiIndex[o]
   176  		c2 := s[2]
   177  		if c2 < 0x80 || 0xC0 <= c2 {
   178  			return Properties{}, 1
   179  		}
   180  		return Properties{entry: trie.lookupValue(uint32(i), c2), last: c2}, 3
   181  	case c0 < 0xF8: // 4-byte UTF-8
   182  		if len(s) < 4 {
   183  			return Properties{}, 0
   184  		}
   185  		i := bidiIndex[c0]
   186  		c1 := s[1]
   187  		if c1 < 0x80 || 0xC0 <= c1 {
   188  			return Properties{}, 1
   189  		}
   190  		o := uint32(i)<<6 + uint32(c1)
   191  		i = bidiIndex[o]
   192  		c2 := s[2]
   193  		if c2 < 0x80 || 0xC0 <= c2 {
   194  			return Properties{}, 1
   195  		}
   196  		o = uint32(i)<<6 + uint32(c2)
   197  		i = bidiIndex[o]
   198  		c3 := s[3]
   199  		if c3 < 0x80 || 0xC0 <= c3 {
   200  			return Properties{}, 1
   201  		}
   202  		return Properties{entry: trie.lookupValue(uint32(i), c3)}, 4
   203  	}
   204  	// Illegal rune
   205  	return Properties{}, 1
   206  }
   207
View as plain text