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

228