(file) Return to LanguageParser.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/LanguageParser.cpp between version 1.1.2.2 and 1.19

version 1.1.2.2, 2003/08/13 19:39:50 version 1.19, 2005/05/31 12:23:38
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2005////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 23 
Line 29 
 // //
 // Author: Humberto Rivero (hurivero@us.ibm.com) // Author: Humberto Rivero (hurivero@us.ibm.com)
 // //
 // Modified By:  // Modified By: Aruran, IBM (ashanmug@in.ibm.com) for Bug# 3697, 3698, 3699, 3700
   //              Aruran, IBM (ashanmug@in.ibm.com) for Bug# 3701, 3702, 3703, 3704
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 38 
Line 45 
  
 const LanguageParser LanguageParser::EMPTY = LanguageParser(); const LanguageParser LanguageParser::EMPTY = LanguageParser();
  
 void LanguageParser::parseHdr(Array<String> &values, String & hdr){  void LanguageParser::parseHdr(Array<String> &values, String hdr){
         // look for ',' which designates distict (Accept/Content)-Language fields         // look for ',' which designates distict (Accept/Content)-Language fields
         // the form: [languagetag, languagetag, languagetag] so whitespace removal         // the form: [languagetag, languagetag, languagetag] so whitespace removal
         // may be necessary.         // may be necessary.
Line 59 
Line 66 
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
 } }
  
 Real32 LanguageParser::parseAcceptLanguageValue(String &language_tag, String & hdr){  Real32 LanguageParser::parseAcceptLanguageValue(String &language_tag, String hdr){
         // look for ';' in hdr, that means we have a quality value to capture         // look for ';' in hdr, that means we have a quality value to capture
     // if not, we only have a language     // if not, we only have a language
  
Line 83 
Line 90 
         if(i != PEG_NOT_FOUND){ // extract and store language and quality         if(i != PEG_NOT_FOUND){ // extract and store language and quality
                 if(isValid(hdr.subString(0,i), validate_length)){                 if(isValid(hdr.subString(0,i), validate_length)){
                         language_tag = hdr.subString(0,i);                         language_tag = hdr.subString(0,i);
                           if(hdr.size() > i + 3)
                         hdr.remove(0,i+3);  // remove everything but the quality value                         hdr.remove(0,i+3);  // remove everything but the quality value
                           else{
                                   MessageLoaderParms parms("Common.LanguageParser.INVALID_QUALITY_VALUE",
                                                                            "AcceptLanguage contains an invalid quality value");
                                   throw InvalidAcceptLanguageHeader(MessageLoader::getMessage(parms));
                           }
                 }                 }
                 else{                 else{
                         //l10n                         //l10n
                         //throw InvalidAcceptLanguageHeader(                         //throw InvalidAcceptLanguageHeader(
                                 //"AcceptLanguage contains too many characters or non-alpha characters");                                 //"AcceptLanguage contains too many characters or non-alpha characters");
                         String s0 = "AcceptLanguage";                          MessageLoaderParms parms("Common.LanguageParser.TOO_MANY_OR_NON_ALPHA_CHARACTERS_AL",
                         MessageLoaderParms parms("Common.LanguageParser.TOO_MANY_OR_NON_ALPHA_CHARACTERS",                                                                           "AcceptLanguage contains too many characters or non-alpha characters");
                                                                          "$0 contains too many characters or non-alpha characters",  
                                                                          s0);  
                         throw InvalidAcceptLanguageHeader(MessageLoader::getMessage(parms));                         throw InvalidAcceptLanguageHeader(MessageLoader::getMessage(parms));
                 }                 }
                 //validate quality                 //validate quality
Line 101 
Line 112 
                         //l10n                         //l10n
                         //throw InvalidAcceptLanguageHeader(                         //throw InvalidAcceptLanguageHeader(
                                 //"AcceptLanguage contains an invalid quality value");                                 //"AcceptLanguage contains an invalid quality value");
                         String s0 = "AcceptLanguage";  
                         MessageLoaderParms parms("Common.LanguageParser.INVALID_QUALITY_VALUE",                         MessageLoaderParms parms("Common.LanguageParser.INVALID_QUALITY_VALUE",
                                                                          "$0 contains an invalid quality value",                                                                           "AcceptLanguage contains an invalid quality value");
                                                                          s0);  
                         throw InvalidAcceptLanguageHeader(MessageLoader::getMessage(parms));                         throw InvalidAcceptLanguageHeader(MessageLoader::getMessage(parms));
                 }                 }
         }         }
