libgo/go/unicode/graphic.go

   1 // Copyright 2011 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 unicode
   6
   7 // Bit masks for each code point under U+0100, for fast lookup.
   8 const (
   9         pC  = 1 << iota // a control character.
  10         pP              // a punctuation character.
  11         pN              // a numeral.
  12         pS              // a symbolic character.
  13         pZ              // a spacing character.
  14         pLu             // an upper-case letter.
  15         pLl             // a lower-case letter.
  16         pp              // a printable character according to Go's definition.
  17         pg  = pp | pZ   // a graphical character according to the Unicode definition.
  18 )
  19
  20 // GraphicRanges defines the set of graphic characters according to Unicode.
  21 var GraphicRanges = []*RangeTable{
  22         L, M, N, P, S, Zs,
  23 }
  24
  25 // PrintRanges defines the set of printable characters according to Go.
  26 // ASCII space, U+0020, is handled separately.
  27 var PrintRanges = []*RangeTable{
  28         L, M, N, P, S,
  29 }
  30
  31 // IsGraphic reports whether the rune is defined as a Graphic by Unicode.
  32 // Such characters include letters, marks, numbers, punctuation, symbols, and
  33 // spaces, from categories L, M, N, P, S, Zs.
  34 func IsGraphic(r rune) bool {
  35         // We convert to uint32 to avoid the extra test for negative,
  36         // and in the index we convert to uint8 to avoid the range check.
  37         if uint32(r) <= MaxLatin1 {
  38                 return properties[uint8(r)]&pg != 0
  39         }
  40         return IsOneOf(GraphicRanges, r)
  41 }
  42
  43 // IsPrint reports whether the rune is defined as printable by Go. Such
  44 // characters include letters, marks, numbers, punctuation, symbols, and the
  45 // ASCII space character, from categories L, M, N, P, S and the ASCII space
  46 // character.  This categorization is the same as IsGraphic except that the
  47 // only spacing character is ASCII space, U+0020.
  48 func IsPrint(r rune) bool {
  49         if uint32(r) <= MaxLatin1 {
  50                 return properties[uint8(r)]&pp != 0
  51         }
  52         return IsOneOf(PrintRanges, r)
  53 }
  54
  55 // IsOneOf reports whether the rune is a member of one of the ranges.
  56 func IsOneOf(set []*RangeTable, r rune) bool {
  57         for _, inside := range set {
  58                 if Is(inside, r) {
  59                         return true
  60                 }
  61         }
  62         return false
  63 }
  64
  65 // IsControl reports whether the rune is a control character.
  66 // The C (Other) Unicode category includes more code points
  67 // such as surrogates; use Is(C, r) to test for them.
  68 func IsControl(r rune) bool {
  69         if uint32(r) <= MaxLatin1 {
  70                 return properties[uint8(r)]&pC != 0
  71         }
  72         // All control characters are < Latin1Max.
  73         return false
  74 }
  75
  76 // IsLetter reports whether the rune is a letter (category L).
  77 func IsLetter(r rune) bool {
  78         if uint32(r) <= MaxLatin1 {
  79                 return properties[uint8(r)]&(pLu|pLl) != 0
  80         }
  81         return isExcludingLatin(Letter, r)
  82 }
  83
  84 // IsMark reports whether the rune is a mark character (category M).
  85 func IsMark(r rune) bool {
  86         // There are no mark characters in Latin-1.
  87         return isExcludingLatin(Mark, r)
  88 }
  89
  90 // IsNumber reports whether the rune is a number (category N).
  91 func IsNumber(r rune) bool {
  92         if uint32(r) <= MaxLatin1 {
  93                 return properties[uint8(r)]&pN != 0
  94         }
  95         return isExcludingLatin(Number, r)
  96 }
  97
  98 // IsPunct reports whether the rune is a Unicode punctuation character
  99 // (category P).
 100 func IsPunct(r rune) bool {
 101         if uint32(r) <= MaxLatin1 {
 102                 return properties[uint8(r)]&pP != 0
 103         }
 104         return Is(Punct, r)
 105 }
 106
 107 // IsSpace reports whether the rune is a space character as defined
 108 // by Unicode's White Space property; in the Latin-1 space
 109 // this is
 110 //      '\t', '\n', '\v', '\f', '\r', ' ', U+0085 (NEL), U+00A0 (NBSP).
 111 // Other definitions of spacing characters are set by category
 112 // Z and property Pattern_White_Space.
 113 func IsSpace(r rune) bool {
 114         // This property isn't the same as Z; special-case it.
 115         if uint32(r) <= MaxLatin1 {
 116                 switch r {
 117                 case '\t', '\n', '\v', '\f', '\r', ' ', 0x85, 0xA0:
 118                         return true
 119                 }
 120                 return false
 121         }
 122         return isExcludingLatin(White_Space, r)
 123 }
 124
 125 // IsSymbol reports whether the rune is a symbolic character.
 126 func IsSymbol(r rune) bool {
 127         if uint32(r) <= MaxLatin1 {
 128                 return properties[uint8(r)]&pS != 0
 129         }
 130         return isExcludingLatin(Symbol, r)
 131 }