void XWinIntlMgr::GetDayNames( VectorOfVString& outNames, bool inAbbreviated) const { // Sunday as day 1 static LCTYPE sTypes[] = { LOCALE_SDAYNAME7, LOCALE_SABBREVDAYNAME7, LOCALE_SDAYNAME1, LOCALE_SABBREVDAYNAME1, LOCALE_SDAYNAME2, LOCALE_SABBREVDAYNAME2, LOCALE_SDAYNAME3, LOCALE_SABBREVDAYNAME3, LOCALE_SDAYNAME4, LOCALE_SABBREVDAYNAME4, LOCALE_SDAYNAME5, LOCALE_SABBREVDAYNAME5, LOCALE_SDAYNAME6, LOCALE_SABBREVDAYNAME6, 0, 0 }; for( LCTYPE *pType = inAbbreviated ? &sTypes[1] : &sTypes[0] ; *pType ; pType += 2) { VString name; if (GetLocaleInfo( *pType, name)) outNames.push_back( name); } }
void VLocalizationTransUnitHandler::CheckPlatformTag( const VString& inTags, bool inIncludeIfTag, bool *ioExcluded) { VectorOfVString tags; inTags.GetSubStrings( ' ', tags, false /*inReturnEmptyStrings*/, true /*inTrimSpaces*/); // same tags as in VContextualMenu::_AddDefaultTags bool mac = std::find( tags.begin(), tags.end(), CVSTR("mac")) != tags.end(); bool win = std::find( tags.begin(), tags.end(), CVSTR("win")) != tags.end(); bool lin = std::find( tags.begin(), tags.end(), CVSTR("linux")) != tags.end(); if (mac || win || lin) { bool ok; #if VERSIONMAC ok = mac; #elif VERSIONWIN ok = win; #elif VERSION_LINUX ok = lin; #endif if (inIncludeIfTag && !ok) *ioExcluded = true; else if (!inIncludeIfTag && ok) *ioExcluded = true; } }
VError VJSONArrayReader::ToArrayString(VectorOfVString &outStrings, bool inDoAppend) { if(!inDoAppend) outStrings.clear(); if(fLastParseError == VE_OK) { if(!inDoAppend) { outStrings = fValues; } else if(!fValues.empty()) { outStrings.insert(outStrings.end(), fValues.begin(), fValues.end()); } } return fLastParseError; }
/* static */ void VProcess::_FetchCommandLineArguments( VectorOfVString& outArguments) { VectorOfVString arguments; #if VERSIONWIN int nbArgs = 0; LPWSTR *tabArgs = ::CommandLineToArgvW( ::GetCommandLineW(), &nbArgs); for( int i = 0 ; i < nbArgs ; ++i) { arguments.push_back( VString( tabArgs[i])); } LocalFree( tabArgs); #else #if VERSIONMAC int *argc_p = _NSGetArgc(); char ***argv_p = _NSGetArgv(); int argc = (argc_p == NULL) ? 0 : *argc_p; char **argv = (argv_p == NULL) ? NULL : *argv_p; #elif VERSION_LINUX // Postponed Linux Implementation ! //extern int __libc_argc; jmo - Theese symbols are not available for us ! //extern char ** __libc_argv; int argc = 0; char **argv = NULL; #endif VToUnicodeConverter_UTF8 converter; for( int i = 0 ; i < argc ; ++i) { VString s; converter.ConvertString( argv[i], strlen( argv[i]), NULL, s); arguments.push_back( s); } #endif outArguments.swap( arguments); }
VError VJSONArray::GetString( VString& outString) const { VError err = VE_OK; if (fVector.empty()) { outString.Clear(); } else { VectorOfVString array; array.resize( fVector.size()); VectorOfVString::iterator j = array.begin(); for( VectorType::const_iterator i = fVector.begin() ; (i != fVector.end()) && (err == VE_OK) ; ++i, ++j) { err = i->GetString( *j); } err = outString.Join( array, ',') ? VE_OK : vThrowError( VE_STRING_ALLOC_FAILED); } return err; }
void VJSLanguageSyntaxTester::_Tokenize( XBOX::VJSParms_callStaticFunction &ioParams, void * ) { // We are expecting 2 JavaScript parameters: // - source code to tokenize // - extension of the fake file VString sourceCode, extension; if (ioParams.CountParams() == 2) { if (!ioParams.GetStringParam( 1, sourceCode )) return; if (!ioParams.GetStringParam( 2, extension )) return; } else return; CLanguageSyntaxComponent *languageSyntax = (CLanguageSyntaxComponent *)VComponentManager::RetainComponent( (CType)CLanguageSyntaxComponent::Component_Type ); if (languageSyntax) { ISyntaxInterface *syntaxEngine = languageSyntax->GetSyntaxByExtension( extension ); if (syntaxEngine) { VectorOfVString tokens; syntaxEngine->GetTokensForTesting(sourceCode, tokens); VJSArray result( ioParams.GetContextRef() ); VJSValue jsval(ioParams.GetContextRef()); for (VectorOfVString::const_iterator it = tokens.begin(); it != tokens.end(); ++it) { jsval.SetString(*it); result.PushValue(jsval); } ioParams.ReturnValue(result); } languageSyntax->Release(); } }
void VLanguageSyntaxTesterCatalog::GetEntityModelNames(VectorOfVString& outEntityNames) const { const VValueBag *catalogBag = RetainCatalogBag(); if (catalogBag != NULL) { const VBagArray* bagModels = catalogBag->GetElements( LS_TESTER_CATALOG_DATACLASSES ); VIndex count = (bagModels != NULL) ? bagModels->GetCount() : 0; for( VIndex i = 1 ; i <= count ; ++i) { const VValueBag* bagEntityModel = bagModels->GetNth(i); if (bagEntityModel) { VString name; bagEntityModel->GetString(LS_TESTER_CATALOG_NAME, name); outEntityNames.push_back( name); } } } ReleaseRefCountable( &catalogBag); }
VError VJSONWriter::StringifyArray( const VJSONArray *inArray, VString& outString) { VError err = VE_OK; if (inArray == NULL) { outString = VJSONValue::sUndefinedString; } else if (inArray->IsEmpty()) { outString = "[]"; } else { IncrementLevel(); VectorOfVString array; size_t count = inArray->GetCount(); try { array.resize( count); } catch(...) { err = vThrowError( VE_MEMORY_FULL); } VectorOfVString::iterator j = array.begin(); for( size_t i = 0 ; (i < count) && (err == VE_OK) ; ++i, ++j) { err = StringifyValue( (*inArray)[i], *j); InsertIndentString( *j); } DecrementLevel(); if (err == VE_OK) { array.front().Insert( '[', 1); AppendIndentString( array.back()); array.back().AppendUniChar( ']'); err = outString.Join( array, ',') ? VE_OK : vThrowError( VE_STRING_ALLOC_FAILED); } } return err; }
void XWinIntlMgr::GetMonthNames( VectorOfVString& outNames, bool inAbbreviated) const { static LCTYPE sTypes[] = { LOCALE_SMONTHNAME1, LOCALE_SABBREVMONTHNAME1, LOCALE_SMONTHNAME2, LOCALE_SABBREVMONTHNAME2, LOCALE_SMONTHNAME3, LOCALE_SABBREVMONTHNAME3, LOCALE_SMONTHNAME4, LOCALE_SABBREVMONTHNAME4, LOCALE_SMONTHNAME5, LOCALE_SABBREVMONTHNAME5, LOCALE_SMONTHNAME6, LOCALE_SABBREVMONTHNAME6, LOCALE_SMONTHNAME7, LOCALE_SABBREVMONTHNAME7, LOCALE_SMONTHNAME8, LOCALE_SABBREVMONTHNAME8, LOCALE_SMONTHNAME9, LOCALE_SABBREVMONTHNAME9, LOCALE_SMONTHNAME10, LOCALE_SABBREVMONTHNAME10, LOCALE_SMONTHNAME11, LOCALE_SABBREVMONTHNAME11, LOCALE_SMONTHNAME12, LOCALE_SABBREVMONTHNAME12, LOCALE_SMONTHNAME13, LOCALE_SABBREVMONTHNAME13, 0, 0 }; for( LCTYPE *pType = inAbbreviated ? &sTypes[1] : &sTypes[0] ; *pType ; pType += 2) { VString name; if (GetLocaleInfo( *pType, name)) outNames.push_back( name); } }
VError VJSONWriter::StringifyObject( const VJSONObject *inObject, VString& outString) { if (inObject == NULL) { outString = VJSONValue::sUndefinedString; return VE_OK; } if (std::find( fStack.begin(), fStack.end(), inObject) != fStack.end()) { return vThrowError( VE_JSON_STRINGIFY_CIRCULAR); } VError err = VE_OK; fStack.push_back( inObject); if (!inObject->DoStringify( outString, *this, &err)) { if (inObject->fMap.empty()) { outString = "{}"; } else { IncrementLevel(); VectorOfVString array; array.resize( inObject->fMap.size()); VectorOfVString::iterator j = array.begin(); for( VJSONPropertyConstIterator i( inObject) ; i.IsValid() && (err == VE_OK) ; ++i, ++j) { err = i.GetName().GetJSONString( *j, GetOptions()); if (err == VE_OK) { InsertIndentString( *j); VString value; err = StringifyValue( i.GetValue(), value); if (err == VE_OK) { j->AppendUniChar( ':'); j->AppendString( value); } } } DecrementLevel(); if (err == VE_OK) { array.front().Insert( '{', 1); AppendIndentString( array.back()); array.back().AppendUniChar( '}'); err = outString.Join( array, ',') ? VE_OK : vThrowError( VE_STRING_ALLOC_FAILED); } } } fStack.pop_back(); return err; }
bool HTMLLexer::ConsumePossibleEntity( VString &outEntityConsumed, UniChar &outCharacterToAdd ) { if (!fLexerInput->HasMoreChars()) return false; xbox_assert( fLexerInput->PeekAtNextChar() == CHAR_AMPERSAND ); // In HTML, escape sequences come in one of three forms: // &#DDDD; (where D is decimal number) // &#xHHHH; (where H is hexidecimal number -- case insensitive) // &entity; (where entity is a common entity reference) // We've already read the ampersand, so now we want to figure out which of // the three cases we're dealing with. If we don't match any of the three // cases, then we just assume we really had regular text and the user just // screwed up. // Consume the current character to see what sort of escape sequence we're dealing with fLexerInput->MoveToNextChar(); // Eat the & if (!fLexerInput->HasMoreChars()) { fLexerInput->MoveToPreviousChar(); return false; } UniChar escapeType = fLexerInput->MoveToNextChar(); sLONG charactersToRevert = 2; outEntityConsumed = "&"; outEntityConsumed.AppendUniChar( escapeType ); switch (escapeType) { case CHAR_NUMBER_SIGN: { // We either have a hex literal or a decimal literal following the # sign. So we // will check to see which we've got and go from there if (!fLexerInput->HasMoreChars()) break; UniChar literalType = fLexerInput->MoveToNextChar(); outEntityConsumed.AppendUniChar( literalType ); charactersToRevert++; switch (literalType) { case CHAR_LATIN_CAPITAL_LETTER_X: case CHAR_LATIN_SMALL_LETTER_X: { // We now want to add any number of hex digits to the stream. Though, if we go over // four hex digits, then we're outside of the range of any legal unicode code point, and // so I am going to do a hard-coded stop there. unsigned short value = 0; for (sLONG i = 0; i < 4; i++) { UniChar c = CHAR_CONTROL_0000; if (fLexerInput->HasMoreChars()) { c = fLexerInput->MoveToNextChar(); charactersToRevert++; if (!isHexDigit( c )) break; // Now we want to add the hex digit we got into our ultimate value value += sixteenToThePowerOf( i ) * getHexValueFromCharacter( c ); outEntityConsumed.AppendUniChar( c ); } else break; } // The last character needs to be a semi-colon, or else it's not a legal entity if (!fLexerInput->HasMoreChars()) break; if (fLexerInput->MoveToNextChar() != CHAR_SEMICOLON) { charactersToRevert++; break; } outEntityConsumed.AppendUniChar( ';' ); // Add the value as a UniChar to our stream outCharacterToAdd = (UniChar)value; return true; } break; default: { // We want to test to see whether the character we read is a legal decimal digit. If it // is, then we have a character literal. If not, the user screwed up and we can just bail. if (isDecimalDigit( literalType )) { // We're going to put the character back just to parse it again. It makes the logic easier fLexerInput->MoveToPreviousChar(); // We know that we've got some digits we care about. Now we need to find out how many, // and we'll put the cap at something sensible, like 5 characters (which can cover all of // the unicode code points in existence). unsigned short value = 0; for (sLONG i = 0; i < 5; i++) { UniChar c = CHAR_CONTROL_0000; if (fLexerInput->HasMoreChars()) { c = fLexerInput->MoveToNextChar(); charactersToRevert++; if (!isDecimalDigit( c )) break; // Now we want to add the decimal digit we got into our ultimate value value += tenToThePowerOf( i ) * (c - '0'); outEntityConsumed.AppendUniChar( c ); } else break; } // The last character needs to be a semi-colon, or else it's not a legal entity if (!fLexerInput->HasMoreChars()) break; if (fLexerInput->MoveToNextChar() != CHAR_SEMICOLON) { charactersToRevert++; break; } outEntityConsumed.AppendUniChar( ';' ); // Add the value as a UniChar to our stream outCharacterToAdd = (UniChar)value; return true; } else break; } break; } } break; default: { // We found an ampersand and know it's not a numeric literal. Now we need to see whether it's an // entity made to be a bit more human readable. We're going to grab a bunch of characters from the // stream without actually shifting them in. We cut them off at the semi-colon because all entities // must end with one to be legal. Then, if it matches a known entity, we're set -- otherwise it's just // a stream of random characters. We need a whopping nine character to be able to support ϑ VString entityName; fLexerInput->GetSubString( fLexerInput->GetCurrentPosition(), 9, entityName ); // Now, let's see where the semi-colon is, and strip it off (as well as everything past it). If we don't // find a semi-colon, then we know we don't have an entity VectorOfVString subStrs; if (!entityName.GetSubStrings( CHAR_SEMICOLON, subStrs )) break; // The first sub string is the entity name we care about if (GetEntityValue( subStrs.front(), outCharacterToAdd )) { // We want to eat up as many characters as the entity was consuming VIndex size = subStrs.front().GetLength(); for (VIndex i = 0; i < size; i++) { outEntityConsumed.AppendUniChar( fLexerInput->MoveToNextChar() ); } return true; } } break; } // Put back the characters we screwed up on for (sLONG i = 0; i < charactersToRevert; i++) fLexerInput->MoveToPreviousChar(); return false; }