const char* decodeIDBKey(const char* p, const char* limit, RefPtr<IDBKey>& foundKey) { ASSERT(limit >= p); if (p >= limit) return 0; unsigned char type = *p++; switch (type) { case IDBKeyNullTypeByte: foundKey = IDBKey::createInvalid(); return p; case IDBKeyArrayTypeByte: { int64_t length; p = decodeVarInt(p, limit, length); if (!p) return 0; if (length < 0) return 0; IDBKey::KeyArray array; while (length--) { RefPtr<IDBKey> key; p = decodeIDBKey(p, limit, key); if (!p) return 0; array.append(key); } foundKey = IDBKey::createArray(array); return p; } case IDBKeyStringTypeByte: { String s; p = decodeStringWithLength(p, limit, s); if (!p) return 0; foundKey = IDBKey::createString(s); return p; } case IDBKeyDateTypeByte: { double d; p = decodeDouble(p, limit, &d); if (!p) return 0; foundKey = IDBKey::createDate(d); return p; } case IDBKeyNumberTypeByte: { double d; p = decodeDouble(p, limit, &d); if (!p) return 0; foundKey = IDBKey::createNumber(d); return p; } } ASSERT_NOT_REACHED(); return 0; }
int compareEncodedIDBKeys(const char*& p, const char* limitA, const char*& q, const char* limitB) { ASSERT(&p != &q); ASSERT(p < limitA); ASSERT(q < limitB); unsigned char typeA = *p++; unsigned char typeB = *q++; if (int x = IDBKey::compareTypes(keyTypeByteToKeyType(typeA), keyTypeByteToKeyType(typeB))) return x; switch (typeA) { case kIDBKeyNullTypeByte: case kIDBKeyMinKeyTypeByte: // Null type or max type; no payload to compare. return 0; case kIDBKeyArrayTypeByte: { int64_t lengthA, lengthB; p = decodeVarInt(p, limitA, lengthA); if (!p) return 0; q = decodeVarInt(q, limitB, lengthB); if (!q) return 0; if (lengthA < 0 || lengthB < 0) return 0; for (int64_t i = 0; i < lengthA && i < lengthB; ++i) { if (int cmp = compareEncodedIDBKeys(p, limitA, q, limitB)) return cmp; } if (lengthA < lengthB) return -1; if (lengthA > lengthB) return 1; return 0; } case kIDBKeyStringTypeByte: return compareEncodedStringsWithLength(p, limitA, q, limitB); case kIDBKeyDateTypeByte: case kIDBKeyNumberTypeByte: { double d, e; p = decodeDouble(p, limitA, &d); ASSERT(p); q = decodeDouble(q, limitB, &e); ASSERT(q); if (d < e) return -1; if (d > e) return 1; return 0; } } ASSERT_NOT_REACHED(); return 0; }
bool Reader::decodeNumber( Token &token ) { bool isDouble = false; for ( Location inspect = token.start_; inspect != token.end_; ++inspect ) { isDouble = isDouble || in( *inspect, '.', 'e', 'E', '+' ) || ( *inspect == '-' && inspect != token.start_ ); } if ( isDouble ) return decodeDouble( token ); // Attempts to parse the number as an integer. If the number is // larger than the maximum supported value of an integer then // we decode the number as a double. Location current = token.start_; bool isNegative = *current == '-'; if ( isNegative ) ++current; Value::LargestUInt maxIntegerValue = isNegative ? Value::LargestUInt(-Value::minLargestInt) : Value::maxLargestUInt; Value::LargestUInt threshold = maxIntegerValue / 10; Value::LargestUInt value = 0; while ( current < token.end_ ) { Char c = *current++; if ( c < '0' || c > '9' ) return addError( "'" + std::string( token.start_, token.end_ ) + "' is not a number.", token ); Value::UInt digit(c - '0'); if ( value >= threshold ) { // We've hit or exceeded the max value divided by 10 (rounded down). If // a) we've only just touched the limit, b) this is the last digit, and // c) it's small enough to fit in that rounding delta, we're okay. // Otherwise treat this number as a double to avoid overflow. if (value > threshold || current != token.end_ || digit > maxIntegerValue % 10) { return decodeDouble( token ); } } value = value * 10 + digit; } if ( isNegative ) currentValue() = -Value::LargestInt( value ); else if ( value <= Value::LargestUInt(Value::maxInt) ) currentValue() = Value::LargestInt( value ); else currentValue() = value; return true; }
bool Reader::decodeNumber( Token &token ) { bool isDouble = false; for ( Location inspect = token.start_; inspect != token.end_; ++inspect ) { isDouble = isDouble || in( *inspect, '.', 'e', 'E', '+' ) || ( *inspect == '-' && inspect != token.start_ ); } if ( isDouble ) return decodeDouble( token ); // Attempts to parse the number as an integer. If the number is // larger than the maximum supported value of an integer then // we decode the number as a double. Location current = token.start_; bool isNegative = *current == '-'; if ( isNegative ) ++current; Value::LargestUInt maxIntegerValue = isNegative ? Value::LargestUInt(-Value::minLargestInt) : Value::maxLargestUInt; Value::LargestUInt threshold = maxIntegerValue / 10; Value::UInt lastDigitThreshold = Value::UInt( maxIntegerValue % 10 ); assert( lastDigitThreshold >=0 && lastDigitThreshold <= 9 ); Value::LargestUInt value = 0; while ( current < token.end_ ) { Char c = *current++; if ( c < '0' || c > '9' ) return addError( "'" + std::string( token.start_, token.end_ ) + "' is not a number.", token ); Value::UInt digit(c - '0'); if ( value >= threshold ) { // If the current digit is not the last one, or if it is // greater than the last digit of the maximum integer value, // the parse the number as a double. if ( current != token.end_ || digit > lastDigitThreshold ) { return decodeDouble( token ); } } value = value * 10 + digit; } if ( isNegative ) currentValue() = -Value::LargestInt( value ); else if ( value <= Value::LargestUInt(Value::maxInt) ) currentValue() = Value::LargestInt( value ); else currentValue() = value; return true; }
static err_t testStruct_decode(buf_t *in, void *out) { struct testStruct *x = (struct testStruct *)out; vomControl ctl = controlNone; uint64_t index; while (true) { err_t err = decodeVar128(in, &index, &ctl); ck(); if (ctl == controlEnd) { return ERR_OK; } if (ctl != controlNone) { // unexpected control message here err = ERR_DECVOM; ck(); } switch (index) { case 0: err = decodeInt(in, &x->A); ck(); break; case 1: err = decodeDouble(in, &x->B); ck(); break; case 2: err = inner_decode(in, &x->Inner); ck(); break; default: // unexpected index number. err = ERR_DECVOM; ck(); } } return ERR_OK; };
int MagnetostaticCuda::decode(buffer* b) { deinit(); LongRangeCuda::decode(b); for(int i=0; i<3; i++) volumeDimensions[i] = decodeDouble(b); for(int i=0; i<9; i++) { ABC[i] = decodeDouble(b); } crossover_tolerance = decodeDouble(b); return 0; }
bool Reader::decodeDouble(Token& token) { Value decoded; if (!decodeDouble(token, decoded)) return false; currentValue().swapPayload(decoded); currentValue().setOffsetStart(token.start_ - begin_); currentValue().setOffsetLimit(token.end_ - begin_); return true; }
bool Reader::decodeNumber(Token& token, Value& decoded) { // Attempts to parse the number as an integer. If the number is // larger than the maximum supported value of an integer then // we decode the number as a double. Location current = token.start_; bool isNegative = *current == '-'; if (isNegative) ++current; // TODO: Help the compiler do the div and mod at compile time or get rid of them. Value::LargestUInt maxIntegerValue = isNegative ? Value::LargestUInt(-Value::minLargestInt) : Value::maxLargestUInt; Value::LargestUInt threshold = maxIntegerValue / 10; Value::LargestUInt value = 0; while (current < token.end_) { Char c = *current++; if (c < '0' || c > '9') return decodeDouble(token, decoded); Value::UInt digit(c - '0'); if (value >= threshold) { // We've hit or exceeded the max value divided by 10 (rounded down). If // a) we've only just touched the limit, b) this is the last digit, and // c) it's small enough to fit in that rounding delta, we're okay. // Otherwise treat this number as a double to avoid overflow. if (value > threshold || current != token.end_ || digit > maxIntegerValue % 10) { return decodeDouble(token, decoded); } } value = value * 10 + digit; } if (isNegative) decoded = -Value::LargestInt(value); else if (value <= Value::LargestUInt(Value::maxInt)) decoded = Value::LargestInt(value); else decoded = value; return true; }
double MainWindow::decodeLineItem(const QString& item, const int next, bool& valid, int& nextIsValue) { if (item.size() == 1) { nextIsValue = next; return 0; } else { nextIsValue = NO_ITEM; return decodeDouble(item.mid(1,-1), valid); } }
int ShortRange::decode(buffer* b) { deinit(); SpinOperation::decode(b); char version = decodeChar(b); if(version == 0) { pbc[0] = decodeInteger(b); pbc[1] = decodeInteger(b); pbc[2] = decodeInteger(b); nxyz = nx * ny * nz; size = decodeInteger(b); num = size; size++; //so we can double if size == 0 pathways = (sss*)malloc(sizeof(sss) * size); for(int i=0; i<num; i++) { pathways[i].fromsite = decodeInteger(b); pathways[i].tosite = decodeInteger(b); pathways[i].strength = decodeDouble(b); for(int j=0; j<9; j++) { pathways[i].matrix[j] = decodeDouble(b); } pathways[i].sig_dot_sig_pow = decodeDouble(b); } } else { fprintf(stderr, "(%s:%i) %s::decode, unknown version:%i\n", __FILE__, __LINE__, lineage(0), (int)version); } return 0; }
bool Reader::decodeNumber( Token &token ) { bool isDouble = false; for ( Location inspect = token.start_; inspect != token.end_; ++inspect ) { isDouble = isDouble || in( *inspect, '.', 'e', 'E', '+' ) || ( *inspect == '-' && inspect != token.start_ ); } if ( isDouble ) return decodeDouble( token ); Location current = token.start_; bool isNegative = *current == '-'; if ( isNegative ) ++current; Value::UInt threshold = (isNegative ? Value::UInt(-Value::minInt) : Value::maxUInt) / 10; Value::UInt value = 0; while ( current < token.end_ ) { Char c = *current++; if ( c < '0' || c > '9' ) return addError( "'" + std::string( token.start_, token.end_ ) + "' is not a number.", token ); if ( value >= threshold ) return decodeDouble( token ); value = value * 10 + Value::UInt(c - '0'); } if ( isNegative ) currentValue() = -Value::Int( value ); else if ( value <= Value::UInt(Value::maxInt) ) currentValue() = Value::Int( value ); else currentValue() = value; return true; }
// reading static uint32_t readNumber(const std::vector<uint8_t>& buffer, uint32_t offset, double& result) { uint32_t originalOffset = offset; uint32_t ret = decodeDouble(buffer, offset, result); if (ret == 0) { return 0; } offset += ret; return offset - originalOffset; }
int Thermal::decode(buffer* b) { SpinOperation::decode(b); char version = decodeChar(b); if(version == 0) { temperature = decodeDouble(b); luaT_dec<dArray>(scale); scale = luaT_inc<dArray>(new dArray(nx,ny,nz)); scale->decode(b); } else { fprintf(stderr, "(%s:%i) %s::decode, unknown version:%i\n", __FILE__, __LINE__, lineage(0), (int)version); } return 0; }
static uint32_t readDate(const std::vector<uint8_t>& buffer, uint32_t offset, Date& result) { uint32_t originalOffset = offset; uint32_t ret = decodeDouble(buffer, offset, result.ms); if (ret == 0) // date in milliseconds from 01/01/1970 { return 0; } offset += ret; ret = decodeInt(buffer, offset, 4, result.timezone); if (ret == 0) // unsupported timezone { return 0; } offset += ret; return offset - originalOffset; }
bool MainWindow::processGCode(QString inputLine, double& x, double& y, double& i, double& j, bool& arc, bool& cw, bool& mm, int& g) { QString line = inputLine.toUpper(); QStringList components = line.split(" ", QString::SkipEmptyParts); QString s; arc = false; bool valid = false; int nextIsValue = NO_ITEM; foreach (s, components) { if (s.at(0) == 'G') { int value = s.mid(1,-1).toInt(); if (value >= 0 && value <= 3) { g = value; if (value == 2) cw = true; else if (value == 3) cw = false; } else if (value == 20) mm = false; else if (value == 21) mm = true; } else if (g >= 0 && g <= 3 && s.at(0) == 'X') { x = decodeLineItem(s, X_ITEM, valid, nextIsValue); } else if (g >= 0 && g <= 3 && s.at(0) == 'Y') { y = decodeLineItem(s, Y_ITEM, valid, nextIsValue); } else if ((g == 2 || g == 3) && s.at(0) == 'I') { i = decodeLineItem(s, I_ITEM, arc, nextIsValue); } else if ((g == 2 || g == 3) && s.at(0) == 'J') { j = decodeLineItem(s, J_ITEM, arc, nextIsValue); } else if (nextIsValue != NO_ITEM) { switch (nextIsValue) { case X_ITEM: x = decodeDouble(s, valid); break; case Y_ITEM: y = decodeDouble(s, valid); break; case I_ITEM: i = decodeDouble(s, arc); break; case J_ITEM: j = decodeDouble(s, arc); break; }; nextIsValue = NO_ITEM; } } return valid; }