Line 114 
Line 123 
                         //l10n                         //l10n
                         //throw InvalidAcceptLanguageHeader(                         //throw InvalidAcceptLanguageHeader(
                                 //"AcceptLanguage contains too many characters or non-alpha characters");                                 //"AcceptLanguage contains too many characters or non-alpha characters");
                         String s0 = "AcceptLanguage";                          MessageLoaderParms parms("Common.LanguageParser.TOO_MANY_OR_NON_ALPHA_CHARACTERS_AL",
                         MessageLoaderParms parms("Common.LanguageParser.TOO_MANY_OR_NON_ALPHA_CHARACTERS",                                                                           "AcceptLanguage contains too many characters or non-alpha characters");
                                                                          "$0 contains too many characters or non-alpha characters",  
                                                                          s0);  
                         throw InvalidAcceptLanguageHeader(MessageLoader::getMessage(parms));                         throw InvalidAcceptLanguageHeader(MessageLoader::getMessage(parms));
                 }                 }
         }         }
Line 126 
Line 133 
         return quality;         return quality;
 } }
  
 String LanguageParser::parseContentLanguageValue(String & hdr){  String LanguageParser::parseContentLanguageValue(const String& hdr){
         // we are looking for the language part of the hdr only,         // we are looking for the language part of the hdr only,
         // according to the RFC, there may be parenthesized strings         // according to the RFC, there may be parenthesized strings
         // that describe the purpose of the language, we need to ignore those         // that describe the purpose of the language, we need to ignore those
Line 140 
Line 147 
                         //l10n                         //l10n
                           //throw InvalidContentLanguageHeader(                           //throw InvalidContentLanguageHeader(
                                                         //"ContentLanguage does not contain terminating ) character");                                                         //"ContentLanguage does not contain terminating ) character");
                         String s0 = "ContentLanguage";  
                         MessageLoaderParms parms("Common.LanguageParser.DOES_NOT_CONTAIN_TERMINATING",                         MessageLoaderParms parms("Common.LanguageParser.DOES_NOT_CONTAIN_TERMINATING",
                                                                          "$0 does not contain terminating ) character",                                                                           "ContentLanguage does not contain terminating ) character");
                                                                          s0);  
                         throw InvalidContentLanguageHeader(MessageLoader::getMessage(parms));                         throw InvalidContentLanguageHeader(MessageLoader::getMessage(parms));
                 }                 }
         }         }
Line 155 
Line 160 
                 //l10n                 //l10n
                  //throw InvalidContentLanguageHeader(                  //throw InvalidContentLanguageHeader(
                                                         //"ContentLanguage contains too many characters or non-alpha characters");                                                         //"ContentLanguage contains too many characters or non-alpha characters");
                 String s0 = "ContentLanguage";                  MessageLoaderParms parms("Common.LanguageParser.TOO_MANY_OR_NON_ALPHA_CHARACTERS_CL",
                 MessageLoaderParms parms("Common.LanguageParser.TOO_MANY_OR_NON_ALPHA_CHARACTERS",                                                                   "ContentLanguage contains too many characters or non-alpha characters");
                                                                  "$0 contains too many characters or non-alpha characters",  
                                                                  s0);  
                 throw InvalidContentLanguageHeader(MessageLoader::getMessage(parms));                 throw InvalidContentLanguageHeader(MessageLoader::getMessage(parms));
  
         }         }
