embedded-5_0-branch/libgo/go/runtime/rune.go

   1 /*
   2  * The authors of this software are Rob Pike and Ken Thompson.
   3  *              Copyright (c) 2002 by Lucent Technologies.
   4  *              Portions Copyright 2009 The Go Authors. All rights reserved.
   5  * Permission to use, copy, modify, and distribute this software for any
   6  * purpose without fee is hereby granted, provided that this entire notice
   7  * is included in all copies of any software which is or includes a copy
   8  * or modification of this software and in all copies of the supporting
   9  * documentation for such software.
  10  * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
  11  * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
  12  * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
  13  * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
  14  */
  15
  16 /*
  17  * This code is copied, with slight editing due to type differences,
  18  * from a subset of ../lib9/utf/rune.c
  19  */
  20
  21 package runtime
  22
  23 const (
  24         bit1 = 7
  25         bitx = 6
  26         bit2 = 5
  27         bit3 = 4
  28         bit4 = 3
  29         bit5 = 2
  30
  31         t1 = ((1 << (bit1 + 1)) - 1) ^ 0xFF /* 0000 0000 */
  32         tx = ((1 << (bitx + 1)) - 1) ^ 0xFF /* 1000 0000 */
  33         t2 = ((1 << (bit2 + 1)) - 1) ^ 0xFF /* 1100 0000 */
  34         t3 = ((1 << (bit3 + 1)) - 1) ^ 0xFF /* 1110 0000 */
  35         t4 = ((1 << (bit4 + 1)) - 1) ^ 0xFF /* 1111 0000 */
  36         t5 = ((1 << (bit5 + 1)) - 1) ^ 0xFF /* 1111 1000 */
  37
  38         rune1 = (1 << (bit1 + 0*bitx)) - 1 /* 0000 0000 0111 1111 */
  39         rune2 = (1 << (bit2 + 1*bitx)) - 1 /* 0000 0111 1111 1111 */
  40         rune3 = (1 << (bit3 + 2*bitx)) - 1 /* 1111 1111 1111 1111 */
  41         rune4 = (1 << (bit4 + 3*bitx)) - 1 /* 0001 1111 1111 1111 1111 1111 */
  42
  43         maskx = (1 << bitx) - 1 /* 0011 1111 */
  44         testx = maskx ^ 0xFF    /* 1100 0000 */
  45
  46         runeerror = 0xFFFD
  47         runeself  = 0x80
  48
  49         surrogateMin = 0xD800
  50         surrogateMax = 0xDFFF
  51
  52         bad = runeerror
  53
  54         runemax = 0x10FFFF /* maximum rune value */
  55 )
  56
  57 /*
  58  * Modified by Wei-Hwa Huang, Google Inc., on 2004-09-24
  59  * This is a slower but "safe" version of the old chartorune
  60  * that works on strings that are not necessarily null-terminated.
  61  *
  62  * If you know for sure that your string is null-terminated,
  63  * chartorune will be a bit faster.
  64  *
  65  * It is guaranteed not to attempt to access "length"
  66  * past the incoming pointer.  This is to avoid
  67  * possible access violations.  If the string appears to be
  68  * well-formed but incomplete (i.e., to get the whole Rune
  69  * we'd need to read past str+length) then we'll set the Rune
  70  * to Bad and return 0.
  71  *
  72  * Note that if we have decoding problems for other
  73  * reasons, we return 1 instead of 0.
  74  */
  75 func charntorune(s string) (rune, int) {
  76         /* When we're not allowed to read anything */
  77         if len(s) <= 0 {
  78                 return bad, 1
  79         }
  80
  81         /*
  82          * one character sequence (7-bit value)
  83          *      00000-0007F => T1
  84          */
  85         c := s[0]
  86         if c < tx {
  87                 return rune(c), 1
  88         }
  89
  90         // If we can't read more than one character we must stop
  91         if len(s) <= 1 {
  92                 return bad, 1
  93         }
  94
  95         /*
  96          * two character sequence (11-bit value)
  97          *      0080-07FF => t2 tx
  98          */
  99         c1 := s[1] ^ tx
 100         if (c1 & testx) != 0 {
 101                 return bad, 1
 102         }
 103         if c < t3 {
 104                 if c < t2 {
 105                         return bad, 1
 106                 }
 107                 l := ((rune(c) << bitx) | rune(c1)) & rune2
 108                 if l <= rune1 {
 109                         return bad, 1
 110                 }
 111                 return l, 2
 112         }
 113
 114         // If we can't read more than two characters we must stop
 115         if len(s) <= 2 {
 116                 return bad, 1
 117         }
 118
 119         /*
 120          * three character sequence (16-bit value)
 121          *      0800-FFFF => t3 tx tx
 122          */
 123         c2 := s[2] ^ tx
 124         if (c2 & testx) != 0 {
 125                 return bad, 1
 126         }
 127         if c < t4 {
 128                 l := ((((rune(c) << bitx) | rune(c1)) << bitx) | rune(c2)) & rune3
 129                 if l <= rune2 {
 130                         return bad, 1
 131                 }
 132                 if surrogateMin <= l && l <= surrogateMax {
 133                         return bad, 1
 134                 }
 135                 return l, 3
 136         }
 137
 138         if len(s) <= 3 {
 139                 return bad, 1
 140         }
 141
 142         /*
 143          * four character sequence (21-bit value)
 144          *      10000-1FFFFF => t4 tx tx tx
 145          */
 146         c3 := s[3] ^ tx
 147         if (c3 & testx) != 0 {
 148                 return bad, 1
 149         }
 150         if c < t5 {
 151                 l := ((((((rune(c) << bitx) | rune(c1)) << bitx) | rune(c2)) << bitx) | rune(c3)) & rune4
 152                 if l <= rune3 || l > runemax {
 153                         return bad, 1
 154                 }
 155                 return l, 4
 156         }
 157
 158         // Support for 5-byte or longer UTF-8 would go here, but
 159         // since we don't have that, we'll just return bad.
 160         return bad, 1
 161 }
 162
 163 // runetochar converts r to bytes and writes the result to str.
 164 // returns the number of bytes generated.
 165 func runetochar(str []byte, r rune) int {
 166         /* runes are signed, so convert to unsigned for range check. */
 167         c := uint32(r)
 168         /*
 169          * one character sequence
 170          *      00000-0007F => 00-7F
 171          */
 172         if c <= rune1 {
 173                 str[0] = byte(c)
 174                 return 1
 175         }
 176         /*
 177          * two character sequence
 178          *      0080-07FF => t2 tx
 179          */
 180         if c <= rune2 {
 181                 str[0] = byte(t2 | (c >> (1 * bitx)))
 182                 str[1] = byte(tx | (c & maskx))
 183                 return 2
 184         }
 185
 186         /*
 187          * If the rune is out of range or a surrogate half, convert it to the error rune.
 188          * Do this test here because the error rune encodes to three bytes.
 189          * Doing it earlier would duplicate work, since an out of range
 190          * rune wouldn't have fit in one or two bytes.
 191          */
 192         if c > runemax {
 193                 c = runeerror
 194         }
 195         if surrogateMin <= c && c <= surrogateMax {
 196                 c = runeerror
 197         }
 198
 199         /*
 200          * three character sequence
 201          *      0800-FFFF => t3 tx tx
 202          */
 203         if c <= rune3 {
 204                 str[0] = byte(t3 | (c >> (2 * bitx)))
 205                 str[1] = byte(tx | ((c >> (1 * bitx)) & maskx))
 206                 str[2] = byte(tx | (c & maskx))
 207                 return 3
 208         }
 209
 210         /*
 211          * four character sequence (21-bit value)
 212          *     10000-1FFFFF => t4 tx tx tx
 213          */
 214         str[0] = byte(t4 | (c >> (3 * bitx)))
 215         str[1] = byte(tx | ((c >> (2 * bitx)) & maskx))
 216         str[2] = byte(tx | ((c >> (1 * bitx)) & maskx))
 217         str[3] = byte(tx | (c & maskx))
 218         return 4
 219 }