void ascii85_decode(FILE *fp, int delims, int ignore_garbage) {
int c, count = 0, end = 0;
unsigned long tuple = 0, pows[] = {85*85*85*85, 85*85*85, 85*85, 85, 1};
while (delims) {
c = getc_nospace(fp);
if (c == '<') {
c = getc_nospace(fp);
if (c == '~') break;
ungetc(c, fp);
}
else if (c == EOF) {
eprintf("ascii85: missing <~\n");
exit(1);
}
}
for (;;) {
c = getc_nospace(fp);
if (c == 'z' && count == 0) {
decode_tuple(0, 5);
continue;
}
if (c == 'y' && count == 0) {
decode_tuple(0x20202020, 5);
continue;
}
if (c == '~' && delims) {
c = getc_nospace(fp);
if (c != '>') {
eprintf("ascii85: ~ without >\n");
exit(1);
}
c = EOF;
end = 1;
}
if (c == EOF) {
if (delims && !end) {
eprintf("ascii85: missing ~>\n");
exit(1);
}
if (count > 0) {
tuple += pows[count-1];
decode_tuple(tuple, count);
}
break;
}
if (c < '!' || c > 'u') {
if (ignore_garbage) continue;
eprintf("ascii85: invalid character '%c'\n", c);
exit(1);
}
tuple += (c - '!') * pows[count++];
if (count == 5) {
decode_tuple(tuple, count);
tuple = 0;
count = 0;
}
}
}
DataType::Ptr decode() {
uint16_t value_type;
buffer_ = decode_uint16(buffer_, value_type);
switch (value_type) {
case CASS_VALUE_TYPE_CUSTOM:
return decode_custom();
case CASS_VALUE_TYPE_LIST:
case CASS_VALUE_TYPE_SET:
case CASS_VALUE_TYPE_MAP:
return decode_collection(static_cast<CassValueType>(value_type));
case CASS_VALUE_TYPE_UDT:
return decode_user_type();
case CASS_VALUE_TYPE_TUPLE:
return decode_tuple();
default:
if (value_type < CASS_VALUE_TYPE_LAST_ENTRY) {
if (data_type_cache_[value_type]) {
return data_type_cache_[value_type];
} else {
DataType::Ptr data_type(
new DataType(static_cast<CassValueType>(value_type)));
data_type_cache_[value_type] = data_type;
return data_type;
}
}
break;
}
return DataType::Ptr();
}
static int
handle_response(DICT_ERLANG *dict_erlang, const char *key,
ei_x_buff *resp, char **res)
{
int err, index = 0;
int res_type, res_size;
err = ei_get_type(resp->buff, &index, &res_type, &res_size);
if (err != 0) {
msg_warn_erl("ei_get_type");
return err;
}
switch (res_type) {
case ERL_ATOM_EXT:
err = decode_atom(resp, &index, "not_found");
if (err != 0)
return err;
return 0;
case ERL_SMALL_TUPLE_EXT:
case ERL_LARGE_TUPLE_EXT: {
int arity;
err = decode_tuple(resp, &index, 2);
if (err == -1)
return err;
err = decode_atom(resp, &index, "ok");
if (err != 0)
return err;
*res = decode_bitstring_list(dict_erlang, key, resp, &index);
if (*res == NULL)
return -1;
return 1;
}
default:
msg_warn("unexpected response type");
return -1;
}
/* NOTREACHED */
}
void decode_cell(pTHX_ unsigned char *input, STRLEN len, STRLEN *pos, struct cc_type *type, SV *output)
{
unsigned char *bytes;
STRLEN bytes_len;
if (unpack_bytes(aTHX_ input, len, pos, &bytes, &bytes_len) != 0) {
sv_setsv(output, &PL_sv_undef);
return;
}
switch (type->type_id) {
case CC_TYPE_ASCII:
case CC_TYPE_CUSTOM:
case CC_TYPE_BLOB:
decode_blob(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_BOOLEAN:
decode_boolean(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_VARCHAR:
case CC_TYPE_TEXT:
decode_utf8(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_INET:
decode_inet(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_SET:
case CC_TYPE_LIST:
decode_list(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_UUID:
case CC_TYPE_TIMEUUID:
decode_uuid(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_FLOAT:
decode_float(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_DOUBLE:
decode_double(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_DECIMAL:
decode_decimal(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_VARINT:
case CC_TYPE_BIGINT:
case CC_TYPE_COUNTER:
case CC_TYPE_TIMESTAMP:
case CC_TYPE_SMALLINT:
case CC_TYPE_TINYINT:
case CC_TYPE_INT:
decode_varint(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_DATE:
decode_date(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_TIME:
decode_time(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_MAP:
decode_map(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_UDT:
decode_udt(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_TUPLE:
decode_tuple(aTHX_ bytes, bytes_len, type, output);
break;
default:
sv_setsv(output, &PL_sv_undef);
warn("Decoder doesn't yet understand type %d, returning undef instead", type->type_id);
break;
}
}
