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); }