Esempio n. 1
0
int CStdInStream::GetChar()
{
  int c = getc(_stream);
  if(c == EOF && !Eof())
    throw kReadErrorMessage;
  return c;
}
Esempio n. 2
0
void LcfReader::SkipDebug(const struct LcfReader::Chunk& chunk_info, const char* srcfile) {
	// Dump the Chunk Data in Debug Mode
#ifdef _WIN32
	const char* srcfilename = strrchr(srcfile, '\\');
#else
	const char* srcfilename = strrchr(srcfile, '/');
#endif
	if (srcfilename == NULL) {
		srcfilename = srcfile;
	} else {
		srcfilename++;
	}
	fprintf(stderr, "Skipped Chunk %02X (%d byte) in lcf at %X (%s)\n",
			chunk_info.ID, chunk_info.length,  Tell(),
			srcfilename);
	for (uint32_t i = 0; i < chunk_info.length; ++i) {
		uint8_t byte;
		LcfReader::Read(byte);
		fprintf(stderr, "%02X ", byte);
		if ((i+1) % 16 == 0) {
			fprintf(stderr, "\n");
		}
		if (Eof()) {
			break;
		}
	}
	fprintf(stderr, "\n");
}
bool wxPipeInputStream::CanRead() const
{
    if ( m_lasterror == wxSTREAM_EOF )
        return false;

    // check if there is any input available
    struct timeval tv;
    tv.tv_sec = 0;
    tv.tv_usec = 0;

    const int fd = m_file->fd();

    fd_set readfds;
    FD_ZERO(&readfds);
    FD_SET(fd, &readfds);
    switch ( select(fd + 1, &readfds, NULL, NULL, &tv) )
    {
        case -1:
            wxLogSysError(_("Impossible to get child process input"));
            // fall through

        case 0:
            return false;

        default:
            wxFAIL_MSG(_T("unexpected select() return value"));
            // still fall through

        case 1:
            // input available -- or maybe not, as select() returns 1 when a
            // read() will complete without delay, but it could still not read
            // anything
            return !Eof();
    }
}
Esempio n. 4
0
void ASNLexer::LookupTag(void)
{
    while ( true ) {
        char c = Char();
        switch ( c ) {
        case '\r':
        case '\n':
            LexerWarning("unclosed tag", 11);
            return;
        case 0:
            if ( Eof() ) {
                LexerWarning("unclosed tag", 12);
                return;
            }
            AddChar();
            LexerWarning("illegal character in tag", 13);
            break;
        case ']':
            AddChar();
            return;
        case '0': case '1': case '2': case '3': case '4':
        case '5': case '6': case '7': case '8': case '9':
        // case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
            AddChar();
            break;
        default:
            AddChar();
            LexerWarning("illegal character in tag", 14);
            break;
        }
    }
}
Esempio n. 5
0
int CStdInStream::GetChar()
{
  int c = fgetc(_stream); // getc() doesn't work in BeOS?
  if (c == EOF && !Eof())
    throw kReadErrorMessage;
  return c;
}
Esempio n. 6
0
void ASNLexer::SkipComment(void)
{
    CComment& comment = AddComment();
    while ( true ) {
        // wait for end of comments
        char c = Char();
        switch ( c ) {
        case '\n':
            SkipChar();
            NextLine();
            return;
        case 0:
            if ( Eof() )
                return;
            break;
        case '-':
            if ( Char(1) == '-' ) {
                SkipChars(2);
                return;
            }
            break;
        case '*':
            if ( Char(1) == '/' ) {
                SkipChars(2);
                return;
            }
            break;
        }
        comment.AddChar(c);
        SkipChar();
    }
}
TStr THttpLx::GetRespReasonPhrase(){
  GetLws();
  TChA RPStr;
  while (!Eof()&&ChDef.IsText(Ch)&&(Ch!=TCh::CrCh)&&(Ch!=TCh::LfCh)){
    RPStr+=Ch; GetCh();}
  return RPStr;
}
Esempio n. 8
0
void ImageSectionsReader::Next(void)
{
	if(Eof()) return;

	m_SectionsLeft--;
	m_Section = (PIMAGE_SECTION_HEADER) PtrFromRva( m_Section, sizeof(IMAGE_SECTION_HEADER) );
}
Esempio n. 9
0
wxArrayString CTextFile::ReadLines(EReadTextFile flags, const wxMBConv& conv)
{
	wxArrayString lines;

	while (!Eof()) {
		wxString line = GetNextLine(conv);

		if (flags & txtStripWhitespace) {
			line = line.Strip(wxString::both);
		}

		if (flags & txtIgnoreEmptyLines) {
			if (line.IsEmpty()) {
				continue;
			}
		}
		
		if (flags & txtIgnoreComments) {
			if (flags & txtStripWhitespace) {
				if (line.StartsWith(wxT("#"))) {
					continue;
				}
			} else if (line.Strip(wxString::leading).StartsWith(wxT("#"))) {
				continue;
			}
		}

		lines.Add(line);
	}

	return lines;
}
Esempio n. 10
0
bool CFCMReadFile::ParsingTextFile(CString szDelimiter)
{
	if(!IsOpen())
	{
		return false;
	}

	CString szLine;

	ResetData();
	// m_nCols = GetNumberColums(szDelimiter);
	m_nCols = GetNumberColumsMulti(szDelimiter);

	while(!Eof())
	{
		if(ReadLine(szLine))
		{
			if (!szLine.IsEmpty()) {
				++m_nRows;
				//ParsingLine(szLine, szDelimiter);
				ParsingLineMulti(szLine, szDelimiter);
			}
		}
	};

	return true;
}
Esempio n. 11
0
TStr THttpLx::GetUrlStr(){
  TChA UrlChA;
  while ((!Eof())&&(!ChDef.IsSp(Ch))){
    UrlChA+=Ch; GetCh();}
  if (UrlChA.Empty()){
    throw THttpEx(heUrlEmpty);}
  return UrlChA;
}
Esempio n. 12
0
void ImageSectionsReader::Next(DWORD characteristicsFilter)
{
	for(;!Eof();Next())
	{
		if(characteristicsFilter == (m_Section->Characteristics & characteristicsFilter))
			break;
	}
}
Esempio n. 13
0
int FileStream::ReadLine(void * data, int maxsize)
{
    char * buf = (char *)data;
    int size = 0;

    if (!Eof())
    {
        char c = 0;

        while (size < maxsize && c != '\n' && !Eof())
        {
			mFile.Read(&c, sizeof(char), 1);
            buf[size++] = c;
        }
    }

    return size;
}
Esempio n. 14
0
int FileStream::SkipLine()
{
    int size = 0;

    if (!Eof())
    {
        char c;

        mFile.Read(&c, sizeof(char), 1);

        while (c != '\n' && !Eof())
        {
            ++size;
        }
    }

    return size;
}
Esempio n. 15
0
// Plain text, up until an angled bracket
bool wxSimpleHtmlParser::ParseText(wxString& text)
{
    while (!Eof() && GetChar(m_pos) != wxT('<'))
    {
        text += GetChar(m_pos);
        m_pos ++;
    }
    return TRUE;
}
Esempio n. 16
0
char InSituStringStream::GetClear()
{
    // get the character and then clear value
    if (Eof())
        return 0;
    char value = *src_;
    *src_++ = 0;
    return value;
}
Esempio n. 17
0
bool TSIn::GetNextLn(TChA& LnChA){
  LnChA.Clr();
  while (!Eof()){
    const char Ch=GetCh();
    if (Ch=='\n'){return true;}
    if (Ch=='\r' && PeekCh()=='\n'){GetCh(); return true;}
    LnChA.AddCh(Ch);
  }
  return !LnChA.Empty();
}
Esempio n. 18
0
bool wxSimpleHtmlParser::ParseAttributes(wxSimpleHtmlTag* tag)
{
    // Parse attributes of a tag header until we reach >
    while (!IsTagEndBracket(GetChar(m_pos)) && !Eof())
    {
        EatWhitespace();

        wxString attrName, attrValue;

        if (IsString())
        {
            ReadString(attrName, TRUE);
            tag->AppendAttribute(attrName, wxEmptyString);
        }
        else if (IsNumeric(GetChar(m_pos)))
        {
            ReadNumber(attrName, TRUE);
            tag->AppendAttribute(attrName, wxEmptyString);
        }
        else
        {
            // Try to read an attribute name/value pair, or at least a name
            // without the value
            ReadLiteral(attrName, TRUE);
            EatWhitespace();

            if (GetChar(m_pos) == wxT('='))
            {
                m_pos ++;
                EatWhitespace();

                if (IsString())
                    ReadString(attrValue, TRUE);
                else if (!Eof() && !IsTagEndBracket(GetChar(m_pos)))
                    ReadLiteral(attrValue, TRUE);
            }
            if (!attrName.IsEmpty())
                tag->AppendAttribute(attrName, attrValue);
        }
    }
    return TRUE;
}
Esempio n. 19
0
char ReadFileStream::Get()
{
    char c = *current_;
    if (!Eof())
    {
        current_++;
        count_++;
        Read();
    }
    return c;
}
Esempio n. 20
0
THttpRqMethod THttpLx::GetRqMethod(){
  TChA MethodNm;
  while (!Eof() && ChDef.IsAlpha(Ch)){
    MethodNm+=Ch; GetCh();}
  THttpRqMethod Method=hrmUndef;
  if (MethodNm==THttp::GetMethodNm){Method=hrmGet;}
  else if (MethodNm==THttp::HeadMethodNm){Method=hrmHead;}
  else if (MethodNm==THttp::PostMethodNm){Method=hrmPost;}
  if (Method==hrmUndef){throw THttpEx(heMethodNmExpected);}
  return Method;
}
Esempio n. 21
0
PUrl THttpLx::GetUrl(){
  TChA UrlChA;
  while ((!Eof())&&(!ChDef.IsSp(Ch))){
    UrlChA+=Ch; GetCh();}
  if (UrlChA.Empty()){
    throw THttpEx(heUrlEmpty);}
  static TStr LocalBaseUrlStr="http://localhost/";
  PUrl Url=PUrl(new TUrl(UrlChA, LocalBaseUrlStr));
  if (!Url->IsOk()){
    throw THttpEx(heBadUrl);}
  return Url;
}
Esempio n. 22
0
bool wxSimpleHtmlParser::ParseComment()
{
    // Eat the comment tag start
    Matches(wxT("<!--"), TRUE);

    while (!Eof() && !Matches(wxT("-->"), TRUE))
    {
        m_pos ++;
    }

    return TRUE;
}
Esempio n. 23
0
inline int64_t Barrier::wait_for (int64_t pos) const
{
  if (last_min_ > pos) {
    return last_min_;
  }

  int64_t min_pos = kMaxInt64Value;
  for (auto itr = limit_seq_.begin (); itr != limit_seq_.end (); ++itr) {
    int64_t itr_pos = 0;
    itr_pos = (*itr)->pos().aquire();

    // spin for a bit 
    for (int i = 0; itr_pos < pos && i < 1000; ++i) {
      itr_pos = (*itr)->pos().aquire();
      if ((*itr)->pos().alert()) break;
    }

    // yield for a while, queue slowing down
    for (int y = 0; itr_pos < pos && y < 1000; ++y) {
      usleep(0);

      itr_pos = (*itr)->pos().aquire();
      if ((*itr)->pos().alert()) break;
    }

    // queue stalled, don't peg the CPU but don't wait too long either...
    while (itr_pos < pos) {
      usleep (10 * 1000); // 10ms

      itr_pos = (*itr)->pos ().aquire ();
      if ((*itr)->pos ().alert ()) break;
    }

    if ((*itr)->pos ().alert ()) {
      (*itr)->check_alert ();

      if (itr_pos > pos) {
        // process everything up to itr_pos
        return itr_pos - 1;
      } else {
        throw Eof();
      }
    }

    if (itr_pos < min_pos) {
      min_pos = itr_pos;
    }
  }

  assert (min_pos != kMaxInt64Value);
  return last_min_ = min_pos;
}
Esempio n. 24
0
// Could be number, string, whatever, but read up until whitespace or end of tag (but not a quoted string)
bool wxSimpleHtmlParser::ReadLiteral(wxString& str, bool eatIt)
{
    int pos = m_pos;

    while (!Eof(pos) && !IsWhitespace(GetChar(pos)) && !IsTagEndBracket(GetChar(pos)) && GetChar(pos) != wxT('='))
    {
        str += GetChar(pos);
        pos ++;
    }
    if (eatIt)
        m_pos = pos;
    return TRUE;
}
Esempio n. 25
0
void SNetStorageObjectImpl::Read(string* data)
{
    char buffer[READ_CHUNK_SIZE];

    data->resize(0);
    size_t bytes_read;

    do {
        Read(buffer, sizeof(buffer), &bytes_read);
        data->append(buffer, bytes_read);
    } while (!Eof());

    Close();
}
Esempio n. 26
0
size_t LcfReader::Read0(void *ptr, size_t size, size_t nmemb) {
	if (size == 0) { //avoid division by 0
		return 0;
	}
	//Read nmemb elements of size and return the number of read elements
	stream.read(reinterpret_cast<char*>(ptr), size*nmemb);
	size_t result = stream.gcount() / size;
#ifdef NDEBUG
	if (result != nmemb && !Eof()) {
		perror("Reading error: ");
	}
#endif
	return result;
}
Esempio n. 27
0
TToken ASNLexer::LookupBinHexString(void)
{
    TToken token = T_BINARY_STRING;
    while ( true ) {
        char c = Char();
        switch ( c ) {
        case '\r':
        case '\n':
            LexerWarning("unclosed bit string", 5);
            return token;
        case 0:
            if ( Eof() ) {
                LexerWarning("unclosed bit string", 6);
                return token;
            }
            AddChar();
            LexerWarning("illegal character in bit string", 7);
            break;
        case '0':
        case '1':
            AddChar();
            break;
        case '2': case '3': case '4': case '5': case '6': case '7': case '8':
        case '9': case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
            AddChar();
            token = T_HEXADECIMAL_STRING;
            break;
        case '\'':
            switch ( Char(1) ) {
            case 'B':
                AddChars(2);
                if ( token != T_BINARY_STRING )
                    LexerWarning("binary string contains hexadecimal digits", 8);
                return T_BINARY_STRING;
            case 'H':
                AddChars(2);
                return T_HEXADECIMAL_STRING;
            default:
                AddChar();
                LexerWarning("unknown type of bit string", 9);
                return token;
            }
        default:
            AddChar();
            LexerWarning("illegal character in bit string", 10);
            break;
        }
    }
}
Esempio n. 28
0
// Sets BfN to the end of line or end of buffer. Reads more data, if needed.
// Returns 1, when an end of line was found, BfN is end of line.
// Returns 0, when an end of line was not found and more data is required,
//    BfN is end of buffer.
// Returns -1, when an end of file was found, BfN is not defined.
int TZipIn::FindEol(int& BfN) {
  char Ch;
  if (BfC >= BfL) { // check for eof, read more data
    if (Eof()) { return -1; }
    FillBf();
  }
  while (BfC < BfL) {
    Ch = Bf[BfC++];
    if (Ch=='\n') { BfN = BfC-1; return 1; }
    if (Ch=='\r' && Bf[BfC+1]=='\n') {
      BfC++;  BfN = BfC-2;  return 1; }
  }
  BfN = BfC;
  return 0;
}
Esempio n. 29
0
void CFileDataIO::Read(void *buffer, size_t count) const
{
	MULE_VALIDATE_PARAMS(buffer, wxT("Attempting to write to NULL buffer."));

	// Check that we read everything we wanted.
	if (doRead(buffer, count) == (signed)count) {
		return;
	}

	// To reduce potential system calls, we only do EOF checks when reads fail.
	if (Eof()) {
		throw CEOFException(wxT("Attempt to read past end of file."));
	} else {
		throw CIOFailureException(wxT("Read error, failed to read from file."));
	}
}
Esempio n. 30
0
size_t ReadFileStream::Read(char* ptr, size_t length)
{
    size_t bytesRead = 0;
    while ((length > 0) && !Eof())
    {
        // copy up to the available data in the buffer
        size_t availBytes = std::min(static_cast<size_t>(bufferLast_ - current_), length);
        memcpy(ptr, current_, availBytes);
        length -= availBytes;
        ptr += availBytes;
        current_ += availBytes;
        bytesRead += availBytes;
        // get more data
        Read();
    }
    count_ += bytesRead;
    return bytesRead;
}