match.go

     1  // Copyright 2013 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 language
     6  
     7  import "errors"
     8  
     9  type scriptRegionFlags uint8
    10  
    11  const (
    12  	isList = 1 << iota
    13  	scriptInFrom
    14  	regionInFrom
    15  )
    16  
    17  func (t *Tag) setUndefinedLang(id Language) {
    18  	if t.LangID == 0 {
    19  		t.LangID = id
    20  	}
    21  }
    22  
    23  func (t *Tag) setUndefinedScript(id Script) {
    24  	if t.ScriptID == 0 {
    25  		t.ScriptID = id
    26  	}
    27  }
    28  
    29  func (t *Tag) setUndefinedRegion(id Region) {
    30  	if t.RegionID == 0 || t.RegionID.Contains(id) {
    31  		t.RegionID = id
    32  	}
    33  }
    34  
    35  // ErrMissingLikelyTagsData indicates no information was available
    36  // to compute likely values of missing tags.
    37  var ErrMissingLikelyTagsData = errors.New("missing likely tags data")
    38  
    39  // addLikelySubtags sets subtags to their most likely value, given the locale.
    40  // In most cases this means setting fields for unknown values, but in some
    41  // cases it may alter a value.  It returns an ErrMissingLikelyTagsData error
    42  // if the given locale cannot be expanded.
    43  func (t Tag) addLikelySubtags() (Tag, error) {
    44  	id, err := addTags(t)
    45  	if err != nil {
    46  		return t, err
    47  	} else if id.equalTags(t) {
    48  		return t, nil
    49  	}
    50  	id.RemakeString()
    51  	return id, nil
    52  }
    53  
    54  // specializeRegion attempts to specialize a group region.
    55  func specializeRegion(t *Tag) bool {
    56  	if i := regionInclusion[t.RegionID]; i < nRegionGroups {
    57  		x := likelyRegionGroup[i]
    58  		if Language(x.lang) == t.LangID && Script(x.script) == t.ScriptID {
    59  			t.RegionID = Region(x.region)
    60  		}
    61  		return true
    62  	}
    63  	return false
    64  }
    65  
    66  // Maximize returns a new tag with missing tags filled in.
    67  func (t Tag) Maximize() (Tag, error) {
    68  	return addTags(t)
    69  }
    70  
    71  func addTags(t Tag) (Tag, error) {
    72  	// We leave private use identifiers alone.
    73  	if t.IsPrivateUse() {
    74  		return t, nil
    75  	}
    76  	if t.ScriptID != 0 && t.RegionID != 0 {
    77  		if t.LangID != 0 {
    78  			// already fully specified
    79  			specializeRegion(&t)
    80  			return t, nil
    81  		}
    82  		// Search matches for und-script-region. Note that for these cases
    83  		// region will never be a group so there is no need to check for this.
    84  		list := likelyRegion[t.RegionID : t.RegionID+1]
    85  		if x := list[0]; x.flags&isList != 0 {
    86  			list = likelyRegionList[x.lang : x.lang+uint16(x.script)]
    87  		}
    88  		for _, x := range list {
    89  			// Deviating from the spec. See match_test.go for details.
    90  			if Script(x.script) == t.ScriptID {
    91  				t.setUndefinedLang(Language(x.lang))
    92  				return t, nil
    93  			}
    94  		}
    95  	}
    96  	if t.LangID != 0 {
    97  		// Search matches for lang-script and lang-region, where lang != und.
    98  		if t.LangID < langNoIndexOffset {
    99  			x := likelyLang[t.LangID]
   100  			if x.flags&isList != 0 {
   101  				list := likelyLangList[x.region : x.region+uint16(x.script)]
   102  				if t.ScriptID != 0 {
   103  					for _, x := range list {
   104  						if Script(x.script) == t.ScriptID && x.flags&scriptInFrom != 0 {
   105  							t.setUndefinedRegion(Region(x.region))
   106  							return t, nil
   107  						}
   108  					}
   109  				} else if t.RegionID != 0 {
   110  					count := 0
   111  					goodScript := true
   112  					tt := t
   113  					for _, x := range list {
   114  						// We visit all entries for which the script was not
   115  						// defined, including the ones where the region was not
   116  						// defined. This allows for proper disambiguation within
   117  						// regions.
   118  						if x.flags&scriptInFrom == 0 && t.RegionID.Contains(Region(x.region)) {
   119  							tt.RegionID = Region(x.region)
   120  							tt.setUndefinedScript(Script(x.script))
   121  							goodScript = goodScript && tt.ScriptID == Script(x.script)
   122  							count++
   123  						}
   124  					}
   125  					if count == 1 {
   126  						return tt, nil
   127  					}
   128  					// Even if we fail to find a unique Region, we might have
   129  					// an unambiguous script.
   130  					if goodScript {
   131  						t.ScriptID = tt.ScriptID
   132  					}
   133  				}
   134  			}
   135  		}
   136  	} else {
   137  		// Search matches for und-script.
   138  		if t.ScriptID != 0 {
   139  			x := likelyScript[t.ScriptID]
   140  			if x.region != 0 {
   141  				t.setUndefinedRegion(Region(x.region))
   142  				t.setUndefinedLang(Language(x.lang))
   143  				return t, nil
   144  			}
   145  		}
   146  		// Search matches for und-region. If und-script-region exists, it would
   147  		// have been found earlier.
   148  		if t.RegionID != 0 {
   149  			if i := regionInclusion[t.RegionID]; i < nRegionGroups {
   150  				x := likelyRegionGroup[i]
   151  				if x.region != 0 {
   152  					t.setUndefinedLang(Language(x.lang))
   153  					t.setUndefinedScript(Script(x.script))
   154  					t.RegionID = Region(x.region)
   155  				}
   156  			} else {
   157  				x := likelyRegion[t.RegionID]
   158  				if x.flags&isList != 0 {
   159  					x = likelyRegionList[x.lang]
   160  				}
   161  				if x.script != 0 && x.flags != scriptInFrom {
   162  					t.setUndefinedLang(Language(x.lang))
   163  					t.setUndefinedScript(Script(x.script))
   164  					return t, nil
   165  				}
   166  			}
   167  		}
   168  	}
   169  
   170  	// Search matches for lang.
   171  	if t.LangID < langNoIndexOffset {
   172  		x := likelyLang[t.LangID]
   173  		if x.flags&isList != 0 {
   174  			x = likelyLangList[x.region]
   175  		}
   176  		if x.region != 0 {
   177  			t.setUndefinedScript(Script(x.script))
   178  			t.setUndefinedRegion(Region(x.region))
   179  		}
   180  		specializeRegion(&t)
   181  		if t.LangID == 0 {
   182  			t.LangID = _en // default language
   183  		}
   184  		return t, nil
   185  	}
   186  	return t, ErrMissingLikelyTagsData
   187  }
   188  
   189  func (t *Tag) setTagsFrom(id Tag) {
   190  	t.LangID = id.LangID
   191  	t.ScriptID = id.ScriptID
   192  	t.RegionID = id.RegionID
   193  }
   194  
   195  // minimize removes the region or script subtags from t such that
   196  // t.addLikelySubtags() == t.minimize().addLikelySubtags().
   197  func (t Tag) minimize() (Tag, error) {
   198  	t, err := minimizeTags(t)
   199  	if err != nil {
   200  		return t, err
   201  	}
   202  	t.RemakeString()
   203  	return t, nil
   204  }
   205  
   206  // minimizeTags mimics the behavior of the ICU 51 C implementation.
   207  func minimizeTags(t Tag) (Tag, error) {
   208  	if t.equalTags(Und) {
   209  		return t, nil
   210  	}
   211  	max, err := addTags(t)
   212  	if err != nil {
   213  		return t, err
   214  	}
   215  	for _, id := range [...]Tag{
   216  		{LangID: t.LangID},
   217  		{LangID: t.LangID, RegionID: t.RegionID},
   218  		{LangID: t.LangID, ScriptID: t.ScriptID},
   219  	} {
   220  		if x, err := addTags(id); err == nil && max.equalTags(x) {
   221  			t.setTagsFrom(id)
   222  			break
   223  		}
   224  	}
   225  	return t, nil
   226  }
   227
View as plain text