/*
* go to the next header
*/
bool FileIO::GotoHeader(char* header)
{
//check for errors
if ((this->mFileHandle == NULL) || (!header))
return false;
bool found = false;
long headerSize = strlen(header);
char* currentHeader = new char[headerSize];
for(;;)
{
//go to a byte
if (Mode() == RECORD_MODE)
{
//goto next unit
if (!GotoNext())
break; //if there is no further unit
}
//reset current header
memset(currentHeader, 0, headerSize);
//there is a byte, find the correct bytes (header)
for(;;)
{
//continue search if in BYTE_MODE and there is something to read
if ((Mode() == RECORD_MODE) ||
(EndOfFile()))
break;
//append one byte to the back of the current header
for (int c=0; c<headerSize - 1; c++)
currentHeader[c] = currentHeader[c+1];
currentHeader[headerSize - 1] = PopByte();
//continue search if the current header is not full or
// it's full but doesn't match the right header
if (!currentHeader[0] || memcmp(currentHeader, header, headerSize))
continue;
else
{
found = true;
break;
}
}
//called break above -> check if found or finished by EOF
if (found || EndOfFile())
break;
}
//clean up memory
if (currentHeader)
delete currentHeader;
//found header?
return found;
}
JsonNode JsonReader::ParseObject() {
JsonNode object = JsonNode(JsonNode::Type::Object);
bool end = false;
if (*m_data == '{') m_data++;
/* Look for the next key name */
while (!end) {
std::string key;
/* Look for string quotes */
while (*m_data != '\"' && *m_data != '\'' && !EndOfFile()) m_data++;
if (EndOfFile()) {
PrintError("Syntax Error : '\"' , ''' were expected. ");
break;
}
/* Parse the key as string */
key = ParseString();
SkipUntil(':');
if (EndOfFile()) {
PrintError("Syntax Error : ':' was expected. ");
break;
}
m_data++;
object[key] = this->ParseValue();
while (*m_data != ',' && *m_data != '}' && !EndOfFile()) m_data++;
switch (*m_data) {
case ',':
m_data++;
break;
case '}':
end = true;
m_data++;
break;
default:
PrintError("Syntax Error : ',' , '}' were expected. ");
end = true;
break;
};
}
return object;
}
uint8_t read_uint8(std::ifstream &file)
{
char byte;
file.read(&byte, 1);
if (file.eof()) throw EndOfFile();
return static_cast<uint8_t>(byte);
}
static int8_t Rd_GetC_m (
Rd_cl *self )
{
RAISE_Rd$EndOfFile();
return 0;
}
/*
* get total record from file,
* byteRecord must be large enough to hold the data
*/
bool FileIO::PopRecord(void* byteRecord)
{
//check for errors
if ((this->mCurrentMode != RECORD_MODE) || !byteRecord ||
(this->mFileHandle == NULL) ||
EndOfFile())
return false;
//if PopRecordSize has not been called
PopRecordSize();
if (!mRecordSize)
return false;
//read Record
int rval;
rval = fread(byteRecord, 1, mRecordSize, this->mFileHandle);
//check for errors
if (rval != mRecordSize)
return false;
//initialize other attributes
mRecordSize = 0;
DetermineNextMode();
return true;
}
static int8_t Rd_GetC_m (
Rd_cl *self )
{
Pipe_st *st = self->st;
uint8_t c;
uint64_t nb;
rd_enter(st);
if (st->ungetc) {
c=st->lastc;
st->ungetc=False;
nb=1;
} else {
nb=rd_get(st, &c, 1, False);
}
MU_RELEASE(&st->mu);
if (nb==0) {
MU_RELEASE(&st->rd_mu);
RAISE_Rd$EndOfFile();
}
st->lastc=c;
MU_RELEASE(&st->rd_mu);
return c;
}
JsonNode JsonReader::ParseArray() {
JsonNode object = JsonNode(JsonNode::Type::Array);
bool end = false;
/* Verify we're parsing an array */
if (*m_data == '[') m_data++;
while (!end) {
/* Use the index value as the key name */
object[object.ChildCount()] = this->ParseValue();
while (*m_data != ',' && *m_data != ']' && !EndOfFile()) m_data++;
switch (*m_data) {
case ',':
m_data++;
break;
case ']':
end = true;
m_data++;
break;
default:
PrintError("Syntax Error : ',' , ']' were expected. ");
end = true;
break;
};
}
return object;
}
void
Read_ENV2(GMC_ARG_VOID)
{
tps_FileName FileName;
tp_FilDsc FilDsc;
tps_Str StrBuf;
tp_Str Str;
int count, status;
size_t sz;
sz = snprintf(FileName, MAX_FileName, "%s/ENV2", OdinDirName);
if (sz >= MAX_FileName) {
(void)fprintf(stderr, "File name too long (MAX_FileName=%d): %s/ENV2\n",
MAX_FileName, OdinDirName);
exit(1); }/*if*/;
FilDsc = FileName_RFilDsc(FileName, FALSE);
FORBIDDEN(FilDsc == ERROR);
for (count = fscanf((FILE *)FilDsc, "%[^\1]\1\n", StrBuf);
count == 1;
count = fscanf((FILE *)FilDsc, "%[^\1]\1\n", StrBuf)) {
Str = Malloc_Str(StrBuf);
status = putenv(Str);
FORBIDDEN(status != 0); }/*for*/;
FORBIDDEN(!EndOfFile(FilDsc));
Close(FilDsc);
}/*Read_ENV2*/
uint16_t read_uint16(std::ifstream &file)
{
char bytes[2];
file.read(bytes, 2);
if (file.eof()) throw EndOfFile();
uint16_t value = static_cast<unsigned char>(bytes[0]) | (static_cast<unsigned char>(bytes[1]) << 8);
return value;
}
T ReadNext(std::istream& stream, int& line)
{
std::string s;
ReadNextToken(stream, s, line);
if (s == "")
throw EndOfFile();
return ParseType<T>(s);
}
inline std::string ReadNext<std::string>(std::istream& stream, int& line)
{
std::string s;
ReadNextToken(stream, s, line);
if (s == "")
throw EndOfFile();
return s;
}
int16_t read_int16(std::ifstream &file)
{
char bytes[2];
file.read(bytes, 2);
if (file.eof()) throw EndOfFile();
int16_t value = bytes[0] | (bytes[1] << 8);
return value;
}
char Parser::NeedChar() const
{
if (AtEnd())
{
throw EndOfFile();
}
return GetChar();
}
bool StringSearch_c::DoSearch ()
{
Assert ( m_pFile );
int nBytesToRead = READ_BUFFER_SIZE;
int iBufStart = 0;
if ( m_iNextOffset > 0 )
fseek ( m_pFile, m_iNextOffset, SEEK_CUR );
else
if ( m_iNextOffset < 0 )
{
nBytesToRead += m_iNextOffset * 2;
iBufStart -= m_iNextOffset * 2;
}
int nBytesRead = fread ( m_dBuffer + iBufStart, 1, nBytesToRead, m_pFile );
if ( nBytesRead < nBytesToRead )
m_bEndReached = true;
int iTestOffset = m_iNextOffset == 0 ? 0 : 1;
if ( Test ( (wchar_t *)m_dBuffer + iTestOffset, nBytesRead / 2, m_iNextOffset ) )
{
EndOfFile ();
return true;
}
if ( ! m_bEndReached )
{
--m_iNextOffset;
if ( m_iNextOffset < 0 )
{
for ( int i = 0; i < -m_iNextOffset; ++i )
m_dBuffer [i] = m_dBuffer [nBytesRead + m_iNextOffset + i];
}
}
else
EndOfFile ();
return false;
}
void read_string(std::ifstream &file)
{
// TODO
char byte;
for(;;)
{
file.read(&byte, 1);
if (file.eof()) throw EndOfFile();
if (byte == '\0')
break;
}
}
uint32_t read_uint32(std::ifstream &file)
{
char bytes[4];
file.read(bytes, 4);
if (file.eof()) throw EndOfFile();
uint32_t a = static_cast<unsigned char>(bytes[0]);
uint32_t b = static_cast<unsigned char>(bytes[1]) << 8;
uint32_t c = static_cast<unsigned char>(bytes[2]) << 16;
uint32_t d = static_cast<unsigned char>(bytes[3]) << 24;
uint32_t value = a | b | c | d;
return value;
}
void Parser::SkipCharClass2(const CharClass & charClass)
{
while (NotAtEnd())
{
if (!charClass.Contains(GetChar()))
{
return;
}
Advance();
}
throw EndOfFile();
}
void Parser::WaitChar(char c)
{
while (NotAtEnd())
{
if (GetChar() == c)
{
return;
}
Advance();
}
throw EndOfFile();
}
void Parser::SkipChars(char c)
{
while (NotAtEnd())
{
if (GetChar() != c)
{
return;
}
Advance();
}
throw EndOfFile();
}
bool
LogCatReader::OnFileEvent(int _fd, unsigned mask)
{
assert(_fd == fd.Get());
char buffer[1024];
ssize_t nbytes = fd.Read(buffer, sizeof(buffer));
if (nbytes > 0) {
if (data.length() < 1024 * 1024)
data.append(buffer, nbytes);
return true;
} else {
EndOfFile();
return false;
}
}
bool CPipedCMD::HasData()
{
if (EndOfFile())
return false;
int ret = poll(&m_PollData, 1, 10);
if (ret == -1) // Error occured
throw Exceptions::CExPoll(errno);
else if (ret == 0)
return false;
else if (((m_PollData.revents & POLLIN) == POLLIN) || ((m_PollData.revents & POLLHUP) == POLLHUP))
return true;
return false;
}
I NRLib::ReadAsciiArrayFast(std::istream& stream, I begin, size_t n)
{
for (size_t i = 0; i < n; ++i) {
stream >> *begin;
++begin;
if ( stream.eof() ) {
throw EndOfFile();
}
if ( stream.fail() ) {
stream.clear();
std::string nextToken;
stream >> nextToken;
throw Exception("Failure during reading element " + ToString(static_cast<unsigned int>(i)) + " of array. "
+ "Next token is " + nextToken + "\n");
}
}
/*
* determine next mode
*/
bool FileIO::DetermineNextMode()
{
if ((this->mFileHandle == NULL) ||
EndOfFile())
return false;
int rval;
rval = fread(&this->mCurrentMode, 1, 1, this->mFileHandle);
//just use the last byte
if ((this->mCurrentMode != BYTE_MODE) && (this->mCurrentMode != RECORD_MODE))
this->mCurrentMode = BYTE_MODE;
if (rval != 1)
return false;
return true;
}
int
my_yyparse(void)
{
if (interactive_mode)
{
char *line = NULL;
char buffer[1024];
snprintf(buffer, 1024, "mini_shell(%d):", status);
line = readline(buffer);
if(line != NULL)
{
int ret;
add_history(line); // Enregistre la line non vide dans l'historique courant
*strchr(line, '\0') = '\n'; // Ajoute \n à la line pour qu'elle puisse etre traité par le parseur
ret = yyparse_string(line); // Remplace l'entrée standard de yyparse par s
free(line);
return ret;
}
else
{
EndOfFile();
return -1;
}
}
else
{
// pour le mode distant par exemple
int ret; int c;
char *line = NULL;
size_t linecap = 0;
ssize_t linelen;
linelen = getline(&line, &linecap, stdin);
if(linelen>0)
{
int ret;
ret = yyparse_string(line);
free(line);
return ret;
}
}
}
Any JsonReader::ParseNumber() {
char *start = m_data;
Any number_value;
char last_char;
bool foundcomma = false;
if (*m_data == '-') m_data++;
while (!EndOfFile()) {
if ((*m_data >= '0' && *m_data <= '9')) {
m_data++;
} else if (*m_data == '.') {
if (foundcomma) {
PrintError("Syntax Error: Expected a number");
break;
} else {
foundcomma = true;
m_data++;
}
} else {
break;
}
}
last_char = *m_data;
*m_data = '\0';
if (foundcomma) {
number_value = Any(std::strtod(start, nullptr));
} else {
number_value = (m_data - start > 4) ? Any(std::strtol(start, nullptr, 10))
: Any(std::stoi(start, nullptr, 10));
}
*m_data = last_char;
return number_value;
}
/*
* get record size if in RECORD_MODE
*/
unsigned int FileIO::PopRecordSize()
{
//check for errors
if (this->mCurrentMode != RECORD_MODE ||
(this->mFileHandle == NULL) ||
EndOfFile())
return 0;
//if PopRecordSize has already been called
if (mRecordSize)
return mRecordSize;
//read RecordSize
int rval;
rval = fread(&mRecordSize, 1, sizeof(unsigned int), this->mFileHandle);
if (rval == sizeof(unsigned int))
return mRecordSize;
return 0;
}
static int8_t Rd_LGetC_m (
Rd_cl *self )
{
Pipe_st *st = self->st;
uint8_t c;
uint64_t nb;
if (st->ungetc) {
c=st->lastc;
st->ungetc=False;
nb=1;
} else {
MU_LOCK(&st->mu);
nb=rd_get(st, &c, 1, False);
MU_RELEASE(&st->mu);
}
if (nb==0) {
RAISE_Rd$EndOfFile();
}
st->lastc=c;
return c;
}
/*
* get next byte if in BYTE_MODE
* returns 0 if not in BYTE_MODE or another error occured
*/
unsigned char FileIO::PopByte()
{
//check for errors
if (this->mCurrentMode != BYTE_MODE ||
(this->mFileHandle == NULL) ||
EndOfFile())
return 0;
unsigned char currentByte;
int rval;
rval = fread(¤tByte, 1, 1, this->mFileHandle);
//initialize other attributes
mRecordSize = 0;
//check for errors
if (rval != 1)
return 0;
DetermineNextMode();
return currentByte;
}
STATUSCODE
ParseFile(
PPARSERDATA pParserData,
PWSTR pFilename
)
/*++
Routine Description:
Parse a PCL-XL printer description file
Arguments:
pParserData - Points to parser data structure
pFilename - Specifies the name of the file to be parsed
Return Value:
ERR_NONE if successful, error code otherwise
--*/
{
STATUSCODE status;
PFILEOBJ pFile;
INT syntaxErrors;
//
// Map the file into memory for read-only access
//
Verbose(("File %ws\n", pFilename));
if (! (pFile = CreateFileObj(pFilename)))
return ERR_FILE;
pParserData->pFile = pFile;
//
// Compute the 16-bit CRC checksum of the file content
//
pParserData->checksum =
ComputeCrc16Checksum(pFile->pStartPtr, pFile->fileSize, pParserData->checksum);
//
// Process entries in the file
//
while ((status = ParseEntry(pParserData)) != ERR_EOF) {
if (status != ERR_NONE && status != ERR_SYNTAX) {
DeleteFileObj(pFile);
return status;
}
}
if (EndOfFile(pFile) && !EndOfLine(pFile)) {
Warning(("Incomplete last line ignored.\n"));
}
//
// Unmap the file and return to the caller
//
syntaxErrors = pFile->syntaxErrors;
DeleteFileObj(pFile);
if (syntaxErrors > 0) {
Error(("%d syntax error(s) found in %ws\n", syntaxErrors, pFilename));
return ERR_SYNTAX;
}
return ERR_NONE;
}
TreeNode* Parser::Statement()
{
kdDebug(0)<<"Parser::Statement()"<<endl;
while (currentToken.type == tokEOL) getToken(); // statements can allways start on newlines
switch (currentToken.type)
{
case tokLearn : return Learn(); break;
case tokIf : return If(); break;
case tokFor : return For(); break;
case tokForEach : return ForEach(); break;
case tokWhile : return While(); break;
case tokRun : return ExternalRun(); break;
case tokReturn : return Return(); break;
case tokBreak : return Break(); break;
case tokUnknown : return Other(); break; //assignment or function call
case tokClear : return Clear(); break;
case tokGo : return Go(); break;
case tokGoX : return GoX(); break;
case tokGoY : return GoY(); break;
case tokForward : return Forward(); break;
case tokBackward : return Backward(); break;
case tokDirection : return Direction(); break;
case tokTurnLeft : return TurnLeft(); break;
case tokTurnRight : return TurnRight(); break;
case tokCenter : return Center(); break;
case tokSetPenWidth : return SetPenWidth(); break;
case tokPenUp : return PenUp(); break;
case tokPenDown : return PenDown(); break;
case tokSetFgColor : return SetFgColor(); break;
case tokSetBgColor : return SetBgColor(); break;
case tokResizeCanvas : return ResizeCanvas(); break;
case tokSpriteShow : return SpriteShow(); break;
case tokSpriteHide : return SpriteHide(); break;
case tokSpritePress : return SpritePress(); break;
case tokSpriteChange : return SpriteChange(); break;
case tokPrint : return Print(); break;
case tokInputWindow : return InputWindow(); break;
case tokMessage : return Message(); break;
case tokFontType : return FontType(); break;
case tokFontSize : return FontSize(); break;
case tokRepeat : return Repeat(); break;
case tokRandom : return Random(); break;
case tokWait : return Wait(); break;
case tokWrapOn : return WrapOn(); break;
case tokWrapOff : return WrapOff(); break;
case tokReset : return Reset(); break;
case tokEOF : return EndOfFile(); break;
case tokEnd : Error(currentToken, i18n("Cannot understand ']'"), 1050);
getToken();
return new TreeNode(currentToken, Unknown);
break;
case tokBegin : Error(currentToken, i18n("Cannot understand '['"), 1050);
getToken();
return new TreeNode(currentToken, Unknown);
break;
default : break;
}
if (currentToken.type != tokEnd)
{
Error(currentToken, i18n("Cannot understand '%1'").arg(currentToken.look), 1060);
}
getToken();
return new TreeNode(currentToken, Unknown); // fall-though for unknowns
}
