code review 6202062: exp/locale/collate: implementation of main collation fu...

src/pkg/exp/locale/collate/colelem.go

 // Copyright 2012 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package collate
 
 import (
         "unicode"
 )
 
 // weights holds the decoded weights per collation level.
 type weights struct {
         primary   uint32
         secondary uint16
         tertiary  uint8
         // TODO: compute quaternary on the fly or compress this value into 8 bits
         // such that weights fit within 64bit.
         quaternary uint32
 }
 
 const (
         defaultSecondary = 0x20
         defaultTertiary  = 0x2
         maxTertiary      = 0x1F
+        maxQuaternary    = 0x1FFFFF // 21 bits.
 )
 
 // colElem is a representation of a collation element.
 // In the typical case, a rune maps to a single collation element. If a rune
 // can be the start of a contraction or expands into multiple collation elements,
 // then the colElem that is associated with a rune will have a special form to represent
 // such m to n mappings.  Such special colElems have a value >= 0x80000000.
 type colElem uint32
 
 const (
@@ skipping 103 matching lines @@
         maxUnified            = 0x9FFF
         minCompatibility      = 0xF900
         maxCompatibility      = 0xFAFF
         minRare               = 0x3400
         maxRare               = 0x4DBF
 )
 const (
         commonUnifiedOffset = 0xFB40
         rareUnifiedOffset   = 0x1FB40
         otherOffset         = 0x4FB40
-        maxPrimary          = otherOffset + unicode.MaxRune
+        illegalOffset       = otherOffset + unicode.MaxRune
+        maxPrimary          = illegalOffset + 1
 )
 
 // implicitPrimary returns the primary weight for the a rune
 // for which there is no entry for the rune in the collation table.
 // We take a different approach from the one specified in
 // http://unicode.org/reports/tr10/#Implicit_Weights,
 // but preserve the resulting relative ordering of the runes.
 func implicitPrimary(r rune) int {
         if unicode.Is(unicode.Ideographic, r) {
                 if r >= minUnified && r <= maxUnified {
                         // The most common case for CJK.
                         return int(r) + commonUnifiedOffset
                 }
                 if r >= minCompatibility && r <= maxCompatibility {
                         // This will typically not hit. The DUCET explicitly specifies mappings
                         // for all characters that do not decompose.
                         return int(r) + commonUnifiedOffset
                 }
                 return int(r) + rareUnifiedOffset
         }
         return int(r) + otherOffset
 }