diff options
Diffstat (limited to 'gruel/src/lib/pmt/pmt_serialize.cc')
| -rw-r--r-- | gruel/src/lib/pmt/pmt_serialize.cc | 254 |
1 files changed, 129 insertions, 125 deletions
diff --git a/gruel/src/lib/pmt/pmt_serialize.cc b/gruel/src/lib/pmt/pmt_serialize.cc index 24be6b772c..2c74f30b01 100644 --- a/gruel/src/lib/pmt/pmt_serialize.cc +++ b/gruel/src/lib/pmt/pmt_serialize.cc @@ -219,15 +219,16 @@ deserialize_tuple(pmt_t *tuple, std::streambuf &sb) uint32_t nitems; bool ok = deserialize_untagged_u32(&nitems, sb); pmt_t list(PMT_NIL); - for(uint32_t i=0; i<nitems; i++){ - pmt_t item = pmt_deserialize( sb ); - if(pmt_eq(list, PMT_NIL)){ - list = pmt_list1(item); - } else { - list = pmt_list_add(list, item); - } + for(uint32_t i=0; i<nitems; i++) { + pmt_t item = deserialize(sb); + if(eq(list, PMT_NIL)) { + list = list1(item); + } + else { + list = list_add(list, item); + } } - (*tuple) = pmt_to_tuple(list); + (*tuple) = to_tuple(list); return ok; } @@ -238,92 +239,93 @@ deserialize_tuple(pmt_t *tuple, std::streambuf &sb) * N.B., Circular structures cause infinite recursion. */ bool -pmt_serialize(pmt_t obj, std::streambuf &sb) +serialize(pmt_t obj, std::streambuf &sb) { bool ok = true; tail_recursion: - if (pmt_is_bool(obj)){ - if (pmt_eq(obj, PMT_T)) + if(is_bool(obj)) { + if(eq(obj, PMT_T)) return serialize_untagged_u8(PST_TRUE, sb); else return serialize_untagged_u8(PST_FALSE, sb); } - if (pmt_is_null(obj)) + if(is_null(obj)) return serialize_untagged_u8(PST_NULL, sb); - if (pmt_is_symbol(obj)){ - const std::string s = pmt_symbol_to_string(obj); + if(is_symbol(obj)) { + const std::string s = symbol_to_string(obj); size_t len = s.size(); ok = serialize_untagged_u8(PST_SYMBOL, sb); ok &= serialize_untagged_u16(len, sb); - for (size_t i = 0; i < len; i++) + for(size_t i = 0; i < len; i++) ok &= serialize_untagged_u8(s[i], sb); return ok; } - if (pmt_is_pair(obj)){ + if(is_pair(obj)) { ok = serialize_untagged_u8(PST_PAIR, sb); - ok &= pmt_serialize(pmt_car(obj), sb); - if (!ok) + ok &= serialize(car(obj), sb); + if(!ok) return false; - obj = pmt_cdr(obj); + obj = cdr(obj); goto tail_recursion; } - if (pmt_is_number(obj)){ + if(is_number(obj)) { - if (pmt_is_uint64(obj)){ - uint64_t i = pmt_to_uint64(obj); + if(is_uint64(obj)) { + uint64_t i = to_uint64(obj); ok = serialize_untagged_u8(PST_UINT64, sb); ok &= serialize_untagged_u64(i, sb); return ok; - } else - if (pmt_is_integer(obj)){ - long i = pmt_to_long(obj); - if (sizeof(long) > 4){ - if (i < -2147483647 || i > 2147483647) - throw pmt_notimplemented("pmt_serialize (64-bit integers)", obj); + } + else { + if(is_integer(obj)) { + long i = to_long(obj); + if(sizeof(long) > 4) { + if(i < -2147483647 || i > 2147483647) + throw notimplemented("pmt::serialize (64-bit integers)", obj); + } + ok = serialize_untagged_u8(PST_INT32, sb); + ok &= serialize_untagged_u32(i, sb); + return ok; } - ok = serialize_untagged_u8(PST_INT32, sb); - ok &= serialize_untagged_u32(i, sb); - return ok; } - if (pmt_is_real(obj)){ - float i = pmt_to_double(obj); + if(is_real(obj)) { + float i = to_double(obj); ok = serialize_untagged_u8(PST_DOUBLE, sb); ok &= serialize_untagged_f64(i, sb); return ok; } - if (pmt_is_complex(obj)){ - std::complex<double> i = pmt_to_complex(obj); + if(is_complex(obj)) { + std::complex<double> i = to_complex(obj); ok = serialize_untagged_u8(PST_COMPLEX, sb); ok &= serialize_untagged_f64(i.real(), sb); ok &= serialize_untagged_f64(i.imag(), sb); return ok; } - } - if (pmt_is_vector(obj)) { - size_t vec_len = pmt::pmt_length(obj); + if(is_vector(obj)) { + size_t vec_len = pmt::length(obj); ok = serialize_untagged_u8(PST_VECTOR, sb); ok &= serialize_untagged_u32(vec_len, sb); for(size_t i=0; i<vec_len; i++) { - ok &= pmt_serialize(pmt_vector_ref(obj, i), sb); + ok &= serialize(vector_ref(obj, i), sb); } return ok; } - if (pmt_is_uniform_vector(obj)) { + if(is_uniform_vector(obj)) { size_t npad = 1; - size_t vec_len = pmt::pmt_length(obj); + size_t vec_len = pmt::length(obj); - if(pmt_is_u8vector(obj)) { + if(is_u8vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_U8, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -332,12 +334,12 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u8(pmt_u8vector_ref(obj, i), sb); + ok &= serialize_untagged_u8(u8vector_ref(obj, i), sb); } return ok; } - if(pmt_is_s8vector(obj)) { + if(is_s8vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_S8, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -346,12 +348,12 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u8(pmt_s8vector_ref(obj, i), sb); + ok &= serialize_untagged_u8(s8vector_ref(obj, i), sb); } return ok; } - if(pmt_is_u16vector(obj)) { + if(is_u16vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_U16, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -360,12 +362,12 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u16(pmt_u16vector_ref(obj, i), sb); + ok &= serialize_untagged_u16(u16vector_ref(obj, i), sb); } return ok; } - if(pmt_is_s16vector(obj)) { + if(is_s16vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_S16, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -374,12 +376,12 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u16(pmt_s16vector_ref(obj, i), sb); + ok &= serialize_untagged_u16(s16vector_ref(obj, i), sb); } return ok; } - if(pmt_is_u32vector(obj)) { + if(is_u32vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_U32, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -388,12 +390,12 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u32(pmt_u32vector_ref(obj, i), sb); + ok &= serialize_untagged_u32(u32vector_ref(obj, i), sb); } return ok; } - if(pmt_is_s32vector(obj)) { + if(is_s32vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_S32, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -402,12 +404,12 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u32(pmt_s32vector_ref(obj, i), sb); + ok &= serialize_untagged_u32(s32vector_ref(obj, i), sb); } return ok; } - if(pmt_is_u64vector(obj)) { + if(is_u64vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_U64, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -416,12 +418,12 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u64(pmt_u64vector_ref(obj, i), sb); + ok &= serialize_untagged_u64(u64vector_ref(obj, i), sb); } return ok; } - if(pmt_is_s64vector(obj)) { + if(is_s64vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_S64, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -430,12 +432,12 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u64(pmt_s64vector_ref(obj, i), sb); + ok &= serialize_untagged_u64(s64vector_ref(obj, i), sb); } return ok; } - if(pmt_is_f32vector(obj)) { + if(is_f32vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_F32, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -444,12 +446,12 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_f64(pmt_f32vector_ref(obj, i), sb); + ok &= serialize_untagged_f64(f32vector_ref(obj, i), sb); } return ok; } - if(pmt_is_f64vector(obj)) { + if(is_f64vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_F64, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -458,12 +460,12 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_f64(pmt_f64vector_ref(obj, i), sb); + ok &= serialize_untagged_f64(f64vector_ref(obj, i), sb); } return ok; } - if(pmt_is_c32vector(obj)) { + if(is_c32vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_C32, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -472,14 +474,14 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - std::complex<float> c = pmt_c32vector_ref(obj, i); + std::complex<float> c = c32vector_ref(obj, i); ok &= serialize_untagged_f64(c.real(), sb); ok &= serialize_untagged_f64(c.imag(), sb); } return ok; } - if(pmt_is_c64vector(obj)) { + if(is_c64vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_C64, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -488,7 +490,7 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - std::complex<double> c = pmt_c64vector_ref(obj, i); + std::complex<double> c = c64vector_ref(obj, i); ok &= serialize_untagged_f64(c.real(), sb); ok &= serialize_untagged_f64(c.imag(), sb); } @@ -496,21 +498,21 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) } } - if (pmt_is_dict(obj)) - throw pmt_notimplemented("pmt_serialize (dict)", obj); + if (is_dict(obj)) + throw notimplemented("pmt::serialize (dict)", obj); - if (pmt_is_tuple(obj)){ - size_t tuple_len = pmt::pmt_length(obj); + if (is_tuple(obj)){ + size_t tuple_len = pmt::length(obj); ok = serialize_untagged_u8(PST_TUPLE, sb); ok &= serialize_untagged_u32(tuple_len, sb); for(size_t i=0; i<tuple_len; i++){ - ok &= pmt_serialize(pmt_tuple_ref(obj, i), sb); + ok &= serialize(tuple_ref(obj, i), sb); } return ok; } - //throw pmt_notimplemented("pmt_serialize (tuple)", obj); + //throw pmt_notimplemented("pmt::serialize (tuple)", obj); - throw pmt_notimplemented("pmt_serialize (?)", obj); + throw notimplemented("pmt::serialize (?)", obj); } /* @@ -520,7 +522,7 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) * Throws exception on malformed input. */ pmt_t -pmt_deserialize(std::streambuf &sb) +deserialize(std::streambuf &sb) { uint8_t tag; uint8_t u8; @@ -547,21 +549,21 @@ pmt_deserialize(std::streambuf &sb) if (!deserialize_untagged_u16(&u16, sb)) goto error; if (u16 > sizeof(tmpbuf)) - throw pmt_notimplemented("pmt_deserialize: very long symbol", - PMT_F); + throw notimplemented("pmt::deserialize: very long symbol", + PMT_F); if (sb.sgetn(tmpbuf, u16) != u16) goto error; - return pmt_intern(std::string(tmpbuf, u16)); + return intern(std::string(tmpbuf, u16)); case PST_INT32: if (!deserialize_untagged_u32(&u32, sb)) goto error; - return pmt_from_long((int32_t) u32); + return from_long((int32_t) u32); case PST_UINT64: if(!deserialize_untagged_u64(&u64, sb)) goto error; - return pmt_from_uint64(u64); + return from_uint64(u64); case PST_PAIR: return parse_pair(sb); @@ -569,14 +571,14 @@ pmt_deserialize(std::streambuf &sb) case PST_DOUBLE: if(!deserialize_untagged_f64(&f64, sb)) goto error; - return pmt_from_double( f64 ); + return from_double( f64 ); case PST_COMPLEX: { double r,i; if(!deserialize_untagged_f64(&r, sb) && !deserialize_untagged_f64(&i, sb)) goto error; - return pmt_make_rectangular( r,i ); + return make_rectangular( r,i ); } case PST_TUPLE: @@ -593,10 +595,10 @@ pmt_deserialize(std::streambuf &sb) uint32_t nitems; if(!deserialize_untagged_u32(&nitems, sb)) goto error; - pmt_t vec = pmt_make_vector(nitems, PMT_NIL); + pmt_t vec = make_vector(nitems, PMT_NIL); for(uint32_t i=0; i<nitems; i++) { - pmt_t item = pmt_deserialize(sb); - pmt_vector_set(vec, i, item); + pmt_t item = deserialize(sb); + vector_set(vec, i, item); } return vec; } @@ -619,149 +621,150 @@ pmt_deserialize(std::streambuf &sb) switch(utag) { case(UVI_U8): { - pmt_t vec = pmt_make_u8vector(nitems, 0); + pmt_t vec = make_u8vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { deserialize_untagged_u8(&u8, sb); - pmt_u8vector_set(vec, i, u8); + u8vector_set(vec, i, u8); } return vec; } case(UVI_S8): { - pmt_t vec = pmt_make_s8vector(nitems, 0); + pmt_t vec = make_s8vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { deserialize_untagged_u8(&u8, sb); - pmt_s8vector_set(vec, i, u8); + s8vector_set(vec, i, u8); } return vec; } case(UVI_U16): { - pmt_t vec = pmt_make_u16vector(nitems, 0); + pmt_t vec = make_u16vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { deserialize_untagged_u16(&u16, sb); - pmt_u16vector_set(vec, i, u16); + u16vector_set(vec, i, u16); } return vec; } case(UVI_S16): { - pmt_t vec = pmt_make_s16vector(nitems, 0); + pmt_t vec = make_s16vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { deserialize_untagged_u16(&u16, sb); - pmt_s16vector_set(vec, i, u16); + s16vector_set(vec, i, u16); } return vec; } case(UVI_U32): { - pmt_t vec = pmt_make_u32vector(nitems, 0); + pmt_t vec = make_u32vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { deserialize_untagged_u32(&u32, sb); - pmt_u32vector_set(vec, i, u32); + u32vector_set(vec, i, u32); } return vec; } case(UVI_S32): { - pmt_t vec = pmt_make_s32vector(nitems, 0); + pmt_t vec = make_s32vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { deserialize_untagged_u32(&u32, sb); - pmt_s32vector_set(vec, i, u32); + s32vector_set(vec, i, u32); } return vec; } case(UVI_U64): { - pmt_t vec = pmt_make_u64vector(nitems, 0); + pmt_t vec = make_u64vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { deserialize_untagged_u64(&u64, sb); - pmt_u64vector_set(vec, i, u64); + u64vector_set(vec, i, u64); } return vec; } case(UVI_S64): { - pmt_t vec = pmt_make_s64vector(nitems, 0); + pmt_t vec = make_s64vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { deserialize_untagged_u64(&u64, sb); - pmt_s64vector_set(vec, i, u64); + s64vector_set(vec, i, u64); } return vec; } case(UVI_F32): { - pmt_t vec = pmt_make_f32vector(nitems, 0); + pmt_t vec = make_f32vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { deserialize_untagged_f64(&f64, sb); - pmt_f32vector_set(vec, i, static_cast<float>(f64)); + f32vector_set(vec, i, static_cast<float>(f64)); } return vec; } case(UVI_F64): { - pmt_t vec = pmt_make_f64vector(nitems, 0); + pmt_t vec = make_f64vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { deserialize_untagged_f64(&f64, sb); - pmt_f64vector_set(vec, i, f64); + f64vector_set(vec, i, f64); } return vec; } case(UVI_C32): { - pmt_t vec = pmt_make_c32vector(nitems, 0); + pmt_t vec = make_c32vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { float re, im; deserialize_untagged_f64(&f64, sb); re = static_cast<float>(f64); deserialize_untagged_f64(&f64, sb); im = static_cast<float>(f64); - pmt_c32vector_set(vec, i, std::complex<float>(re, im)); + c32vector_set(vec, i, std::complex<float>(re, im)); } return vec; } case(UVI_C64): { - pmt_t vec = pmt_make_c64vector(nitems, 0); + pmt_t vec = make_c64vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { double re, im; deserialize_untagged_f64(&f64, sb); re = f64; deserialize_untagged_f64(&f64, sb); im = f64; - pmt_c64vector_set(vec, i, std::complex<double>(re, im)); + c64vector_set(vec, i, std::complex<double>(re, im)); } return vec; } default: - throw pmt_exception("pmt_deserialize: malformed input stream, tag value = ", - pmt_from_long(tag)); + throw exception("pmt::deserialize: malformed input stream, tag value = ", + from_long(tag)); } } case PST_DICT: case PST_COMMENT: - throw pmt_notimplemented("pmt_deserialize: tag value = ", - pmt_from_long(tag)); + throw notimplemented("pmt::deserialize: tag value = ", + from_long(tag)); default: - throw pmt_exception("pmt_deserialize: malformed input stream, tag value = ", - pmt_from_long(tag)); + throw exception("pmt::deserialize: malformed input stream, tag value = ", + from_long(tag)); } error: - throw pmt_exception("pmt_deserialize: malformed input stream", PMT_F); + throw exception("pmt::deserialize: malformed input stream", PMT_F); } /* * provide a simple string accessor to the serialized pmt form */ -std::string pmt_serialize_str(pmt_t obj){ +std::string +serialize_str(pmt_t obj){ std::stringbuf sb; - pmt_serialize(obj, sb); + serialize(obj, sb); return sb.str(); } @@ -769,9 +772,10 @@ std::string pmt_serialize_str(pmt_t obj){ /* * provide a simple string accessor to the deserialized pmt form */ -pmt_t pmt_deserialize_str(std::string s){ +pmt_t +deserialize_str(std::string s){ std::stringbuf sb(s); - return pmt_deserialize(sb); + return deserialize(sb); } @@ -792,17 +796,17 @@ parse_pair(std::streambuf &sb) // lastnptr = PMT_NIL; while (1){ - expr = pmt_deserialize(sb); // read the car + expr = deserialize(sb); // read the car - nptr = pmt_cons(expr, PMT_NIL); // build new cell - if (pmt_is_null(lastnptr)) + nptr = cons(expr, PMT_NIL); // build new cell + if (is_null(lastnptr)) val = nptr; else - pmt_set_cdr(lastnptr, nptr); + set_cdr(lastnptr, nptr); lastnptr = nptr; if (!deserialize_untagged_u8(&tag, sb)) // get tag of cdr - throw pmt_exception("pmt_deserialize: malformed input stream", PMT_F); + throw exception("pmt::deserialize: malformed input stream", PMT_F); if (tag == PST_PAIR) continue; // keep on looping... @@ -816,14 +820,14 @@ parse_pair(std::streambuf &sb) // default: push tag back and use pmt_deserialize to get the cdr // sb.sungetc(); - expr = pmt_deserialize(sb); + expr = deserialize(sb); break; } // // At this point, expr contains the value of the final cdr in the list. // - pmt_set_cdr(lastnptr, expr); + set_cdr(lastnptr, expr); return val; } |