VError VValueBag::_GetJSONString(VString& outJSONString, sLONG& curlevel, bool prettyformat, JSONOption inModifier) const
{
AppendBeginJSONObject(outJSONString, curlevel, prettyformat);
VIndex nbatt = GetAttributesCount();
VIndex nbelem = GetElementNamesCount();
bool first = true;
for (VIndex i = 1; i <= nbatt; i++)
{
VStr255 s;
const VValueSingle* val = GetNthAttribute(i, &s);
if ( !s.EqualToUSASCIICString( "____objectunic") && !s.EqualToUSASCIICString( "____property_name_in_jsarray"))
{
if (first)
first = false;
else
outJSONString.AppendUniChar(',');
if (s.EqualToUSASCIICString( "<>"))
s = "__CDATA";
AppendJSONPropertyName(outJSONString, curlevel, prettyformat, s);
if (val == NULL || val->IsNull())
outJSONString += "null";
else
{
val->GetJSONString(s, JSON_WithQuotesIfNecessary);
outJSONString += s;
}
}
}
for (VIndex i = 1; i <= nbelem; i++)
{
if (first)
first = false;
else
outJSONString.AppendUniChar(',');
VStr255 s;
const VBagArray* subelems = GetNthElementName(i, &s);
AppendJSONPropertyName(outJSONString, curlevel, prettyformat, s);
if ((inModifier & JSON_UniqueSubElementsAreNotArrays) != 0 && subelems->GetCount() == 1)
{
subelems->GetNth(1)->_GetJSONString(outJSONString, curlevel, prettyformat, inModifier);
}
else if (subelems->GetNth(1)->GetAttribute("____objectunic"))
{
subelems->GetNth(1)->_GetJSONString(outJSONString, curlevel, prettyformat, inModifier);
}
else
subelems->_GetJSONString(outJSONString, curlevel, prettyformat, inModifier);
}
AppendEndJSONObject(outJSONString, curlevel, prettyformat);
return VE_OK;
}
void AppendEndJSONArray(VString& outJSONString, sLONG& curlevel, bool prettyformat)
{
AppendJSONNewline(outJSONString, prettyformat);
curlevel--;
AjustJSONTab(outJSONString, curlevel, prettyformat);
outJSONString.AppendUniChar(']');
}
bool ScriptDocLexer::ConsumeName( VString &outName, bool &outIsOptional, bool &outDoFurtherProcessing )
{
outIsOptional = false;
outDoFurtherProcessing = true;
while (true) {
if (!fLexerInput->HasMoreChars()) return false;
UniChar ch = fLexerInput->MoveToNextChar();
if (CHAR_LEFT_SQUARE_BRACKET == ch) {
// If the name is enclosed in [], then it's considered to be an optional
// parameter.
if (outName.GetLength() == 0) {
outIsOptional = true;
} else {
return false;
}
} else if (IsLineEnding( ch )) {
// We've reached the end of the tag, and the user has not specified a comment, which
// is fine. We'll just break out now and not do any further processing.
ConsumeLineEnding( ch );
outDoFurtherProcessing = false;
break;
} else if (IsWhitespace( ch ) || (outIsOptional && CHAR_RIGHT_SQUARE_BRACKET == ch)) {
break;
} else {
outName.AppendUniChar( ch );
}
}
return true;
}
bool ScriptDocLexer::ConsumeExceptionTag()
{
// The exception tag takes the form: @exception {name} description, and we've already
// handled the @exception clause. So we want to skip over whitespace and look for the
// {name} clause next.
UniChar ch;
bool toss;
if (!SkipWhitespaces( toss )) return false;
if (!fLexerInput->HasMoreChars()) return false;
// We expect the next character to be an open curly bracket.
if (CHAR_LEFT_CURLY_BRACKET != fLexerInput->MoveToNextChar()) return false;
if (!fLexerInput->HasMoreChars()) return false;
// Now we expect to read the name of the exception
VString exceptionName;
while (true) {
if (!fLexerInput->HasMoreChars()) return false;
ch = fLexerInput->MoveToNextChar();
if (IsLineEnding( ch )) { ConsumeLineEnding( ch ); return false; }
if (CHAR_RIGHT_CURLY_BRACKET == ch) break;
exceptionName.AppendUniChar( ch );
}
// Now that we have the exception name clause, we can skip whitespaces and look
// for the description
if (!SkipWhitespaces( toss )) return false;
VString description;
if (!ConsumeComment( description )) return false;
fLastElement = new ExceptionElement( exceptionName, description );
return true;
}
VString XLinuxIntlMgr::GetTimeSeparator() const
{
VString timeSeparator;
VString timePattern=GetDateOrTimePattern(SHORT_TIME);
bool isQuoted=false;
for(int i=0 ; i<timePattern.GetLength() ; i++)
{
UniChar c=timePattern[i];
if(c=='\'')
isQuoted=!isQuoted;
if(isQuoted)
continue;
if(!(c>='A' && c<='Z') && !(c>='a' && c<='z'))
{
timeSeparator.AppendUniChar(c);
break;
}
}
if(timeSeparator.IsEmpty())
return VString(":");
return timeSeparator;
}
void AppendBeginJSONObject(VString& outJSONString, sLONG& curlevel, bool prettyformat)
{
AppendJSONNewline(outJSONString, prettyformat);
AjustJSONTab(outJSONString, curlevel, prettyformat);
outJSONString.AppendUniChar('{');
curlevel++;
//AppendJSONNewline(outJSONString, prettyformat);
}
VFolder::VFolder( const FSRef& inRef)
{
VString fullPath;
XMacFile::FSRefToHFSPath( inRef, fullPath);
fullPath.AppendUniChar( FOLDER_SEPARATOR);
fPath.FromFullPath(fullPath);
xbox_assert( fPath.IsFolder());
fFolder.Init( this);
}
void VJSGroup::_filterParents( XBOX::VJSParms_callStaticFunction& ioParms, CUAGGroup* inGroup)
{
VString s;
ioParms.GetStringParam(1,s);
s.AppendUniChar(ioParms.GetWildChar());
CUAGGroupVector groups;
bool firstlevel = ioParms.GetBoolParam(2, "firstLevel", "allLevels");
inGroup->RetainOwners(groups, firstlevel);
ioParms.ReturnValue(buildArrFromGroups(ioParms, groups, &s));
}
void AppendJSONPropertyName(VString& outJSONString, sLONG& curlevel, bool prettyformat, const VString name)
{
VString name2;
AppendJSONNewline(outJSONString, prettyformat);
AjustJSONTab(outJSONString, curlevel, prettyformat);
name.GetJSONString(name2, JSON_WithQuotesIfNecessary);
outJSONString += name2;
if (prettyformat)
outJSONString += " : ";
else
outJSONString.AppendUniChar(':');
}
VString XLinuxIntlMgr::GetDateSeparator() const
{
VString dateSeparator;
icu::DateFormat* dateFmt=icu::DateFormat::createDateInstance(icu::DateFormat::SHORT, fLocale);
xbox_assert(dateFmt!=NULL);
icu::SimpleDateFormat* simpleDateFmt=reinterpret_cast<icu::SimpleDateFormat*>(dateFmt);
xbox_assert(simpleDateFmt!=NULL);
if(simpleDateFmt!=NULL)
{
UErrorCode err=U_ZERO_ERROR;
UnicodeString tmpPattern;
simpleDateFmt->toLocalizedPattern(tmpPattern, err);
xbox_assert(err==U_ZERO_ERROR);
VString datePattern(tmpPattern.getTerminatedBuffer());
bool isQuoted=false;
for(int i=0 ; i<datePattern.GetLength() ; i++)
{
UniChar c=datePattern[i];
if(c=='\'')
isQuoted=!isQuoted;
if(isQuoted)
continue;
//ICU works with patterns ("M/d/yy" for ex.) and doesn't have a notion of date separator.
//As a work around, we try to get a localized date pattern and pick the first char that looks like a separator.
if(!(c>='A' && c<='Z') && !(c>='a' && c<='z'))
{
dateSeparator.AppendUniChar(c);
break;
}
}
}
if(dateFmt!=NULL)
delete dateFmt;
xbox_assert(!dateSeparator.IsEmpty());
if(dateSeparator.IsEmpty())
return VString("/");
return dateSeparator;
}
VError VBagArray::_GetJSONString(VString& outJSONString, sLONG& curlevel, bool prettyformat, JSONOption inModifier) const
{
AppendBeginJSONArray(outJSONString, curlevel, prettyformat);
VIndex nbelem = GetCount();
for (VIndex i = 1; i <= nbelem; i++)
{
GetNth(i)->_GetJSONString(outJSONString, curlevel, prettyformat, inModifier);
if (i != nbelem)
outJSONString.AppendUniChar(',');
}
AppendEndJSONArray(outJSONString, curlevel, prettyformat);
return VE_OK;
}
bool ScriptDocLexer::ConsumeReturnTag()
{
UniChar ch;
bool toss;
if ( ! SkipWhitespaces( toss ) )
return false;
if ( ! fLexerInput->HasMoreChars() )
return false;
// We expect the next character to be an open curly bracket.
if ( CHAR_LEFT_CURLY_BRACKET != fLexerInput->MoveToNextChar() )
return false;
if ( ! fLexerInput->HasMoreChars() )
return false;
// Now we expect to read the type list
VString typeList;
while (true)
{
if ( ! fLexerInput->HasMoreChars() )
return false;
ch = fLexerInput->MoveToNextChar();
if ( IsLineEnding( ch ) )
{
ConsumeLineEnding( ch );
return false;
}
if (CHAR_RIGHT_CURLY_BRACKET == ch)
break;
typeList.AppendUniChar( ch );
}
if ( ! SkipWhitespaces( toss ) )
return false;
// Now we can find the description of the return value
VString description;
ConsumeComment( description );
fLastElement = new ReturnElement( typeList, description );
return true;
}
bool ScriptDocLexer::ConsumeTypes( VString &outTypes, bool &outDoFurtherProcessing )
{
outDoFurtherProcessing = true;
// We expect the next character to be an open curly bracket if the user has specified
// type information for the parameter
bool curlyBracketMode = CHAR_LEFT_CURLY_BRACKET == fLexerInput->PeekAtNextChar();
if ( curlyBracketMode )
{
fLexerInput->MoveToNextChar();
if ( ! fLexerInput->HasMoreChars() )
return false;
}
// Now we expect to read the type list
while (true)
{
if ( ! fLexerInput->HasMoreChars() )
return false;
UniChar ch = fLexerInput->MoveToNextChar();
if ( IsLineEnding( ch ) )
{
ConsumeLineEnding( ch );
if (curlyBracketMode)
outDoFurtherProcessing = false;
break;
}
if (curlyBracketMode && CHAR_RIGHT_CURLY_BRACKET == ch)
break;
outTypes.AppendUniChar( ch );
}
return true;
}
BEGIN_TOOLBOX_NAMESPACE
// ===========================================================
#pragma mark -
#pragma mark VJSONImporter
// ===========================================================
/* WARNING: this GetNextJSONToken(VString&, bool*) is the same as the GetNextJSONToken() with no parameters,
except it fills outString and withQuotes.
=> if something must be changed here, think about changing the parsing also in the other GetNextJSONToken()
It looks better to write 2 routines instead of filling this one with more parameter and testing, such as writting
a lot of if(!doNotFillString) or something
*/
VJSONImporter::JsonToken VJSONImporter::GetNextJSONToken(VString& outString, bool* withQuotes)
{
outString.Clear();
bool eof;
if (withQuotes != NULL)
*withQuotes = false;
UniChar c;
do
{
c = _GetNextChar(eof);
if (c > 32)
{
switch (c)
{
case '{':
return jsonBeginObject;
break;
case '}':
return jsonEndObject;
break;
case '[':
return jsonBeginArray;
break;
case ']':
return jsonEndArray;
break;
case ',':
return jsonSeparator;
break;
case ':':
return jsonAssigne;
break;
case '"':
{
if (withQuotes != NULL)
*withQuotes = true;
do
{
c = _GetNextChar(eof);
if (c != 0)
{
if (c == '\\')
{
c = _GetNextChar(eof);
switch(c)
{
case '\\':
case '"':
case '/':
// c is the same
break;
case 't':
c = 9;
break;
case 'r':
c = 13;
break;
case 'n':
c = 10;
break;
case 'b':
c = 8;
break;
case 'f':
c = 12;
break;
case 'u':
/* 2010-02-22 - T.A.
http://www.ietf.org/rfc/rfc4627.txt
. . .
The application/json Media Type for JavaScript Object Notation (JSON)
. . .
Any character may be escaped. If the character is in the Basic
Multilingual Plane (U+0000 through U+FFFF), then it may be
represented as a six-character sequence: a reverse solidus, followed
by the lowercase letter u, followed by four hexadecimal digits that
encode the character's code point. The hexadecimal letters A though
F can be upper or lowercase. So, for example, a string containing
only a single reverse solidus character may be represented as
"\u005C".
. . .
*/
if ( testAssert( fCurChar - fStartChar + 4 <= fInputLen))
{
c = 0;
for(sLONG i_fromHex = 1; i_fromHex <= 4; ++i_fromHex)
{
UniChar theChar = *fCurChar++;
if (theChar >= CHAR_DIGIT_ZERO && theChar <= CHAR_DIGIT_NINE)
{
c *= 16L;
c += (theChar - CHAR_DIGIT_ZERO);
}
else if (theChar >= CHAR_LATIN_CAPITAL_LETTER_A && theChar <= CHAR_LATIN_CAPITAL_LETTER_F)
{
c *= 16L;
c += (theChar - CHAR_LATIN_CAPITAL_LETTER_A) + 10L;
}
else if (theChar >= CHAR_LATIN_SMALL_LETTER_A && theChar <= CHAR_LATIN_SMALL_LETTER_F)
{
c *= 16L;
c += (theChar - CHAR_LATIN_SMALL_LETTER_A) + 10L;
}
}
}
else
{
eof = true;
c = 0;
}
break;
}
if (c != 0)
outString.AppendUniChar(c);
}
else if (c == '"')
{
return jsonString;
}
else
{
outString.AppendUniChar(c);
}
}
} while(!eof);
return jsonString;
}
break;
default:
{
outString.AppendUniChar(c);
do
{
const UniChar* oldpos = fCurChar;
c = _GetNextChar(eof);
if (c <= 32)
{
return jsonString;
}
else
{
switch(c)
{
case '{':
case '}':
case '[':
case ']':
case ',':
case ':':
case '"':
fCurChar = oldpos;
return jsonString;
break;
default:
outString.AppendUniChar(c);
break;
}
}
} while(!eof);
return jsonString;
}
break;
}
}
} while(!eof);
return jsonNone;
}
int HTMLLexer::ConsumePossiblePunctuation( UniChar inChar, TokenList *outTokens )
{
VIndex nStartingPosition = fLexerInput->GetCurrentPosition();
int tk = 0;
VString tokenStr;
switch (inChar) {
case CHAR_AMPERSAND: {
VString entity;
UniChar ch;
if (ConsumePossibleEntity( entity, ch )) {
tk = HTMLLexemes::TEXT;
if (outTokens) {
outTokens->push_back( new HTMLLexerToken( ILexerToken::TT_HTML_ENTITY, nStartingPosition, entity.GetLength(), entity, ch ) );
}
return tk;
}
} break;
case CHAR_EQUALS_SIGN: {
tokenStr.AppendUniChar( fLexerInput->MoveToNextChar() );
tk = (int)inChar;
} break;
case CHAR_SOLIDUS: {
fLexerInput->MoveToNextChar();
if (fLexerInput->HasMoreChars()) {
if (fLexerInput->PeekAtNextChar() == CHAR_GREATER_THAN_SIGN) {
tk = HTMLLexemes::SELF_CLOSE;
tokenStr = "/>";
fLexerInput->MoveToNextChar(); // Eat the >
}
}
if (!tk) fLexerInput->MoveToPreviousChar();
} break;
case CHAR_LESS_THAN_SIGN: {
tokenStr.AppendUniChar( fLexerInput->MoveToNextChar() );
tk = (int)inChar;
if (fLexerInput->HasMoreChars()) {
if (fLexerInput->PeekAtNextChar() == CHAR_SOLIDUS) {
tk = HTMLLexemes::START_OF_CLOSE_TAG;
tokenStr = "</";
fLexerInput->MoveToNextChar(); // Eat the /
} else if (fLexerInput->PeekAtNextChar() == CHAR_EXCLAMATION_MARK) {
tk = HTMLLexemes::BANG_START;
tokenStr = "<!";
fLexerInput->MoveToNextChar();
} else if (fLexerInput->PeekAtNextChar() == CHAR_QUESTION_MARK) {
tk = HTMLLexemes::QUESTION_START;
tokenStr = "<?";
fLexerInput->MoveToNextChar();
}
}
} break;
case CHAR_GREATER_THAN_SIGN: {
tokenStr.AppendUniChar( fLexerInput->MoveToNextChar() );
tk = (int)inChar;
} break;
}
if (tk && outTokens) {
outTokens->push_back( new HTMLLexerToken( ILexerToken::TT_PUNCTUATION,
nStartingPosition, tokenStr.GetLength(), tokenStr, tk ) );
}
return tk;
}
void XWinIntlMgr::FormatDate( const VTime& inDate, VString& outDate, EOSFormats inFormat, bool inUseGMTTimeZoneForDisplay)
{
// Prepare SYSTEMTIME for windows.
sWORD YY = 0;
sWORD MM = 0;
sWORD DD = 0;
sWORD hh = 0;
sWORD mm = 0;
sWORD ss = 0;
sWORD ms = 0;
if (inUseGMTTimeZoneForDisplay)
inDate.GetUTCTime (YY,MM,DD,hh,mm,ss,ms);
else
inDate.GetLocalTime (YY,MM,DD,hh,mm,ss,ms);
// Verify if date >1st Jan 1601 (GetDateFormat doesn't support earlier dates.
if (YY>=1601)
{
// Let the OS do it's job.
UniChar acBuffer[256];
SYSTEMTIME osDate={0};
osDate.wYear=YY;
osDate.wMonth=MM;
osDate.wDay=DD;
osDate.wHour=hh;
osDate.wMinute=mm;
osDate.wSecond=ss;
osDate.wMilliseconds=ms;
if (inFormat == eOS_MEDIUM_FORMAT)
{
VString pattern;
if (GetLocaleInfo( LOCALE_SLONGDATE, pattern))
{
// replace long month and date by medium ones
pattern.ExchangeRawString( CVSTR( "MMMM"), CVSTR( "MMM"));
pattern.ExchangeRawString( CVSTR( "dddd"), CVSTR( "ddd"));
if (::GetDateFormatW( fDialect, 0, &osDate, pattern.GetCPointer(), acBuffer, sizeof(acBuffer)))
outDate = acBuffer;
}
}
else
{
// Let the OS do the stuff.
DWORD dateFormat = (inFormat == eOS_SHORT_FORMAT) ? DATE_SHORTDATE : DATE_LONGDATE;
if (::GetDateFormatW(fDialect,dateFormat,&osDate,NULL,acBuffer,sizeof(acBuffer)))
outDate = acBuffer;
}
}
else
{
// Get the date pattern
VString pattern;
if (GetLocaleInfo( (inFormat == eOS_LONG_FORMAT) ? LOCALE_SLONGDATE : LOCALE_SSHORTDATE, pattern))
{
XBOX::VString tokens="gyMd";
UniChar oldToken=0;
sLONG count=0;
pattern.AppendChar(' ');
sLONG YY2=YY%100;
XBOX::VString oneName;
for (int pos=0;pos<pattern.GetLength();pos++)
{
UniChar token=pattern[pos];
if (tokens.FindUniChar(token)>=1)
{
if (token==oldToken)
count++;
else
{
if (!count)
{
count=1;
oldToken=token;
}
}
}
if (count && token!=oldToken)
{
switch(oldToken)
{
case 'g':
if (count==2)
{
// TODO: ERA will be added if really wanted.
}
else
{
for (int i=0;i<count;i++)
outDate.AppendUniChar(oldToken);
}
break;
case 'y': // YEAR
switch(count)
{
case 5:
case 4: // 4 or more digits date
outDate.AppendLong(YY);
break;
case 2: // 2 digits with starting 0.
if (YY2<=9)
outDate.AppendLong(0);
case 1: // 1 or 2 digits
outDate.AppendLong(YY2);
break;
default:
for (int i=0;i<count;i++)
outDate.AppendUniChar(oldToken);
break;
}
break;
case 'M': // MONTH
switch(count)
{
case 4: // Long name
case 3: // Abbreviated name
if (GetLocaleInfo( ((count==4) ? LOCALE_SMONTHNAME1 : LOCALE_SABBREVMONTHNAME1) + MM - 1, oneName))
outDate += oneName;
break;
case 2: // 2 digits number (leading 0)
if (MM<=9)
outDate.AppendLong(0);
case 1: // 1 or 2 digits number
outDate.AppendLong(MM);
break;
default:
for (int i=0;i<count;i++)
outDate.AppendUniChar(oldToken);
break;
}
break;
case 'd': // DAY
switch(count)
{
case 4: // Weekday long name
case 3: // Weekday abbreviated name
if (GetLocaleInfo( ((count==4) ? LOCALE_SDAYNAME1 : LOCALE_SABBREVDAYNAME1) + (inDate.GetWeekDay() + 6) % 7, oneName))
outDate += oneName;
break;
case 2: // Month day on 2 digits (leading 0)
if (DD<=9)
outDate.AppendLong(0);
case 1: // Month day on 1 or 2 digits.
outDate.AppendLong(DD);
break;
default:
for (int i=0;i<count;i++)
outDate.AppendUniChar(oldToken);
break;
}
break;
}
count=0;
}
if (!count)
outDate.AppendUniChar(token);
oldToken=token;
}
// Remove the extra space at end of pattern.
if (outDate.GetLength()>1)
outDate.SubString(1,outDate.GetLength()-1);
}
}
}
void AjustJSONTab(VString& outJSONString, sLONG& curlevel, bool prettyformat)
{
if (prettyformat)
for (sLONG i = 0; i < curlevel; i++)
outJSONString.AppendUniChar(9);
}
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;
}
bool ScriptDocLexer::ConsumeScriptDocTag()
{
// We need to consume the @ token for the tag. We know it exists because
// we've already peeked at it
if (!testAssert( fLexerInput->MoveToNextChar() == CHAR_COMMERCIAL_AT )) return false;
// After the @ symbol comes the name of the tag, followed by some whitespace. Any
// whitespace between the @ and the tag name will be eaten
bool toss = false;
if (!SkipWhitespaces( toss )) return false;
UniChar ch;
VString text;
bool bLineEnded = false;
while (true) {
if (!fLexerInput->HasMoreChars()) return false;
ch = fLexerInput->MoveToNextChar();
if (IsWhitespace( ch )) break;
if (IsLineEnding( ch )) {
ConsumeLineEnding( ch );
bLineEnded = true;
break;
}
text.AppendUniChar( ch );
}
// Skip any whitespace between the tag name and the tag contents
if (!SkipWhitespaces( toss )) return false;
// Now that we have the tag name, we can create the appropriate class to represent
// it.
VString simpleText;
if (text == "author" && ConsumeComment( simpleText ))
{
fLastElement = new AuthorElement( simpleText );
}
else if (text == "alias" && ConsumeComment( simpleText ))
{
fLastElement = new AliasElement( simpleText );
}
else if (text == "attributes" && ConsumeComment( simpleText ))
{
fLastElement = new AttributesElement( simpleText );
}
else if (text == "class" && ConsumeComment( simpleText ))
{
fLastElement = new ClassElement( simpleText );
}
else if (text == "classDescription" && ConsumeComment( simpleText ))
{
fLastElement = new ClassDescriptionElement( simpleText );
}
else if (text == "constructor")
{
fLastElement = new ConstructorElement();
}
else if (text == "default" && ConsumeComment( simpleText ))
{
fLastElement = new DefaultElement(simpleText);
}
else if (text == "deprecated" && ConsumeComment( simpleText ))
{
fLastElement = new DeprecatedElement(simpleText);
}
else if (text == "exception")
{
return ConsumeExceptionTag();
}
else if ( (text == "extends" || text == "augments" || text == "inherits") && ConsumeComment( simpleText ))
{
fLastElement = new ExtendsElement(simpleText);
}
else if (text == "id" && ConsumeComment( simpleText ))
{
fLastElement = new IdElement( simpleText );
}
else if (text == "inherits" && ConsumeComment( simpleText ))
{
fLastElement = new InheritsElement( simpleText );
}
else if (text == "memberOf" && ConsumeComment( simpleText ))
{
fLastElement = new MemberOfElement( simpleText );
}
else if (text == "method")
{
return ConsumeMethodTag();
}
else if (text == "module" && ConsumeComment( simpleText ))
{
fLastElement = new ModuleElement( simpleText );
}
else if (text == "namespace" && ConsumeComment( simpleText ))
{
fLastElement = new NamespaceElement( simpleText );
}
else if (text == "param")
{
return ConsumeParamTag();
}
else if (text == "paramValue")
{
return ConsumeParamValueTag();
}
else if (text == "private")
{
fLastElement = new PrivateElement();
}
else if (text == "projectDescription" && ConsumeComment( simpleText ))
{
fLastElement = new ProjectDescriptionElement( simpleText );
}
else if (text == "property")
{
return ConsumePropertyTag();
}
else if ( (text == "require" ||text == "requires") && ConsumeComment( simpleText ))
{
fLastElement = new RequiresElement( simpleText );
}
else if (text == "return" || text == "returns" || text == "result")
{
return ConsumeReturnTag();
}
else if (text == "sdoc" && ConsumeComment( simpleText ))
{
fLastElement = new SDocElement( simpleText );
}
else if (text == "see")
{
return ConsumeSeeTag();
}
else if (text == "since" && ConsumeComment( simpleText ))
{
fLastElement = new SinceElement( simpleText );
}
else if (text == "static")
{
fLastElement = new StaticElement();
}
else if (text == "throws" || text == "throw")
{
return ConsumeThrowsTag();
}
else if (text == "type")
{
return ConsumeTypeTag();
}
else if (text == "version" && ConsumeComment( simpleText ))
{
fLastElement = new VersionElement( simpleText );
}
else
{
// This is an unsupported tag, so make an Unknown tag to handle it. Unknown tags can
// have comments following them, or just a newline signifying it's time for another tag.
// We don't know which it is supposed to be, so we will skip whitespaces and check to see
// if there's a newline. If there is, then it's assumed to be a tag with no comments.
if (bLineEnded || ConsumeComment( simpleText ))
{
fLastElement = new UnknownElement( text, simpleText );
}
else
{
return false;
}
}
return true;
}
void VSysLogOutput::Put( std::vector< const XBOX::VValueBag* >& inValuesVector)
{
for (std::vector< const XBOX::VValueBag* >::iterator bagIter = inValuesVector.begin() ; bagIter != inValuesVector.end() ; ++bagIter)
{
EMessageLevel bagLevel = ILoggerBagKeys::level.Get( *bagIter);
if ((fFilter & (1 << bagLevel)) != 0)
{
VString logMsg;
VError errorCode = VE_OK;
ILoggerBagKeys::error_code.Get( *bagIter, errorCode);
VString loggerID;
ILoggerBagKeys::source.Get( *bagIter, loggerID);
OsType componentSignature = 0;
if (!ILoggerBagKeys::component_signature.Get( *bagIter, componentSignature))
componentSignature = COMPONENT_FROM_VERROR( errorCode);
if (componentSignature != 0)
{
if (!loggerID.IsEmpty())
loggerID.AppendUniChar( L'.');
loggerID.AppendOsType( componentSignature);
}
if (!loggerID.IsEmpty())
logMsg.Printf( "[%S]", &loggerID);
// build message string
VString message;
if (errorCode != VE_OK)
message.AppendPrintf( "error %d", ERRCODE_FROM_VERROR( errorCode));
VString bagMsg;
if (ILoggerBagKeys::message.Get( *bagIter, bagMsg))
{
if (!message.IsEmpty())
message.AppendString( L", ");
message.AppendString( bagMsg);
}
sLONG taskId=-1;
if (ILoggerBagKeys::task_id.Get( *bagIter, taskId))
{
if (!message.IsEmpty())
message.AppendString( L", ");
message.AppendString( L"task #");
message.AppendLong( taskId);
}
VString taskName;
if (!ILoggerBagKeys::task_name.Get( *bagIter, taskName))
VTask::GetCurrent()->GetName( taskName);
if (!taskName.IsEmpty())
{
if (!message.IsEmpty())
message.AppendString( L", ");
message.AppendString( taskName);
}
sLONG socketDescriptor=-1;
if (ILoggerBagKeys::socket.Get( *bagIter, socketDescriptor))
{
if (!message.IsEmpty())
message.AppendString( L", ");
message.AppendString( L"socket ");
message.AppendLong(socketDescriptor);
}
VString localAddr;
if (ILoggerBagKeys::local_addr.Get( *bagIter, localAddr))
{
if (!message.IsEmpty())
message.AppendString( L", ");
message.AppendString( L"local addr is ");
message.AppendString( localAddr);
}
VString peerAddr;
if (ILoggerBagKeys::peer_addr.Get( *bagIter, peerAddr))
{
if (!message.IsEmpty())
message.AppendString( L", ");
message.AppendString( L"peer addr is ");
message.AppendString( peerAddr);
}
bool exchangeEndPointID=false;
if (ILoggerBagKeys::exchange_id.Get( *bagIter, exchangeEndPointID))
{
if (!message.IsEmpty())
message.AppendString( L", ");
message.AppendString( (exchangeEndPointID) ? L"exchange endpoint id" : L"do not exchange endpoint id");
}
bool isBlocking=false;
if (ILoggerBagKeys::is_blocking.Get( *bagIter, isBlocking))
{
if (!message.IsEmpty())
message.AppendString( L", ");
message.AppendString( (isBlocking) ? L"is blocking" : L"is not blocking");
}
bool isSSL=false;
if (ILoggerBagKeys::is_ssl.Get( *bagIter, isSSL))
{
if (!message.IsEmpty())
message.AppendString( L", ");
message.AppendString( (isSSL) ? L"with SSL" : L"without SSL");
}
bool isSelectIO=false;
if (ILoggerBagKeys::is_select_io.Get( *bagIter, isSelectIO))
{
if (!message.IsEmpty())
message.AppendString( L", ");
message.AppendString( (isSelectIO) ? L"with SelectIO" : L"without SelectIO");
}
sLONG ioTimeout=-1;
if (ILoggerBagKeys::ms_timeout.Get( *bagIter, ioTimeout))
{
if (!message.IsEmpty())
message.AppendString( L", ");
message.AppendString( L"with ");
message.AppendLong( ioTimeout);
message.AppendString( L"ms timeout");
}
sLONG askedCount=-1;
if (ILoggerBagKeys::count_bytes_asked.Get( *bagIter, askedCount))
{
if (!message.IsEmpty())
message.AppendString( L", ");
message.AppendString( L"asked for ");
message.AppendLong( askedCount);
message.AppendString( L" byte(s)");
}
sLONG sentCount=-1;
if (ILoggerBagKeys::count_bytes_sent.Get(*bagIter, sentCount))
{
if (!message.IsEmpty())
message.AppendString( L", ");
message.AppendString( L"sent ");
message.AppendLong( sentCount);
message.AppendString( L" byte(s)");
}
sLONG receivedCount=-1;
if (ILoggerBagKeys::count_bytes_received.Get( *bagIter, receivedCount))
{
if (!message.IsEmpty())
message.AppendString( L", ");
message.AppendString( L"received ");
message.AppendLong( receivedCount);
message.AppendString( L" byte(s)");
}
sLONG ioSpent=-1;
if (ILoggerBagKeys::ms_spent.Get( *bagIter, ioSpent))
{
if (!message.IsEmpty())
message.AppendString( L", ");
message.AppendString( L"done in ");
message.AppendLong( ioSpent);
message.AppendString( L"ms");
}
sLONG dumpOffset=-1;
if (ILoggerBagKeys::dump_offset.Get( *bagIter, dumpOffset))
{
if (!message.IsEmpty())
message.AppendString( L", ");
message.AppendString( L"offset ");
message.AppendLong( dumpOffset);
}
VString dumpBuffer;
if (ILoggerBagKeys::dump_buffer.Get( *bagIter, dumpBuffer))
{
if (!message.IsEmpty())
message.AppendString( L", ");
message.AppendString( L"data : ");
message.AppendString( dumpBuffer);
}
VString fileName;
if (ILoggerBagKeys::file_name.Get( *bagIter, fileName))
{
if (!message.IsEmpty())
message.AppendString( L", ");
message.AppendString( fileName);
}
sLONG lineNumber;
if (ILoggerBagKeys::line_number.Get( *bagIter, lineNumber))
{
if (!message.IsEmpty())
message.AppendString( L", ");
message.AppendLong( lineNumber);
}
VString stackCrawl;
if (ILoggerBagKeys::stack_crawl.Get( *bagIter, stackCrawl))
{
if (!message.IsEmpty())
message.AppendString( L", ");
message.AppendString( L", {");
stackCrawl.ExchangeAll( L"\n", L" ; ");
message.AppendString( stackCrawl);
message.AppendUniChar( L'}');
}
if (!logMsg.IsEmpty())
logMsg.AppendUniChar( L' ');
logMsg.AppendString( message);
if (!logMsg.IsEmpty())
{
StStringConverter<char> messageConverter( VTC_StdLib_char);
switch( bagLevel)
{
case EML_Dump:
case EML_Assert:
case EML_Debug:
syslog( LOG_DEBUG, messageConverter.ConvertString( logMsg));
break;
case EML_Trace:
syslog( LOG_NOTICE, messageConverter.ConvertString( logMsg));
break;
case EML_Information:
syslog( LOG_INFO, messageConverter.ConvertString( logMsg));
break;
case EML_Warning:
syslog( LOG_WARNING, messageConverter.ConvertString( logMsg));
break;
case EML_Error:
syslog( LOG_ERR, messageConverter.ConvertString( logMsg));
break;
case EML_Fatal:
syslog( LOG_CRIT, messageConverter.ConvertString( logMsg));
break;
default:
assert(false);
break;
}
}
}
}
}
void AppendJSONNewline(VString& outJSONString, bool prettyformat)
{
if (prettyformat)
outJSONString.AppendUniChar(10);
}
