bool readToken(Element_Type* token)
{
if ( mUngetBuffer.size() )
{
*token = mUngetBuffer.back();
mUngetBuffer.pop_back();
return true;
}
if (bufferEmpty())
{
fillBuffer();
}
if (bufferEmpty())
{
mIsEndOfFile = true;
return false;
}
else
{
*token = mBuffer[mPtr];
mPtr++;
return true;
}
}
qint64 AudioInjectorLocalBuffer::readData(char* data, qint64 maxSize) {
if (!_isStopped) {
// first copy to the end of the raw audio
int bytesToEnd = _rawAudioArray.size() - _currentOffset;
int bytesRead = maxSize;
if (maxSize > bytesToEnd) {
bytesRead = bytesToEnd;
}
copy(data, _rawAudioArray.data() + _currentOffset, bytesRead, _volume);
// now check if we are supposed to loop and if we can copy more from the beginning
if (_shouldLoop && maxSize != bytesRead) {
bytesRead += recursiveReadFromFront(data + bytesRead, maxSize - bytesRead);
} else {
_currentOffset += bytesRead;
}
if (!_shouldLoop && bytesRead == bytesToEnd) {
// we hit the end of the buffer, emit a signal
emit bufferEmpty();
} else if (_shouldLoop && _currentOffset == _rawAudioArray.size()) {
_currentOffset = 0;
}
return bytesRead;
} else {
return 0;
}
}
int Konsole::Pty::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = K3Process::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: done((*reinterpret_cast< int(*)>(_a[1]))); break;
case 1: receivedData((*reinterpret_cast< const char*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 2: bufferEmpty(); break;
case 3: readRVBData(); break;
case 4: setUtf8Mode((*reinterpret_cast< bool(*)>(_a[1]))); break;
case 5: lockPty((*reinterpret_cast< bool(*)>(_a[1]))); break;
case 6: sendData((*reinterpret_cast< const char*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 7: sendData1((*reinterpret_cast< const char*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 8: doSendJobs1(); break;
case 9: donePty(); break;
case 10: dataReceived((*reinterpret_cast< K3Process*(*)>(_a[1])),(*reinterpret_cast< char*(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3]))); break;
case 11: doSendJobs(); break;
case 12: writeReady(); break;
default: ;
}
_id -= 13;
}
return _id;
}
void Adafruit_STMPE610::readData(uint16_t *x, uint16_t *y, uint8_t *z) {
uint8_t data[4];
for (uint8_t i=0; i<4; i++) {
data[i] = readRegister8(0xD7); //SPI.transfer(0x00);
// Serial.print("0x"); Serial.print(data[i], HEX); Serial.print(" / ");
}
*x = data[0];
*x <<= 4;
*x |= (data[1] >> 4);
*y = data[1] & 0x0F;
*y <<= 8;
*y |= data[2];
*z = data[3];
if (bufferEmpty())
writeRegister8(STMPE_INT_STA, 0xFF); // reset all ints
}
HttpParserImpl::ParseState HttpParserImpl::parseChunk(const char*& cur_pos, const char* end)
{
const char* p_line = nullptr;
const char* p_end = nullptr;
bool b_line = false;
while (cur_pos < end)
{
switch (chunk_state_)
{
case CHUNK_READ_SIZE:
{
b_line = getLine(cur_pos, end, p_line, p_end);
if(!b_line)
{// need more data, save remain data.
if(saveData(cur_pos, end) != KUMA_ERROR_NOERR) {
return PARSE_STATE_ERROR;
}
cur_pos = end;
return PARSE_STATE_CONTINUE;
}
std::string str;
if(!str_buf_.empty()) {
str.swap(str_buf_);
clearBuffer();
}
str.append(p_line, p_end);
// need not parse chunk extension
chunk_size_ = (uint32_t)strtol(str.c_str(), NULL, 16);
KUMA_INFOTRACE("HttpParser::parseChunk, chunk_size="<<chunk_size_);
if(0 == chunk_size_)
{// chunk completed
chunk_state_ = CHUNK_READ_TRAILER;
} else {
chunk_bytes_read_ = 0;
chunk_state_ = CHUNK_READ_DATA;
}
break;
}
case CHUNK_READ_DATA:
{
uint32_t cur_len = uint32_t(end - cur_pos);
if(chunk_size_ - chunk_bytes_read_ <= cur_len) {// data enough
const char* notify_data = cur_pos;
uint32_t notify_len = chunk_size_ - chunk_bytes_read_;
total_bytes_read_ += notify_len;
chunk_bytes_read_ = chunk_size_ = 0; // reset
chunk_state_ = CHUNK_READ_DATA_CR;
cur_pos += notify_len;
bool destroyed = false;
destroy_flag_ptr_ = &destroyed;
if(cb_data_) cb_data_(notify_data, notify_len);
if(destroyed) {
return PARSE_STATE_DESTROY;
}
destroy_flag_ptr_ = nullptr;
} else {// need more data
const char* notify_data = cur_pos;
total_bytes_read_ += cur_len;
chunk_bytes_read_ += cur_len;
cur_pos += cur_len;
if(cb_data_) cb_data_(notify_data, cur_len);
return PARSE_STATE_CONTINUE;
}
break;
}
case CHUNK_READ_DATA_CR:
{
if(*cur_pos != CR) {
KUMA_ERRTRACE("HttpParser::parseChunk, can not find data CR");
read_state_ = HTTP_READ_ERROR;
return PARSE_STATE_ERROR;
}
++cur_pos;
chunk_state_ = CHUNK_READ_DATA_LF;
break;
}
case CHUNK_READ_DATA_LF:
{
if(*cur_pos != LF) {
KUMA_ERRTRACE("HttpParser::parseChunk, can not find data LF");
read_state_ = HTTP_READ_ERROR;
return PARSE_STATE_ERROR;
}
++cur_pos;
chunk_state_ = CHUNK_READ_SIZE;
break;
}
case CHUNK_READ_TRAILER:
{
b_line = getLine(cur_pos, end, p_line, p_end);
if(b_line) {
if(p_line == p_end && bufferEmpty()) {
// blank line, http completed
read_state_ = HTTP_READ_DONE;
onComplete();
return PARSE_STATE_DONE;
}
clearBuffer(); // discard trailer
} else { // need more data
if(saveData(cur_pos, end) != KUMA_ERROR_NOERR) {
return PARSE_STATE_ERROR;
}
cur_pos = end; // all data was consumed
return PARSE_STATE_CONTINUE;
}
break;
}
}
}
return HTTP_READ_DONE == read_state_?PARSE_STATE_DONE:PARSE_STATE_CONTINUE;
}
HttpParserImpl::ParseState HttpParserImpl::parseHttp(const char*& cur_pos, const char* end)
{
const char* line = nullptr;
const char* line_end = nullptr;
bool b_line = false;
if(HTTP_READ_LINE == read_state_)
{// try to get status line
while ((b_line = getLine(cur_pos, end, line, line_end)) && line == line_end && str_buf_.empty())
;
if(b_line && (line != line_end || !str_buf_.empty())) {
if(!parseStartLine(line, line_end)) {
read_state_ = HTTP_READ_ERROR;
return PARSE_STATE_ERROR;
}
read_state_ = HTTP_READ_HEAD;
} else {
// need more data
if(saveData(cur_pos, end) != KUMA_ERROR_NOERR) {
return PARSE_STATE_ERROR;
}
cur_pos = end; // all data was consumed
return PARSE_STATE_CONTINUE;
}
}
if(HTTP_READ_HEAD == read_state_)
{
while ((b_line = getLine(cur_pos, end, line, line_end)))
{
if(line == line_end && bufferEmpty())
{// blank line, header completed
onHeaderComplete();
if(paused_) {
return PARSE_STATE_CONTINUE;
}
if(hasBody() && !upgrade_) {
read_state_ = HTTP_READ_BODY;
} else {
read_state_ = HTTP_READ_DONE;
onComplete();
return PARSE_STATE_DONE;
}
break;
}
parseHeaderLine(line, line_end);
}
if(HTTP_READ_HEAD == read_state_)
{// need more data
if(saveData(cur_pos, end) != KUMA_ERROR_NOERR) {
return PARSE_STATE_ERROR;
}
cur_pos = end; // all data was consumed
return PARSE_STATE_CONTINUE;
}
}
if(HTTP_READ_BODY == read_state_ && cur_pos < end)
{// try to get body
if(is_chunked_) {
return parseChunk(cur_pos, end);
} else {
uint32_t cur_len = uint32_t(end - cur_pos);
if(has_content_length_ && (content_length_ - total_bytes_read_) <= cur_len)
{// data enough
const char* notify_data = cur_pos;
uint32_t notify_len = content_length_ - total_bytes_read_;
cur_pos += notify_len;
total_bytes_read_ = content_length_;
read_state_ = HTTP_READ_DONE;
KUMA_ASSERT(!destroy_flag_ptr_);
bool destroyed = false;
destroy_flag_ptr_ = &destroyed;
if(cb_data_) cb_data_(notify_data, notify_len);
if(destroyed) {
return PARSE_STATE_DESTROY;
}
destroy_flag_ptr_ = nullptr;
onComplete();
return PARSE_STATE_DONE;
}
else
{// need more data, or read untill EOF
const char* notify_data = cur_pos;
total_bytes_read_ += cur_len;
cur_pos = end;
if(cb_data_) cb_data_(notify_data, cur_len);
return PARSE_STATE_CONTINUE;
}
}
}
return HTTP_READ_DONE == read_state_?PARSE_STATE_DONE:PARSE_STATE_CONTINUE;
}