Line 166 
Line 169 
         return value;         return value;
 } }
  
 String LanguageParser::getLanguage(String & language_tag){  String LanguageParser::getLanguage(const String & language_tag){
         // given a language_tag: en-US-mn we want to return "en"         // given a language_tag: en-US-mn we want to return "en"
         Uint32 i;         Uint32 i;
         if((i = language_tag.find(findSeparator(language_tag.getCString()))) != PEG_NOT_FOUND)         if((i = language_tag.find(findSeparator(language_tag.getCString()))) != PEG_NOT_FOUND)
Line 174 
Line 177 
         return String(language_tag);         return String(language_tag);
 } }
  
 String LanguageParser::getCountry(String & language_tag){  String LanguageParser::getCountry(const String & language_tag){
         // given a language_tag: en-US-mn we want to return "US"         // given a language_tag: en-US-mn we want to return "US"
         Uint32 i,j;         Uint32 i,j;
         if( (i = language_tag.find(findSeparator(language_tag.getCString()))) != PEG_NOT_FOUND )         if( (i = language_tag.find(findSeparator(language_tag.getCString()))) != PEG_NOT_FOUND )
Line 185 
Line 188 
         return String::EMPTY;         return String::EMPTY;
 } }
  
 String LanguageParser::getVariant(String & language_tag){  String LanguageParser::getVariant(const String & language_tag){
         // given a language_tag: en-US-mn we want to return "mn"         // given a language_tag: en-US-mn we want to return "mn"
         Uint32 i;         Uint32 i;
         if( (i = language_tag.find(findSeparator(language_tag.getCString()))) != PEG_NOT_FOUND )         if( (i = language_tag.find(findSeparator(language_tag.getCString()))) != PEG_NOT_FOUND )
Line 207 
Line 210 
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
 } }
  
 Boolean LanguageParser::isValid(String language_tag, Boolean validate_length){  Boolean LanguageParser::isValid(const String& language_tag, Boolean validate_length){
         //break the String down into parts(subtags), then validate each part         //break the String down into parts(subtags), then validate each part
  
         if(language_tag == "*") return true;         if(language_tag == "*") return true;
Line 215 
Line 218 
         Array<String> subtags;         Array<String> subtags;
         parseLanguageSubtags(subtags, language_tag);         parseLanguageSubtags(subtags, language_tag);
         if(subtags.size() > 0){         if(subtags.size() > 0){
                 for(int i = 0; i < subtags.size(); i++){                  for(Uint32 i = 0; i < subtags.size(); i++){
                         //length should be 8 or less AND all characters should be A-Z or a-z                         //length should be 8 or less AND all characters should be A-Z or a-z
                         if((validate_length && subtags[i].size() > 8) || !checkAlpha(subtags[i].getCString()))                         if((validate_length && subtags[i].size() > 8) || !checkAlpha(subtags[i].getCString()))
                                 return false;                                 return false;
Line 227 
Line 230 
         return true;         return true;
 } }
  
 String LanguageParser::convertPrivateLanguageTag(String language_tag){  String LanguageParser::convertPrivateLanguageTag(const String & language_tag){
         // figure out if its a unix style locale or windows locale         // figure out if its a unix style locale or windows locale
         int i;          Uint32 i;
         if(( i = language_tag.find("pegasus-")) != PEG_NOT_FOUND ){         if(( i = language_tag.find("pegasus-")) != PEG_NOT_FOUND ){
                 language_tag = language_tag.subString(i+5);  // capture the remainder of the string                  String str;
                 return String(replaceSeparator(language_tag.getCString(), '-'));                  str = language_tag.subString(i+5);
                   //language_tag = language_tag.subString(i+5);  // capture the remainder of the string
                   return String(replaceSeparator(str.getCString(), '-'));
         }         }
         //else if( (i = language_tag.find("win-")) != PEG_NOT_FOUND ){         //else if( (i = language_tag.find("win-")) != PEG_NOT_FOUND ){
           // return language_tag.subString(i+4);  // capture the remainder of the string           // return language_tag.subString(i+4);  // capture the remainder of the string
Line 243 
Line 248 
         }         }
 } }
  
 Boolean LanguageParser::checkAlpha(CString _str){  Boolean LanguageParser::checkAlpha(const CString & _str){
         for(int i = 0; i < strlen(_str); i++)          Uint32 length = (Uint32) strlen(_str);
           for(Uint32 i = 0; i < length; i++)
                 if( !isalpha(_str[i]) )                 if( !isalpha(_str[i]) )
                         return false;                         return false;
         return true;         return true;
 } }
  
 char LanguageParser::findSeparator(CString _str){  char LanguageParser::findSeparator(const CString & _str){
         for(int i = 0; i < strlen(_str); i++)          Uint32 length = (Uint32) strlen(_str);
           for(Uint32 i = 0; i < length; i++)
                 if(!isalnum(_str[i]))                 if(!isalnum(_str[i]))
                         return _str[i];                         return _str[i];
         return '\0';         return '\0';
 } }
  
 CString LanguageParser::replaceSeparator(CString _s, char new_sep){  CString LanguageParser::replaceSeparator(const CString & _s, char new_sep){
         char * _str = const_cast<char *>((const char*)_s);          char * _str = 0;
         for(int i = 0; i < strlen(_str); i++)          strcpy(_str,_s);
           Uint32 length = (Uint32) strlen(_str);
           for(Uint32 i = 0; i < length; i++)
                 _str[i] = (!isalnum(_str[i])) ? new_sep : _str[i];                 _str[i] = (!isalnum(_str[i])) ? new_sep : _str[i];
         return (String(_str)).getCString();         return (String(_str)).getCString();
 } }

Legend:
Removed from v.1.1.2.2  
changed lines
  Added in v.1.19
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2