CBufferedLineReader& CBufferedLineReader::operator++(void)
{
++m_LineNumber;
if ( m_UngetLine ) {
_ASSERT(m_Line.begin());
m_UngetLine = false;
return *this;
}
// check if we are at the buffer end
const char* start = m_Pos;
const char* end = m_End;
for ( const char* p = start; p < end; ++p ) {
if ( *p == '\n' ) {
m_Line = CTempString(start, p - start);
m_LastReadSize = p + 1 - start;
m_Pos = ++p;
if ( p == end ) {
m_String = m_Line;
m_Line = m_String;
x_ReadBuffer();
}
return *this;
}
else if ( *p == '\r' ) {
m_Line = CTempString(start, p - start);
m_LastReadSize = p + 1 - start;
if ( ++p == end ) {
m_String = m_Line;
m_Line = m_String;
if ( x_ReadBuffer() ) {
p = m_Pos;
if ( *p == '\n' ) {
m_Pos = p+1;
++m_LastReadSize;
}
}
return *this;
}
if ( *p != '\n' ) {
return *this;
}
++m_LastReadSize;
m_Pos = ++p;
if ( p == end ) {
m_String = m_Line;
m_Line = m_String;
x_ReadBuffer();
}
return *this;
}
}
x_LoadLong();
return *this;
}
bool CSearch_func :: x_StringMayContainPlural(const string& str) const
{
char last_letter, second_to_last_letter, next_letter;
bool may_contain_plural = false;
string word_skip = " ,";
unsigned len;
if (str.empty()) {
return false;
}
vector <string> arr;
arr = NStr::Tokenize(str, " ,", arr, NStr::eMergeDelims);
if (arr.size() == 1) { // doesn't have ', ', or the last char is ', '
len = arr[0].size();
if (len == 1) {
return false;
}
last_letter = arr[0][len-1];
second_to_last_letter = arr[0][len-2];
next_letter = (len == str.size()) ? ',' : str[len];
may_contain_plural = x_DoesStrContainPlural(arr[0],
last_letter,
second_to_last_letter,
next_letter);
}
else {
string strtmp(str);
size_t pos;
vector <string>::const_iterator jt;
ITERATE (vector <string>, it, arr) {
pos = strtmp.find(*it);
len = (*it).size();
if (len == 1) {
strtmp = CTempString(strtmp).substr(pos+len);
strtmp = NStr::TruncateSpaces(strtmp, NStr::eTrunc_Begin);
continue;
}
last_letter = (*it)[len-1];
second_to_last_letter = (*it)[len-2];
next_letter = (len == strtmp.size()) ? ',' : strtmp[pos+len];
may_contain_plural = x_DoesStrContainPlural(*it,
last_letter,
second_to_last_letter,
next_letter);
if (may_contain_plural) {
break;
}
jt = it;
if (++jt != arr.end()) { // not jt++
strtmp = CTempString(strtmp).substr(strtmp.find(*jt));
}
}
}
CTempString CObjectIStreamAsn::ScanEndOfId(bool isId)
{
if ( isId ) {
for ( size_t i = 1; ; ++i ) {
char c = m_Input.PeekCharNoEOF(i);
if ( !IdChar(c) &&
(c != '-' || !IdChar(m_Input.PeekChar(i + 1))) ) {
const char* ptr = m_Input.GetCurrentPos();
m_Input.SkipChars(i);
return CTempString(ptr, i);
}
}
}
return CTempString();
}
string CCompoundIDDumpParser::x_ReadString()
{
char quote_char;
if (x_EOF() || ((quote_char = *m_Ch) != '"' && quote_char != '\'')) {
x_SaveErrPos();
CID_PARSER_EXCEPTION("string must start with a quote character");
}
const char* str_begin = ++m_Ch;
bool escaped = false;
while (!x_EOF())
if (*m_Ch == quote_char && !escaped)
return NStr::ParseEscapes(
CTempString(str_begin, m_Ch++ - str_begin));
else if (*m_Ch == '\\') {
escaped = !escaped;
++m_Ch;
} else {
escaped = false;
if (*m_Ch++ == '\n') {
m_LineBegin = m_Ch;
++m_Line;
}
}
x_SaveErrPos();
CID_PARSER_EXCEPTION("unterminated quoted string");
}
void CDBL_Connection::x_SetExtraMsg(const I_BlobDescriptor& descr,
size_t data_size)
{
CNcbiOstrstream oss;
oss << "Data size: " << data_size;
if (descr.DescriptorType() == CDBL_BLOB_DESCRIPTOR_TYPE_MAGNUM) {
const CDBL_BlobDescriptor& dbldescr
= static_cast<const CDBL_BlobDescriptor&>(descr);
oss << " Destination: " << dbldescr.m_ObjName
<< " WHERE TEXTPTR(...) = 0x";
if ( !dbldescr.m_TxtPtr_is_NULL ) {
char buffer[DBTXPLEN * 2];
size_t n = impl::binary_to_hex_string
(buffer, sizeof(buffer), dbldescr.m_TxtPtr, DBTXPLEN,
impl::fB2H_NoFinalNul | impl::fB2H_NoPrefix);
oss << CTempString(buffer, n);
}
} else {
const CDB_BlobDescriptor* dbdescr
= dynamic_cast<const CDB_BlobDescriptor*>(&descr);
if (dbdescr != NULL) {
oss << " Destination: " << dbdescr->TableName() << '.'
<< dbdescr->ColumnName() << " WHERE "
<< dbdescr->SearchConditions();
}
}
string extra_msg = CNcbiOstrstreamToString(oss);
SetExtraMsg(extra_msg);
}
string ParseString()
{
size_t len;
string str(NStr::ParseQuoted(CTempString(m_Ch, GetRemainder()), &len));
m_Ch += len;
return str;
}
double CNetScheduleStructuredOutputParser::ParseDouble(size_t len)
{
double val = NStr::StringToDouble(CTempString(m_Ch, len));
m_Ch += len;
return val;
}
Uint8 CCompoundIDDumpParser::x_ReadInt8()
{
const char* token_begin = m_Ch;
x_SaveErrPos();
if (!x_EOF() && *m_Ch == '-')
++m_Ch;
if (x_EOF() || !isdigit(*m_Ch)) {
x_SaveErrPos();
CID_PARSER_EXCEPTION("missing integer value");
}
do
++m_Ch;
while (!x_EOF() && isdigit(*m_Ch));
Int8 result = NStr::StringToInt8(CTempString(token_begin,
m_Ch - token_begin), NStr::fConvErr_NoThrow);
if (result == 0 && errno != 0) {
CID_PARSER_EXCEPTION("integer overflow");
}
return result;
}
static void s_ResolveItems(CTypeInfo*& info, const char*& name,
ETypeFamily req_family)
{
TTypeInfo info0 = info;
const char* name0 = name;
while ( const char* dot = strchr(name, '.') ) {
CTempString item_name(name, dot-name);
TTypeInfo new_info;
switch ( info->GetTypeFamily() ) {
case eTypeFamilyClass:
new_info = dynamic_cast<CClassTypeInfo*>(info)
->GetMemberInfo(item_name)->GetTypeInfo();
break;
case eTypeFamilyChoice:
new_info = dynamic_cast<CChoiceTypeInfo*>(info)
->GetVariantInfo(item_name)->GetTypeInfo();
break;
case eTypeFamilyContainer:
if ( item_name != "E" ) {
NCBI_THROW_FMT(CSerialException,eInvalidData,
info0->GetName()<<'.'<<
CTempString(name0, name-name0)<<
": element name must be 'E'");
}
new_info = dynamic_cast<CContainerTypeInfo*>(info)
->GetElementType();
break;
default:
new_info = info;
break;
}
// skip all pointers (CRef<>)
while ( new_info->GetTypeFamily() == eTypeFamilyPointer ) {
new_info = dynamic_cast<const CPointerTypeInfo*>(new_info)
->GetPointedType();
}
info = const_cast<CTypeInfo*>(new_info);
name = dot+1;
}
if ( info->GetTypeFamily() != req_family ) {
NCBI_THROW_FMT(CSerialException,eInvalidData,
info0->GetName()<<'.'<<
CTempString(name0, name-name0)<<
": not a "<<
(req_family == eTypeFamilyClass? "class": "choice"));
}
}
string CNetScheduleStructuredOutputParser::ParseString(size_t max_len)
{
size_t len;
string val(NStr::ParseQuoted(CTempString(m_Ch, max_len), &len));
m_Ch += len;
return val;
}
void CBlastDbBlob::Clear()
{
m_Owner = true;
m_ReadOffset = 0;
m_WriteOffset = 0;
m_DataHere.resize(0);
m_DataRef = CTempString("");
m_Lifetime.Reset();
}
Uint8 CCompoundIDDumpParser::x_ReadUint8()
{
x_SaveErrPos();
if (x_EOF() || !isdigit(*m_Ch)) {
CID_PARSER_EXCEPTION("missing integer value");
}
const char* token_begin;
int base;
if (*m_Ch != '0') {
token_begin = m_Ch;
++m_Ch; // A digit other than '0', moving on...
base = 10;
} else {
++m_Ch; // Skip the leading zero.
if (x_EOF())
return 0;
switch (*m_Ch) {
case 'b':
case 'B':
token_begin = ++m_Ch;
base = 2;
break;
case 'x':
case 'X':
token_begin = ++m_Ch;
base = 16;
break;
default:
if (!isdigit(*m_Ch))
return 0;
token_begin = m_Ch;
++m_Ch; // It's a digit; move on to the next character.
base = 8;
}
}
while (!x_EOF() && isalnum(*m_Ch))
++m_Ch;
Uint8 result = NStr::StringToUInt8(CTempString(token_begin,
m_Ch - token_begin), NStr::fConvErr_NoThrow, base);
if (result == 0 && errno != 0) {
CID_PARSER_EXCEPTION("invalid Uint8 number specification");
}
return result;
}
TMemberIndex CObjectIStreamAsn::GetAltItemIndex(
const CClassTypeInfoBase* classType,
const CTempString& id,
const TMemberIndex pos /*= kInvalidMember*/)
{
TMemberIndex idx = kInvalidMember;
if (!id.empty()) {
const CItemsInfo& info = classType->GetItems();
string id_alt = string(id);
id_alt[0] = toupper((unsigned char)id_alt[0]);
if (pos != kInvalidMember) {
idx = info.Find(CTempString(id_alt),pos);
} else {
idx = info.Find(CTempString(id_alt));
}
if (idx != kInvalidMember &&
!info.GetItemInfo(idx)->GetId().HaveNoPrefix()) {
idx = kInvalidMember;
}
}
return idx;
}
void g_VerifyAlphabet(const string& str, const CTempString& param_name,
ECharacterClass char_class)
{
char bad_char;
if (!g_CheckAlphabet(str, param_name, char_class, &bad_char)) {
NCBI_THROW_FMT(CConfigException, eParameterMissing,
"Invalid character '" <<
NStr::PrintableString(CTempString(&bad_char, 1)) <<
"' in the " << param_name << " \"" <<
NStr::PrintableString(str) << "\".");
}
}
CJsonNode g_GenericStatToJson(CNetServer server,
ENetScheduleStatTopic topic, bool verbose)
{
string stat_cmd(s_StatTopics[topic].command);
CTempString prefix(s_StatTopics[topic].record_prefix);
CTempString entity_name(s_StatTopics[topic].entity_name);
if (verbose)
stat_cmd.append(" VERBOSE");
CNetServerMultilineCmdOutput output(server.ExecWithRetry(stat_cmd, true));
CJsonNode entities(CJsonNode::NewArrayNode());
CJsonNode entity_info;
CJsonNode array_value;
string line;
while (output.ReadLine(line)) {
if (NStr::StartsWith(line, prefix)) {
if (entity_info)
entities.Append(entity_info);
entity_info = CJsonNode::NewObjectNode();
entity_info.SetString(entity_name, UnquoteIfQuoted(
CTempString(line.data() + prefix.length(),
line.length() - prefix.length())));
} else if (entity_info && NStr::StartsWith(line, " ")) {
if (NStr::StartsWith(line, " ") && array_value) {
array_value.AppendString(UnquoteIfQuoted(
NStr::TruncateSpaces(line, NStr::eTrunc_Begin)));
} else {
if (array_value)
array_value = NULL;
CTempString key, value;
NStr::SplitInTwo(line, ":", key, value);
NormalizeStatKeyName(key);
string key_norm(key);
value = NStr::TruncateSpaces_Unsafe(value, NStr::eTrunc_Begin);
if (value.empty())
entity_info.SetByKey(key_norm, array_value =
CJsonNode::NewArrayNode());
else
entity_info.SetByKey(key_norm, CJsonNode::GuessType(value));
}
}
}
if (entity_info)
entities.Append(entity_info);
return entities;
}
CTempString CObjectIStreamAsn::ReadNumber(void)
{
char c = SkipWhiteSpace();
if ( c != '-' && c != '+' && !isdigit((unsigned char) c) )
ThrowError(fFormatError, "invalid number");
for ( size_t i = 1; ; ++i ) {
c = m_Input.PeekChar(i);
if ( !isdigit((unsigned char) c) ) {
const char* ptr = m_Input.GetCurrentPos();
m_Input.SkipChars(i);
return CTempString(ptr, i);
}
}
}
bool g_FixMisplacedPID(CJsonNode& stat_info, CTempString& executable_path,
const char* pid_key)
{
SIZE_TYPE misplaced_pid = NStr::Find(executable_path, "; PID: ");
if (misplaced_pid == NPOS)
return false;
SIZE_TYPE pos = misplaced_pid + sizeof("; PID: ") - 1;
stat_info.SetInteger(pid_key, NStr::StringToInt8(
CTempString(executable_path.data() + pos,
executable_path.length() - pos)));
executable_path.erase(misplaced_pid);
return true;
}
Int8 CNetScheduleStructuredOutputParser::ParseInt(size_t len)
{
Int8 val = NStr::StringToInt8(CTempString(m_Ch, len));
if (*m_Ch == '-') {
++m_Ch;
--len;
}
if (*m_Ch == '0' && len > 1) {
NCBI_THROW2(CStringException, eFormat,
"Leading zeros are not allowed", GetPosition());
}
m_Ch += len;
return val;
}
CJsonNode CExecAndParseStructuredOutput::ParseNode()
{
switch (*m_Ch) {
case '[':
++m_Ch;
return ParseArray();
case '{':
++m_Ch;
return ParseObject(false);
case '\'': case '"':
return CJsonNode::NewStringNode(ParseString());
}
size_t max_len = GetRemainder();
size_t len = 1;
switch (*m_Ch) {
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
while (len <= max_len && isdigit(m_Ch[len]))
++len;
{
CJsonNode::TNumber val(NStr::StringToInt8(CTempString(m_Ch, len)));
m_Ch += len;
return CJsonNode::NewNumberNode(val);
}
case 'F': case 'f': case 'N': case 'n':
case 'T': case 't': case 'Y': case 'y':
while (len <= max_len && isalpha(m_Ch[len]))
++len;
{
bool val(NStr::StringToBool(CTempString(m_Ch, len)));
m_Ch += len;
return CJsonNode::NewBooleanNode(val);
}
}
return CJsonNode();
}
bool CSearch_func :: x_DoesStrContainPlural(const string& word, char last_letter, char second_to_last_letter, char next_letter) const
{
unsigned len = word.size();
if (last_letter == 's') {
if (len >= 5 && CTempString(word).substr(len-5) == "trans") {
return false; // not plural;
}
else if (len > 3) {
if (second_to_last_letter != 's'
&& second_to_last_letter != 'i'
&& second_to_last_letter != 'u'
&& next_letter == ',') {
return true;
}
}
}
return false;
};
static TReadId sx_GetReadId(const string& sra, bool with_chunk)
{
SIZE_TYPE dot1 = sra.find('.');
if ( dot1 == NPOS ) {
return TReadId();
}
SIZE_TYPE dot2 = with_chunk? sra.find('.', dot1+1): sra.size();
if ( dot2 == NPOS || dot1+1 >= dot2 || sra[dot1+1] == '0' ||
(with_chunk && (dot2+2 != sra.size() ||
(sra[dot2+1] != '2' && sra[dot2+1] != '4') )) ) {
return TReadId();
}
unsigned spot_id =
NStr::StringToUInt(CTempString(sra.data()+dot1+1, dot2-dot1-1));
TReadId ret;
ret.first = new CSRABlobId(sra.substr(0, dot1), spot_id);
ret.second = sra[dot2+1] - '0';
return ret;
}
CTempString CObjectIStreamAsn::ReadTypeId(char c)
{
if ( c == '[' ) {
for ( size_t i = 1; ; ++i ) {
switch ( m_Input.PeekChar(i) ) {
case '\r':
case '\n':
ThrowError(fFormatError, "end of line: expected ']'");
break;
case ']':
{
const char* ptr = m_Input.GetCurrentPos();
m_Input.SkipChars(i);
return CTempString(ptr + 1, i - 2);
}
}
}
}
else {
return ScanEndOfId(FirstIdChar(c));
}
}
CTempString CBlastDbBlob::x_ReadString(EStringFormat fmt, int * offsetp) const
{
int sz = 0;
if (fmt == eSize4) {
sz = x_ReadIntFixed<int,4>(offsetp);
} else if (fmt == eSizeVar) {
sz = x_ReadVarInt(offsetp);
}
const char * datap = "";
if (fmt == eNUL) {
CTempString ts = Str();
int zoffset = -1;
for(size_t i = *offsetp; i < ts.size(); i++) {
if (ts[i] == (char)0) {
zoffset = i;
break;
}
}
if (zoffset == -1) {
NCBI_THROW(CSeqDBException,
eFileErr,
"CBlastDbBlob::ReadString: Unterminated string.");
}
datap = ts.data() + *offsetp;
sz = zoffset - *offsetp;
*offsetp = zoffset+1;
} else {
datap = x_ReadRaw(sz, offsetp);
}
return CTempString(datap, sz);
}
CMemoryLineReader& CMemoryLineReader::operator++(void)
{
const char* p = m_Pos;
if ( p == m_Line.begin() ) {
p = m_Line.end();
}
else {
while ( p < m_End && *p != '\r' && *p != '\n' ) {
++p;
}
m_Line = CTempString(m_Pos, p - m_Pos);
}
// skip over delimiters
if (p + 1 < m_End && *p == '\r' && p[1] == '\n') {
m_Pos = p + 2;
} else if (p < m_End) {
m_Pos = p + 1;
} else { // no final line break
m_Pos = p;
}
++m_LineNumber;
return *this;
}
bool CODBC_BCPInCmd::Send(void)
{
char param_buff[2048]; // maximal row size, assured of buffer overruns
if (!x_AssignParams(param_buff)) {
SetHasFailed();
string err_message = "Cannot assign params." + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 423004 );
}
SetWasSent();
if (bcp_sendrow(GetHandle()) != SUCCEED) {
SetHasFailed();
ReportErrors();
string err_message = "bcp_sendrow failed." + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 423005 );
}
if (m_HasTextImage) { // send text/image data
char buff[1800]; // text/image page size
for (unsigned int i = 0; i < GetBindParamsImpl().NofParams(); ++i) {
if (GetBindParamsImpl().GetParamStatus(i) == 0)
continue;
CDB_Object& param = *GetBindParamsImpl().GetParam(i);
if (param.GetType() != eDB_Image &&
(param.GetType() != eDB_Text || param.IsNULL()))
continue;
CDB_Stream& val = dynamic_cast<CDB_Stream&> (param);
size_t left_bytes = val.Size();
size_t len = 0;
size_t valid_len = 0;
size_t invalid_len = 0;
do {
invalid_len = len - valid_len;
if (valid_len < len) {
memmove(buff, buff + valid_len, invalid_len);
}
len = val.Read(buff + invalid_len, sizeof(buff) - invalid_len);
if (len > left_bytes) {
len = left_bytes;
}
valid_len = CUtf8::GetValidBytesCount( CTempString(buff, len));
CODBCString odbc_str(buff, len);
// !!! TODO: Decode to UCS2 if needed !!!!
if (bcp_moretext(GetHandle(),
(DBINT) valid_len,
(LPCBYTE)static_cast<const char*>(odbc_str)
) != SUCCEED) {
SetHasFailed();
ReportErrors();
string err_text;
if (param.GetType() == eDB_Text) {
err_text = "bcp_moretext for text failed.";
} else {
err_text = "bcp_moretext for image failed.";
}
err_text += GetDbgInfo();
DATABASE_DRIVER_ERROR( err_text, 423006 );
}
if (!valid_len) {
break;
}
left_bytes -= valid_len;
} while (left_bytes);
}
}
return true;
}
CTempString CStreamLineReader::operator*(void) const
{
_ASSERT(!m_UngetLine);
return CTempString(m_Line);
}
bool CJsonOverUTTPReader::ReadMessage(CUTTPReader& reader)
{
for (;;)
switch (reader.GetNextEvent()) {
case CUTTPReader::eChunkPart:
switch (m_State) {
case eExpectNextToken:
m_State = eReadingString;
m_CurrentChunk.assign(reader.GetChunkPart(),
reader.GetChunkPartSize());
break;
case eReadingString:
m_CurrentChunk.append(reader.GetChunkPart(),
reader.GetChunkPartSize());
break;
case eReadingDouble:
// The underlying transport protocol guarantees
// that m_Double boundaries will not be exceeded.
memcpy(m_DoublePtr, reader.GetChunkPart(),
reader.GetChunkPartSize());
m_DoublePtr += reader.GetChunkPartSize();
break;
default: /* case eMessageComplete: */
goto ThrowUnexpectedTrailingToken;
}
break;
case CUTTPReader::eChunk:
switch (m_State) {
case eExpectNextToken:
m_CurrentChunk.assign(reader.GetChunkPart(),
reader.GetChunkPartSize());
break;
case eReadingString:
m_State = eExpectNextToken;
m_CurrentChunk.append(reader.GetChunkPart(),
reader.GetChunkPartSize());
break;
case eReadingDouble:
m_State = eExpectNextToken;
memcpy(m_DoublePtr, reader.GetChunkPart(),
reader.GetChunkPartSize());
if (m_DoubleEndianness != DOUBLE_PREFIX)
reverse(reinterpret_cast<char*>(&m_Double),
reinterpret_cast<char*>(&m_Double + 1));
if (!x_AddNewNode(CJsonNode::NewDoubleNode(m_Double)))
m_State = eMessageComplete;
continue;
default: /* case eMessageComplete: */
goto ThrowUnexpectedTrailingToken;
}
if (!m_CurrentNode) {
m_CurrentNode = CJsonNode::NewStringNode(m_CurrentChunk);
m_State = eMessageComplete;
} else if (m_HashValueIsExpected) {
m_HashValueIsExpected = false;
m_CurrentNode.SetString(m_HashKey, m_CurrentChunk);
} else
// The current node is either a JSON object or an array,
// because if it was a non-container node, m_State would
// be eMessageComplete.
if (m_CurrentNode.IsArray())
m_CurrentNode.AppendString(m_CurrentChunk);
else {
m_HashKey = m_CurrentChunk;
m_HashValueIsExpected = true;
}
break;
case CUTTPReader::eControlSymbol:
{
char control_symbol = reader.GetControlSymbol();
if (control_symbol == '\n') {
if (m_State != eMessageComplete) {
NCBI_THROW(CJsonOverUTTPException, eUnexpectedEOM,
"JSON-over-UTTP: Unexpected end of message");
}
return true;
}
if (m_State != eExpectNextToken)
goto ThrowChunkContinuationExpected;
switch (control_symbol) {
case '[':
case '{':
{
CJsonNode new_node(control_symbol == '[' ?
CJsonNode::NewArrayNode() :
CJsonNode::NewObjectNode());
if (x_AddNewNode(new_node)) {
m_NodeStack.push_back(m_CurrentNode);
m_CurrentNode = new_node;
}
}
break;
case ']':
case '}':
if (!m_CurrentNode ||
(control_symbol == ']') ^ m_CurrentNode.IsArray()) {
NCBI_THROW(CJsonOverUTTPException, eUnexpectedClosingBracket,
"JSON-over-UTTP: Unexpected closing bracket");
}
if (m_NodeStack.empty())
m_State = eMessageComplete;
else {
m_CurrentNode = m_NodeStack.back();
m_NodeStack.pop_back();
}
break;
case 'D':
case 'd':
switch (reader.ReadRawData(sizeof(double))) {
default: /* case CUTTPReader::eEndOfBuffer: */
m_State = eReadingDouble;
m_DoubleEndianness = control_symbol;
m_DoublePtr = reinterpret_cast<char*>(&m_Double);
return false;
case CUTTPReader::eChunkPart:
m_State = eReadingDouble;
m_DoubleEndianness = control_symbol;
memcpy(&m_Double, reader.GetChunkPart(),
reader.GetChunkPartSize());
m_DoublePtr = reinterpret_cast<char*>(&m_Double) +
reader.GetChunkPartSize();
break;
case CUTTPReader::eChunk:
_ASSERT(reader.GetChunkPartSize() == sizeof(double));
if (control_symbol == DOUBLE_PREFIX)
memcpy(&m_Double, reader.GetChunkPart(),
sizeof(double));
else {
// Copy the entire chunk to
// m_Double in reverse order.
const char* src = reader.GetChunkPart();
char* dst = reinterpret_cast<char*>(&m_Double + 1);
int count = sizeof(double);
do
*--dst = *src++;
while (--count > 0);
}
if (!x_AddNewNode(CJsonNode::NewDoubleNode(m_Double)))
m_State = eMessageComplete;
}
break;
case 'Y':
if (!x_AddNewNode(CJsonNode::NewBooleanNode(true)))
m_State = eMessageComplete;
break;
case 'N':
if (!x_AddNewNode(CJsonNode::NewBooleanNode(false)))
m_State = eMessageComplete;
break;
case 'U':
if (!x_AddNewNode(CJsonNode::NewNullNode()))
m_State = eMessageComplete;
break;
default:
NCBI_THROW_FMT(CJsonOverUTTPException,
eUnknownControlSymbol,
"JSON-over-UTTP: Unknown control symbol '" <<
NStr::PrintableString(CTempString(&control_symbol,
1)) << '\'');
}
}
break;
case CUTTPReader::eNumber:
switch (m_State) {
case eExpectNextToken:
if (!x_AddNewNode(CJsonNode::NewIntegerNode(reader.GetNumber())))
m_State = eMessageComplete;
break;
case eMessageComplete:
goto ThrowUnexpectedTrailingToken;
default:
goto ThrowChunkContinuationExpected;
}
break;
case CUTTPReader::eEndOfBuffer:
return false;
default: /* case CUTTPReader::eFormatError: */
NCBI_THROW(CJsonOverUTTPException, eUTTPFormatError,
"JSON-over-UTTP: UTTP format error");
}
ThrowUnexpectedTrailingToken:
NCBI_THROW(CJsonOverUTTPException, eUnexpectedTrailingToken,
"JSON-over-UTTP: Received a token while expected EOM");
ThrowChunkContinuationExpected:
NCBI_THROW(CJsonOverUTTPException, eChunkContinuationExpected,
"JSON-over-UTTP: Chunk continuation expected");
}
CStringUTF8 CHTMLHelper::HTMLDecode(const string& str, EEncoding encoding,
THTMLDecodeFlags* result_flags)
{
CStringUTF8 ustr;
THTMLDecodeFlags result = 0;
if (encoding == eEncoding_Unknown) {
encoding = CUtf8::GuessEncoding(str);
if (encoding == eEncoding_Unknown) {
NCBI_THROW2(CStringException, eBadArgs,
"Unable to guess the source string encoding", 0);
}
}
// wild guess...
ustr.reserve(str.size());
string::const_iterator i, e = str.end();
char ch;
TUnicodeSymbol uch;
for (i = str.begin(); i != e;) {
ch = *(i++);
//check for HTML entities and character references
if (i != e && ch == '&') {
string::const_iterator itmp, end_of_entity, start_of_entity;
itmp = end_of_entity = start_of_entity = i;
bool ent, dec, hex, parsed=false;
ent = isalpha((unsigned char)(*itmp)) != 0;
dec = !ent && *itmp == '#' && ++itmp != e &&
isdigit((unsigned char)(*itmp)) != 0;
hex = !dec && itmp != e &&
(*itmp == 'x' || *itmp == 'X') && ++itmp != e &&
isxdigit((unsigned char)(*itmp)) != 0;
start_of_entity = itmp;
if (itmp != e && (ent || dec || hex)) {
// do not look too far
for (int len=0; len<16 && itmp != e; ++len, ++itmp) {
if (*itmp == '&' || *itmp == '#') {
break;
}
if (*itmp == ';') {
end_of_entity = itmp;
break;
}
ent = ent && isalnum( (unsigned char)(*itmp)) != 0;
dec = dec && isdigit( (unsigned char)(*itmp)) != 0;
hex = hex && isxdigit((unsigned char)(*itmp)) != 0;
}
if (end_of_entity != i && (ent || dec || hex)) {
uch = 0;
if (ent) {
string entity(start_of_entity,end_of_entity);
const struct tag_HtmlEntities* p = s_HtmlEntities;
for ( ; p->u != 0; ++p) {
if (entity.compare(p->s) == 0) {
uch = p->u;
parsed = true;
result |= fCharRef_Entity;
break;
}
}
} else {
parsed = true;
result |= fCharRef_Numeric;
for (itmp = start_of_entity;
itmp != end_of_entity; ++itmp) {
TUnicodeSymbol ud = *itmp;
if (dec) {
uch = 10 * uch + (ud - '0');
} else if (hex) {
if (ud >='0' && ud <= '9') {
ud -= '0';
} else if (ud >='a' && ud <= 'f') {
ud -= 'a';
ud += 10;
} else if (ud >='A' && ud <= 'F') {
ud -= 'A';
ud += 10;
}
uch = 16 * uch + ud;
}
}
}
if (parsed) {
ustr += CUtf8::AsUTF8(&uch,1);
i = ++end_of_entity;
continue;
}
}
}
}
// no entity - append as is
if (encoding == eEncoding_UTF8 || encoding == eEncoding_Ascii) {
ustr.append( 1, ch );
} else {
result |= fEncoding;
ustr += CUtf8::AsUTF8(CTempString(&ch,1), encoding);
}
}
if (result_flags) {
*result_flags = result;
}
return ustr;
}
operator CTempString(void) const
{
return CTempString(GetString(), GetLength());
}
CTempString operator*(void) const {
return CTempString(m_ConvLine);
}
