bool Socket::Data::CloseRaw(int msecs_timeout)
{
if(socket == INVALID_SOCKET)
return false;
bool ok = !IsError() && Peek(msecs_timeout, true);
SOCKET old_socket = socket;
socket = INVALID_SOCKET;
if(old_socket != INVALID_SOCKET) {
SLOG("Socket::Data::CloseRaw(" << (int)old_socket << ")");
int res;
#if defined(PLATFORM_WIN32)
res = closesocket(old_socket);
#elif defined(PLATFORM_POSIX)
res = close(old_socket);
#else
#error Unsupported platform
#endif
if(res && !IsError()) {
SetSockError("close");
ok = false;
}
}
SLOG("//Socket::Data::CloseRaw, ok = " << ok);
return ok;
}
void CGCode3DParser::M26Command()
{
// set sd pos
if (!GetExecutingFile() || CControl::GetInstance()->PrintFromSDRunnding())
{
Error(MESSAGE_PARSER3D_NO_FILE_SELECTED);
return;
}
if (_reader->SkipSpacesToUpper() == 'S')
{
_reader->GetNextChar();
_state._printFilePos = GetUInt32();
_state._printFileLine = 1; // TO DO => count line
if (IsError()) return;
GetExecutingFile().seek(_state._printFilePos);
}
else if (_reader->GetCharToUpper() == 'L')
{
_reader->GetNextChar();
unsigned long lineNr = GetUInt32();
if (IsError()) return;
if (lineNr < 1)
{
Error(MESSAGE_PARSER3D_LINE_SEEK_ERROR);
return;
}
GetExecutingFile().seek(0);
for (unsigned long line = 1; line < lineNr; line++)
{
// read line until \n
char ch;
do
{
if (GetExecutingFile().available() == 0)
{
Error(MESSAGE_PARSER3D_LINE_SEEK_ERROR);
return;
}
ch = GetExecutingFile().read();
}
while (ch != '\n');
}
_state._printFileLine = lineNr;
_state._printFilePos = GetExecutingFile().position();
}
}
void EzSockets::update()
{
if (IsError()) //If socket is in error, don't bother.
return;
while (CanRead() && !IsError()) //Check for Reading
if (pUpdateRead() < 1)
break;
if (CanWrite() && (outBuffer.length()>0))
pUpdateWrite();
}
void FNameTableArchiveReader::Seek( int64 InPos )
{
if (!IsError())
{
Reader.Seek( InPos );
}
}
void FNameTableArchiveReader::Serialize( void* V, int64 Length )
{
if (!IsError())
{
Reader.Serialize( V, Length );
}
}
bool CAddModuleSession::OnProcessMessage (const SArchonMessage &Msg)
// OnProcessMessage
//
// Process a response
{
switch (m_iState)
{
case stateWaitForMsg:
{
if (IsError(Msg))
{
SendMessageReplyError(Msg.sMsg, Msg.dPayload.GetElement(0));
return false;
}
SendMessageReply(MSG_OK);
return false;
}
default:
return false;
}
}
CString CCInteger::Print (CCodeChain *pCC, DWORD dwFlags)
// Print
//
// Returns a text representation of this item
{
// If this is an error code, translate it
if (IsError())
{
switch (m_iValue)
{
case CCRESULT_NOTFOUND:
return strPatternSubst(LITERAL("[%d] Item not found."), m_iValue);
case CCRESULT_CANCEL:
return strPatternSubst(LITERAL("[%d] Operation canceled."), m_iValue);
case CCRESULT_DISKERROR:
return strPatternSubst(LITERAL("[%d] Disk error."), m_iValue);
default:
return strPatternSubst(LITERAL("[%d] Unknown error."), m_iValue);
}
}
// Otherwise, just print the integer value
else
return strFromInt(m_iValue, TRUE);
}
bool OGRCouchDBDataSource::IsOK(json_object* poAnswerObj,
const char* pszErrorMsg)
{
if ( poAnswerObj == NULL ||
!json_object_is_type(poAnswerObj, json_type_object) )
{
CPLError(CE_Failure, CPLE_AppDefined, "%s",
pszErrorMsg);
return false;
}
json_object* poOK = CPL_json_object_object_get(poAnswerObj, "ok");
if ( !poOK )
{
IsError(poAnswerObj, pszErrorMsg);
return false;
}
const char* pszOK = json_object_get_string(poOK);
if ( !pszOK || !CPLTestBool(pszOK) )
{
CPLError(CE_Failure, CPLE_AppDefined, "%s", pszErrorMsg);
return false;
}
return true;
}
bool BlockStream::SyncPos()
{
if(IsError())
return false;
SetPos(GetPos());
return SyncPage();
}
void FNameTableArchiveReader::Serialize( void* V, int64 Length )
{
if (FileAr && !IsError())
{
FileAr->Serialize( V, Length );
}
}
void FNameTableArchiveReader::Seek( int64 InPos )
{
if (FileAr && !IsError())
{
FileAr->Seek( InPos );
}
}
ThemeManager::ThemeManager(FAContext *pContext)
{
char szThemePath[_MAX_PATH];
uint32 len = _MAX_PATH;
Error eRet;
m_pContext = pContext;
m_oCurrentTheme = "";
m_bDevelTheme = false;
szThemePath[0] = 0;
eRet = pContext->prefs->GetPrefString(kThemePathPref, szThemePath, &len);
if (IsError(eRet) || strlen(szThemePath) == 0) {
m_oCurrentTheme = BRANDING_DEFAULT_THEME;
}
else {
struct stat buf;
m_oCurrentTheme = szThemePath;
if (stat(szThemePath, &buf) == 0 && S_ISDIR(buf.st_mode)) {
m_bDevelTheme = true;
m_oDevelTheme = m_oCurrentTheme;
m_oCurrentTheme = THEME_IN_DEVEL;
}
}
}
Value ConvertDate::Scan(const Value& text) const {
Value v = UPP::Scan(DATE_V, text, defaultval);
if(IsError(v)) return v;
if(IsNull(v)) return notnull ? NotNullError() : v;
Date m = v;
if(m >= minval && m <= maxval) return v;
return ErrorValue(t_("Date must be between ") + UPP::Format(minval) + t_("range\v and ") + UPP::Format(maxval) + ".");
}
int EzSockets::PeekData(char *data, unsigned int bytes)
{
if (blocking)
while ((inBuffer.length()<bytes) && !IsError())
pUpdateRead();
else
while (CanRead() && !IsError())
if (pUpdateRead()<1)
break;
int bytesRead = bytes;
if (inBuffer.length()<bytes)
bytesRead = inBuffer.length();
memcpy(data,inBuffer.c_str(), bytesRead);
return bytesRead;
}
void BlockStream::_Put(int c) {
if(!IsOpen()) return;
if(IsError() || !SyncPos())
ptr = buffer;
wrlim = buffer + pagesize;
pagedirty = true;
*ptr++ = c;
}
void EzSockets::SendData(const char *data, unsigned int bytes)
{
outBuffer.append(data, bytes);
if(blocking)
while ((outBuffer.length()>0) && !IsError())
pUpdateWrite();
else
update();
}
static kbool_t ParseJson(KonohaContext *kctx, struct JsonBuf *jsonbuf, const char *text, size_t length, KTraceInfo *trace)
{
JSON json = parseJSON((JSONMemoryPool *)(JSONAPI JsonHandler), text, text + length);
if(IsError(json.val)) {
KLIB KRuntime_raise(kctx, KException_("InvalidJsonText"), SoftwareFault, NULL, trace->baseStack);
}
jsonbuf->json_i = json.bits;
return jsonbuf->json_i != 0;
}
bool FNameTableArchiveReader::Precache( int64 PrecacheOffset, int64 PrecacheSize )
{
if (FileAr && !IsError())
{
return FileAr->Precache( PrecacheOffset, PrecacheSize );
}
return false;
}
/*********************\
| Raw Data System |
\*********************/
void EzSockets::SendData(const string& outData)
{
outBuffer.append(outData);
if(blocking)
while ((outBuffer.length()>0) && !IsError())
pUpdateWrite();
else
update();
}
void BlockStream::SetSize(int64 size)
{
if(IsError() || !IsOpen()) return;
int64 pos = GetPos();
Flush();
Seek(0);
SetStreamSize(size);
streamsize = size;
Seek(pos < size ? pos : size);
}
bool FNameTableArchiveReader::SerializeNameMap()
{
int64 NameOffset = 0;
*this << NameOffset;
if (IsError() || NameOffset > TotalSize())
{
// The file was corrupted. Return false to fail to load the cache an thus regenerate it.
return false;
}
if( NameOffset > 0 )
{
int64 OriginalOffset = Tell();
Seek( NameOffset );
int32 NameCount = 0;
*this << NameCount;
if (IsError())
{
return false;
}
for ( int32 NameMapIdx = 0; NameMapIdx < NameCount; ++NameMapIdx )
{
// Read the name entry from the file.
FNameEntrySerialized NameEntry(ENAME_LinkerConstructor);
*this << NameEntry;
if (IsError())
{
return false;
}
NameMap.Add(FName(NameEntry));
}
Seek( OriginalOffset );
}
return true;
}
MIValue const &MIValue::Get(int i) const
{
if(IsError())
return *this;
if(type == MIArray)
return array[i];
if(type == MITuple)
return tuple[i];
return ErrorMIValue("Not an Array value type");
}
wxString wxFileSystemWatcherEvent::ToString() const
{
if (IsError())
{
return wxString::Format("FSW_EVT type=%d (%s) message='%s'", m_changeType,
GetFSWEventChangeTypeName(m_changeType), GetErrorDescription());
}
return wxString::Format("FSW_EVT type=%d (%s) path='%s'", m_changeType,
GetFSWEventChangeTypeName(m_changeType), GetPath().GetFullPath());
}
// simple accessors
int MIValue::GetCount(void) const
{
if(IsError())
return 0;
if(type == MIArray)
return array.GetCount();
else if(type == MITuple)
return tuple.GetCount();
else
return string.GetCount();
}
dword FileStream::Read(int64 at, void *ptr, dword size) {
ASSERT(IsOpen() && (style & STRM_READ));
dword n;
SetPos(at);
if(IsError()) return 0;
if(!ReadFile(handle, ptr, size, (DWORD *)&n, NULL)) {
SetLastError();
return 0;
}
return n;
}
dword FileStream::Read(int64 at, void *ptr, dword size) {
ASSERT(IsOpen() && (style & STRM_READ));
SetPos(at);
if(IsError()) return 0;
int n = read(handle, ptr, size);
if(n < 0) {
SetLastError();
return 0;
}
return n;
}
/*getErrorMessage- return error string*/
char *DBConnection_ORACLE::getErrorMessage(Bool p_last)
{
// AL-2013-11-08 [[ Bug 11149 ]] Make sure most recent error string is available to revDatabaseConnectResult
if (p_last || IsError())
{
// OK-2007-09-10 : Bug 5360
if (m_error != NULL)
return m_error;
}
return (char *)DBNullValue;
}
int BlockStream::_Term() {
if(IsError() || !IsOpen()) return -1;
if(ptr < rdlim)
return *ptr;
if(SyncPos())
rdlim = buffer + (int)min<int64>(streamsize - pos, pagesize);
else {
rdlim = buffer;
return -1;
}
return ptr < rdlim ? *ptr : -1;
}
void BlockStream::Flush() {
if(!IsOpen() || IsError()) return;
if(pagedirty && pagepos >= 0) {
SyncSize();
int size = (int)min<int64>(streamsize - pagepos, pagesize);
LLOG("Write: " << pagepos << ", " << size);
Write(pagepos, buffer, size);
streamsize = max(streamsize, pagepos + size);
}
wrlim = buffer;
pagedirty = false;
}
void FileStream::Write(int64 at, const void *ptr, dword size) {
ASSERT(IsOpen() && (style & STRM_WRITE));
SetPos(at);
if(IsError()) return;
int n = write(handle, ptr, size);
if(n < 0) {
SetLastError();
return;
}
if((dword)n != size)
SetError(ERROR_NOT_ENOUGH_SPACE);
}
