1 karl 1.25 //%2006////////////////////////////////////////////////////////////////////////
|
2 humberto 1.8 //
|
3 karl 1.10 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
4 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
5 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
|
6 karl 1.9 // IBM Corp.; EMC Corporation, The Open Group.
|
7 karl 1.10 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
|
9 karl 1.11 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
|
11 karl 1.25 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
12 // EMC Corporation; Symantec Corporation; The Open Group.
|
13 humberto 1.8 //
14 // Permission is hereby granted, free of charge, to any person obtaining a copy
15 // of this software and associated documentation files (the "Software"), to
16 // deal in the Software without restriction, including without limitation the
17 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
18 // sell copies of the Software, and to permit persons to whom the Software is
19 // furnished to do so, subject to the following conditions:
20 //
21 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
22 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
23 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
24 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
25 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
26 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
27 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 //
30 //==============================================================================
31 //
32 //%/////////////////////////////////////////////////////////////////////////////
33
34 humberto 1.8 #include <Pegasus/Common/LanguageParser.h>
35 #include <Pegasus/Common/InternalException.h>
36 #include <Pegasus/Common/Tracer.h>
37 #include <Pegasus/Common/MessageLoader.h> //l10n
38 #include <cstring>
39
|
40 kumpf 1.21 #ifdef PEGASUS_HAS_ICU
41 # include <unicode/locid.h>
42 #endif
43 #if defined(PEGASUS_OS_OS400)
|
44 mike 1.27 # include "EBCDIC_OS400.h"
|
45 kumpf 1.21 #endif
46
|
47 humberto 1.8 PEGASUS_NAMESPACE_BEGIN
48
|
49 kumpf 1.21 static char LANGUAGE_TAG_SEPARATOR_CHAR = '-';
|
50 kumpf 1.26 static char LOCALE_ID_SEPARATOR_CHAR = '_';
|
51 kumpf 1.21
|
52 kumpf 1.23 AcceptLanguageList LanguageParser::parseAcceptLanguageHeader(
|
53 kumpf 1.21 const String& acceptLanguageHeader)
54 {
55 PEG_METHOD_ENTER(TRC_L10N, "LanguageParser::parseAcceptLanguageHeader");
56
|
57 kumpf 1.23 AcceptLanguageList acceptLanguages;
|
58 kumpf 1.21
59 try
60 {
61 Array<String> languageElements;
62 LanguageParser::_parseLanguageHeader(
63 acceptLanguageHeader,
64 languageElements);
65
66 for (Uint32 i = 0; i < languageElements.size(); i++)
67 {
68 String languageTagString;
69 Real32 qualityValue;
70 LanguageParser::_parseAcceptLanguageElement(
71 languageElements[i], languageTagString, qualityValue);
72 acceptLanguages.insert(LanguageTag(languageTagString), qualityValue);
73 }
74 }
75 catch (Exception& e)
76 {
77 throw InvalidAcceptLanguageHeader(e.getMessage());
78 }
79 kumpf 1.21
80 PEG_METHOD_EXIT();
81 return acceptLanguages;
82 }
83
|
84 kumpf 1.23 ContentLanguageList LanguageParser::parseContentLanguageHeader(
|
85 kumpf 1.21 const String& contentLanguageHeader)
86 {
87 PEG_METHOD_ENTER(TRC_L10N, "LanguageParser::parseContentLanguageHeader");
88
|
89 kumpf 1.23 ContentLanguageList contentLanguages;
|
90 kumpf 1.21
91 try
92 {
93 Array<String> languageElements;
94 LanguageParser::_parseLanguageHeader(
95 contentLanguageHeader,
96 languageElements);
97
98 for (Uint32 i = 0; i < languageElements.size(); i++)
99 {
100 contentLanguages.append(LanguageTag(languageElements[i]));
101 }
102 }
103 catch (Exception& e)
104 {
105 throw InvalidContentLanguageHeader(e.getMessage());
106 }
107
108 PEG_METHOD_EXIT();
109 return contentLanguages;
110 }
111 kumpf 1.21
112 void LanguageParser::parseLanguageTag(
|
113 kumpf 1.24 const String& languageTagString,
|
114 kumpf 1.21 String& language,
115 String& country,
116 String& variant)
117 {
118 PEG_METHOD_ENTER(TRC_L10N, "LanguageParser::parseLanguageTag");
119
120 language.clear();
121 country.clear();
122 variant.clear();
123
124 if (languageTagString == "*")
125 {
126 // Parsing and validation is complete
127 PEG_METHOD_EXIT();
128 return;
129 }
130
131 Boolean isStandardFormat = true; // RFC 3066 (ISO 639, ISO 3166)
132 Array<String> subtags;
133
134 _parseLanguageSubtags(subtags, languageTagString);
135 kumpf 1.21
136 // _parseLanguageSubtags() always returns at least one subtag.
137 PEGASUS_ASSERT(subtags.size() > 0);
138
139 // Validate the primary subtag.
140 // Given a languageTagString "en-US-mn" the language is "en".
141
142 language = subtags[0];
143
144 if ((language == "i") || (language == "x"))
145 {
146 // These primary tags are allowed, but are not ISO 639 compliant
147 isStandardFormat = false;
148 language.clear();
149 }
150 else if ((language.size() != 2) && (language.size() != 3))
151 {
152 // Except for "i" and "x", primary tags must be 2 or 3 characters,
153 // according to RFC 3066.
154 MessageLoaderParms parms(
155 "Common.LanguageParser.INVALID_LANGUAGE_TAG",
156 kumpf 1.21 "Invalid language tag \"$0\".", languageTagString);
157 PEG_METHOD_EXIT();
|
158 marek 1.28 // do not localize message, requires a language tag for this
159 // localization can cause recursion here
160 throw Exception(parms.toString());
|
161 kumpf 1.21 }
162
163 if (subtags.size() == 1)
164 {
165 // If only the primary subtag is present, we are done!
166 PEG_METHOD_EXIT();
167 return;
168 }
169
170 // Validate the second subtag.
171 // Given a languageTagString "en-US-mn" the country is "US".
172
173 if (subtags[1].size() == 1)
174 {
175 // The second subtag may not be a single character according to
176 // RFC 3066.
177 MessageLoaderParms parms(
178 "Common.LanguageParser.INVALID_LANGUAGE_TAG",
179 "Invalid language tag \"$0\".", languageTagString);
180 PEG_METHOD_EXIT();
|
181 marek 1.28 // do not localize message, requires a language tag for this
182 // localization can cause recursion here
183 throw Exception(parms.toString());
|
184 kumpf 1.21 }
185
186 if (isStandardFormat)
187 {
188 Uint32 variantIndex = 1;
189
190 if (subtags[1].size() == 2)
191 {
192 country = subtags[1];
193 variantIndex = 2;
194 }
195
196 Uint32 numSubtags = subtags.size();
197
198 if (variantIndex < numSubtags)
199 {
200 variant = subtags[variantIndex++];
201
202 while (variantIndex < numSubtags)
203 {
204 variant.append(LANGUAGE_TAG_SEPARATOR_CHAR);
205 kumpf 1.21 variant.append(subtags[variantIndex++]);
206 }
207 }
208 }
209
210 PEG_METHOD_EXIT();
211 }
212
213 void LanguageParser::validateQualityValue(Real32 quality)
214 {
215 if ((quality > 1.0) || (quality < 0.0))
216 {
217 MessageLoaderParms parms(
218 "Common.LanguageParser.INVALID_QUALITY_VALUE",
219 "AcceptLanguage contains an invalid quality value");
220 throw InvalidAcceptLanguageHeader(MessageLoader::getMessage(parms));
221 }
222 }
223
224 String LanguageParser::buildAcceptLanguageHeader(
|
225 kumpf 1.23 const AcceptLanguageList& acceptLanguages)
|
226 kumpf 1.21 {
227 String alString;
228 Uint32 numAcceptLanguages = acceptLanguages.size();
229
230 for (Uint32 i = 0; i < numAcceptLanguages; i++)
231 {
232 alString.append(acceptLanguages.getLanguageTag(i).toString());
233
234 Real32 q = acceptLanguages.getQualityValue(i);
235 if (q != 1.0)
236 {
237 char qValueString[6];
238 sprintf(qValueString, "%4.3f", q);
239 alString.append(";q=");
240 alString.append(qValueString);
241 }
242
243 if (i < numAcceptLanguages - 1)
244 {
245 alString.append(",");
246 }
247 kumpf 1.21 }
248
249 return alString;
250 }
251
252 String LanguageParser::buildContentLanguageHeader(
|
253 kumpf 1.23 const ContentLanguageList& contentLanguages)
|
254 kumpf 1.21 {
255 String clString;
256 Uint32 numContentLanguages = contentLanguages.size();
257
258 for (Uint32 i = 0; i < numContentLanguages; i++)
259 {
260 clString.append(contentLanguages.getLanguageTag(i).toString());
261
262 if (i < numContentLanguages - 1)
263 {
264 clString.append(",");
265 }
266 }
267
268 return clString;
269 }
270
|
271 kumpf 1.26 #ifdef PEGASUS_HAS_ICU
272 String& LanguageParser::convertLocaleIdToLanguageTag(String& localeId)
273 {
274 Uint32 index = 0;
275 while ((index = localeId.find(index, LOCALE_ID_SEPARATOR_CHAR)) !=
276 PEG_NOT_FOUND)
277 {
278 localeId[index] = LANGUAGE_TAG_SEPARATOR_CHAR;
279 }
280 return localeId;
281 }
282 #endif
283
|
284 kumpf 1.23 AcceptLanguageList LanguageParser::getDefaultAcceptLanguages()
|
285 kumpf 1.21 {
286 #if defined(PEGASUS_HAS_MESSAGES) && defined(PEGASUS_HAS_ICU)
287 Locale default_loc = Locale::getDefault();
288
289 # ifdef PEGASUS_OS_OS400
290 char* tmp = (char*)default_loc.getName();
291 char tmp_[100];
292 EtoA(strcpy(tmp_,tmp));
|
293 kumpf 1.26 String localeId = tmp_;
|
294 kumpf 1.21 # else
|
295 kumpf 1.26 String localeId = default_loc.getName();
296 # endif
297
|
298 kumpf 1.21 try
299 {
|
300 kumpf 1.26 return LanguageParser::parseAcceptLanguageHeader(
301 convertLocaleIdToLanguageTag(localeId));
|
302 kumpf 1.21 }
303 catch (const InvalidAcceptLanguageHeader& e)
304 {
305 Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
306 "src.Server.cimserver.FAILED_TO_GET_PROCESS_LOCALE",
307 "Could not convert the system locale to a valid accept-language "
308 "format");
309 Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
310 e.getMessage());
|
311 kumpf 1.23 AcceptLanguageList al;
|
312 kumpf 1.22 al.insert(LanguageTag("*"), 1);
313 return al;
|
314 kumpf 1.21 }
|
315 kumpf 1.22 #else
|
316 kumpf 1.23 return AcceptLanguageList();
|
317 kumpf 1.21 #endif
318 }
319
320 void LanguageParser::_parseLanguageHeader(
321 const String& languageHeaderValue,
322 Array<String>& languageElements)
323 {
324 PEG_METHOD_ENTER(TRC_L10N, "LanguageParser::_parseLanguageHeader");
325
326 languageElements.clear();
327 String element;
328
329 for (Uint32 i=0, len=languageHeaderValue.size(); i<len; i++)
330 {
331 Char16 nextChar = languageHeaderValue[i];
332
333 if (isascii(nextChar) && isspace(nextChar))
334 {
335 // Ignore whitespace
336 }
337 else if (nextChar == '(')
338 kumpf 1.21 {
339 // Ignore comments
340 while (i < len)
341 {
342 // Search for the closing parenthesis
343 if (languageHeaderValue[i] == ')')
344 {
345 break;
346 }
347
348 // Skip over escape characters
349 if (languageHeaderValue[i] == '\\')
350 {
351 i++;
352 }
353
354 i++;
355 }
356
357 // Check for a missing closing parenthesis
358 if (i >= len)
359 kumpf 1.21 {
360 MessageLoaderParms parms(
361 "Common.LanguageParser.DOES_NOT_CONTAIN_TERMINATING",
362 "Closing \")\" character is missing.");
363 throw Exception(MessageLoader::getMessage(parms));
364 }
365 }
366 else if (nextChar == ',')
367 {
368 // Check for the end of the element
369 languageElements.append(element);
370 element.clear();
371 }
372 else
373 {
374 // Unescape an escape character
375 if ((nextChar == '\\') && (i < len-1))
376 {
377 nextChar = languageHeaderValue[++i];
378 }
379
380 kumpf 1.21 // Include this character in the value
381 element.append(nextChar);
382 }
383 }
384
385 // Include the last element in the languageElements array
386 languageElements.append(element);
387
388 PEG_METHOD_EXIT();
389 }
390
391 void LanguageParser::_parseAcceptLanguageElement(
392 const String& acceptLanguageElement,
393 String& languageTag,
394 Real32& quality)
395 {
396 PEG_METHOD_ENTER(TRC_L10N, "LanguageParser::_parseAcceptLanguageElement");
397
398 // look for ';' in acceptLanguageElement, that means we have a
399 // quality value to capture. If not present, we only have a language tag.
400
401 kumpf 1.21 Uint32 semicolonIndex = acceptLanguageElement.find(";");
402 if (semicolonIndex != PEG_NOT_FOUND)
403 {
404 // Separate the language tag and quality value
405
406 String qualityString =
407 acceptLanguageElement.subString(semicolonIndex+1);
408 languageTag = acceptLanguageElement.subString(0, semicolonIndex);
409
410 // Parse the quality value
|
411 humberto 1.8
|
412 kumpf 1.21 char dummyChar;
413 int scanfConversions = sscanf(
414 qualityString.getCString(),
415 "q=%f%c", &quality, &dummyChar);
416
417 if ((scanfConversions != 1) ||
418 (qualityString.size() > 7))
419 {
420 MessageLoaderParms parms(
421 "Common.LanguageParser.INVALID_QUALITY_VALUE",
422 "AcceptLanguage contains an invalid quality value");
423 PEG_METHOD_EXIT();
424 throw Exception(MessageLoader::getMessage(parms));
425 }
426 }
427 else
428 {
429 languageTag = acceptLanguageElement;
430 quality = 1.0;
431 }
432
433 kumpf 1.21 PEG_METHOD_EXIT();
434 }
435
436 void LanguageParser::_parseLanguageSubtags(
437 Array<String>& subtags,
438 const String& languageTagString)
439 {
440 PEG_METHOD_ENTER(TRC_L10N, "LanguageParser::_parseLanguageSubtags");
441
442 // Parse the language tag into subtags
443
444 Uint32 subtagIndex = 0;
445 Uint32 separatorIndex;
446 while ((separatorIndex = languageTagString.find(
447 subtagIndex, LANGUAGE_TAG_SEPARATOR_CHAR)) != PEG_NOT_FOUND)
448 {
449 subtags.append(languageTagString.subString(
450 subtagIndex, separatorIndex - subtagIndex));
451 subtagIndex = separatorIndex + 1;
452 }
453 subtags.append(languageTagString.subString(subtagIndex));
454 kumpf 1.21
455 // Validate the syntax of each of the subtags
456
457 for (Uint32 i = 0, n = subtags.size(); i < n; i++)
458 {
459 if (((i == 0) && !_isValidPrimarySubtagSyntax(subtags[i])) ||
460 ((i > 0) && !_isValidSubtagSyntax(subtags[i])))
461 {
462 MessageLoaderParms parms(
463 "Common.LanguageParser.MALFORMED_LANGUAGE_TAG",
464 "Malformed language tag \"$0\".", languageTagString);
465 PEG_METHOD_EXIT();
|
466 marek 1.28 // do not localize message, requires a language tag for this
467 // localization can cause recursion here
468 throw Exception(parms.toString());
|
469 kumpf 1.21 }
470 }
471
472 PEG_METHOD_EXIT();
|
473 humberto 1.8 }
474
|
475 kumpf 1.21 Boolean LanguageParser::_isValidPrimarySubtagSyntax(const String& subtag)
476 {
477 if ((subtag.size() == 0) || (subtag.size() > 8))
478 {
479 return false;
480 }
481
482 for (Uint32 i = 0, n = subtag.size(); i < n; i++)
483 {
484 if (!(isascii(subtag[i]) && isalpha(subtag[i])))
485 {
486 return false;
487 }
488 }
489
490 return true;
491 }
492
493 Boolean LanguageParser::_isValidSubtagSyntax(const String& subtag)
494 {
495 if ((subtag.size() == 0) || (subtag.size() > 8))
496 kumpf 1.21 {
497 return false;
498 }
499
500 for (Uint32 i = 0, n = subtag.size(); i < n; i++)
501 {
502 if (!(isascii(subtag[i]) && isalnum(subtag[i])))
503 {
504 return false;
505 }
506 }
507
508 return true;
509 }
|
510 humberto 1.8
511 PEGASUS_NAMESPACE_END
|
Return to
LanguageParser.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common