int stor_lookup_destroy_req_mashal(void *ptr, cmp_reader reader, cmp_writer writer, const struct _stor_lookup_destroy_req *in){ cmp_ctx_t cmp; cmp_init(&cmp, ptr, reader, writer); cmp_write_sint(&cmp, in->luid); return 0; }
int stor_fmoveto_req_unmash(void *ptr, cmp_reader reader, cmp_writer writer, struct _stor_fmoveto_req **out){ struct _stor_fmoveto_req *o; cmp_ctx_t cmp; cmp_init(&cmp, ptr, reader, writer); o = (struct _stor_fmoveto_req*)osapi_malloc(sizeof(*o)); if(o == NULL) return -ENOMEM; memset(o, 0, sizeof(*o)); cmp_read_long(&cmp,&o->fid); cmp_read_long(&cmp,&o->folder); { uint32_t size; cmp_read_str_size(&cmp, &size); if(size == 0){ o->fname = NULL; }else{ o->fname = (char*)osapi_malloc(size+1); if(o->fname == NULL){ osapi_free(o); return -ENOMEM; } reader(&cmp, o->fname, size); o->fname[size] = 0; } } *out = o; return 0; }
int stor_fdelete_req_mashal(void *ptr, cmp_reader reader, cmp_writer writer, const struct _stor_fdelete_req *in){ cmp_ctx_t cmp; cmp_init(&cmp, ptr, reader, writer); cmp_write_sint(&cmp, in->fid); return 0; }
int stor_fwrite_req_unmash(void *ptr, cmp_reader reader, cmp_writer writer, struct _stor_fwrite_req **out){ struct _stor_fwrite_req *o; cmp_ctx_t cmp; cmp_init(&cmp, ptr, reader, writer); o = (struct _stor_fwrite_req*)osapi_malloc(sizeof(*o)); if(o == NULL) return -ENOMEM; memset(o, 0, sizeof(*o)); cmp_read_long(&cmp,&o->fid); cmp_read_long(&cmp,&o->offset); cmp_read_bin_size(&cmp, &o->data_len); if(o->data_len == 0){ o->data = NULL; }else{ o->data = osapi_malloc(o->data_len); if(o->data == NULL){ stor_fwrite_req_free(o); return -ENOMEM; } reader(&cmp, o->data, o->data_len); } *out = o; return 0; }
int stor_fstat_rsp_mashal(void *ptr, cmp_reader reader, cmp_writer writer, const struct _stor_fstat_rsp *in){ cmp_ctx_t cmp; cmp_init(&cmp, ptr, reader, writer); cmp_write_sint(&cmp, in->fid); if(in->fname == NULL){ cmp_write_str(&cmp, in->fname, 0); }else{ cmp_write_str(&cmp, in->fname, strlen(in->fname)); } if(in->folder == NULL){ cmp_write_str(&cmp, in->folder, 0); }else{ cmp_write_str(&cmp, in->folder, strlen(in->folder)); } cmp_write_sint(&cmp, in->type); cmp_write_sint(&cmp, in->fatime); cmp_write_sint(&cmp, in->fmtime); cmp_write_sint(&cmp, in->fctime); cmp_write_sint(&cmp, in->fsize); cmp_write_bin(&cmp, in->snap, in->snap_len); return 0; }
int stor_fclose_rsp_mashal(void *ptr, cmp_reader reader, cmp_writer writer, const struct _stor_fclose_rsp *in){ cmp_ctx_t cmp; cmp_init(&cmp, ptr, reader, writer); cmp_write_sint(&cmp, in->errcode); return 0; }
Unpacker( char const * bytes, size_t len ) : _ptr( bytes ) , _end( bytes + len ) { _stack.reserve( 512 ); cmp_init( &_cmp, this, &Unpacker::read_bytes_, nullptr ); }
int stor_lookup_create_req_mashal(void *ptr, cmp_reader reader, cmp_writer writer, const struct _stor_lookup_create_req *in){ cmp_ctx_t cmp; cmp_init(&cmp, ptr, reader, writer); cmp_write_sint(&cmp, in->folder); cmp_write_sint(&cmp, in->type); cmp_write_sint(&cmp, in->asc); return 0; }
int stor_fwrite_rsp_mashal(void *ptr, cmp_reader reader, cmp_writer writer, const struct _stor_fwrite_rsp *in){ cmp_ctx_t cmp; cmp_init(&cmp, ptr, reader, writer); cmp_write_sint(&cmp, in->fid); cmp_write_sint(&cmp, in->offset); cmp_write_sint(&cmp, in->len); return 0; }
int main(void) { FILE *fh = NULL; cmp_ctx_t cmp; uint32_t array_size = 0; uint32_t str_size = 0; char hello[6] = {0, 0, 0, 0, 0, 0}; char message_pack[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; fh = fopen("cmp_data.dat", "w+b"); if (fh == NULL) error_and_exit("Error opening data.dat"); cmp_init(&cmp, fh, file_reader, file_writer); if (!cmp_write_array(&cmp, 2)) error_and_exit(cmp_strerror(&cmp)); if (!cmp_write_str(&cmp, "Hello", 5)) error_and_exit(cmp_strerror(&cmp)); if (!cmp_write_str(&cmp, "MessagePack", 11)) error_and_exit(cmp_strerror(&cmp)); rewind(fh); if (!cmp_read_array(&cmp, &array_size)) error_and_exit(cmp_strerror(&cmp)); /* You can read the str byte size and then read str bytes... */ if (!cmp_read_str_size(&cmp, &str_size)) error_and_exit(cmp_strerror(&cmp)); if (str_size > (sizeof(hello) - 1)) error_and_exit("Packed 'hello' length too long\n"); if (!read_bytes(hello, str_size, fh)) error_and_exit(cmp_strerror(&cmp)); /* * ...or you can set the maximum number of bytes to read and do it all in * one call */ str_size = sizeof(message_pack); if (!cmp_read_str(&cmp, message_pack, &str_size)) error_and_exit(cmp_strerror(&cmp)); printf("Array Length: %zu.\n", array_size); printf("[\"%s\", \"%s\"]\n", hello, message_pack); fclose(fh); return EXIT_SUCCESS; }
int stor_fclose_rsp_unmash(void *ptr, cmp_reader reader, cmp_writer writer, struct _stor_fclose_rsp **out){ struct _stor_fclose_rsp *o; cmp_ctx_t cmp; cmp_init(&cmp, ptr, reader, writer); o = (struct _stor_fclose_rsp*)osapi_malloc(sizeof(*o)); if(o == NULL) return -ENOMEM; memset(o, 0, sizeof(*o)); cmp_read_int(&cmp, &o->errcode); *out = o; return 0; }
int stor_fmoveto_req_mashal(void *ptr, cmp_reader reader, cmp_writer writer, const struct _stor_fmoveto_req *in){ cmp_ctx_t cmp; cmp_init(&cmp, ptr, reader, writer); cmp_write_sint(&cmp, in->fid); cmp_write_sint(&cmp, in->folder); if(in->fname == NULL){ cmp_write_str(&cmp, in->fname, 0); }else{ cmp_write_str(&cmp, in->fname, strlen(in->fname)); } return 0; }
int stor_lookup_destroy_req_unmash(void *ptr, cmp_reader reader, cmp_writer writer, struct _stor_lookup_destroy_req **out){ struct _stor_lookup_destroy_req *o; cmp_ctx_t cmp; cmp_init(&cmp, ptr, reader, writer); o = (struct _stor_lookup_destroy_req*)osapi_malloc(sizeof(*o)); if(o == NULL) return -ENOMEM; memset(o, 0, sizeof(*o)); cmp_read_long(&cmp,&o->luid); *out = o; return 0; }
void scene_save(Scene* scene, const char* path) { FILE *file = NULL; cmp_ctx_t context; file = fopen(path, "w+b"); if(file == NULL) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to open %s. ERROR: %d\n", path, errno); } cmp_init(&context, file, file_reader, file_writer); scene_serialize(scene, &context); fclose(file); SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Scene `%s` serialized.\n", scene->path); }
bool run_test(uint32_t* hash_out) { char* data = benchmark_in_situ_copy(file_data, file_size); if (!data) return false; buffer_t buffer; buffer.data = data; buffer.left = file_size; cmp_ctx_t cmp; cmp_init(&cmp, &buffer, buffer_cmp_reader, NULL); bool ok = hash_element(&cmp, hash_out); benchmark_in_situ_free(data); return ok; }
void *rcservo_save_calibration(const rcservo_t *s, void *calib) { cmp_ctx_t cmp; void *writep = calib; cmp_init(&cmp, &writep, NULL, cmp_write); bool err = false; err = err || !cmp_write_array(&cmp, 6); err = err || !cmp_write_u16(&cmp, s->calib.gain_pos); err = err || !cmp_write_u16(&cmp, s->calib.gain_neg); err = err || !cmp_write_u16(&cmp, s->calib.zero); err = err || !cmp_write_u16(&cmp, s->calib.min); err = err || !cmp_write_u16(&cmp, s->calib.max); err = err || !cmp_write_u8(&cmp, s->calib.update_period); if (err || (char *)calib + RC_SERVO_CALIBRATION_BUFFER_SIZE != writep) { return NULL; } return writep; }
const void *rcservo_load_calibration(rcservo_t *s, const void *calib) { cmp_ctx_t cmp; const void *readp = calib; cmp_init(&cmp, &readp, cmp_read, NULL); bool err = false; uint32_t array_size; err = err || !cmp_read_array(&cmp, &array_size); err = err || (array_size != 6); err = err || !cmp_read_u16(&cmp, &s->calib.gain_pos); err = err || !cmp_read_u16(&cmp, &s->calib.gain_neg); err = err || !cmp_read_u16(&cmp, &s->calib.zero); err = err || !cmp_read_u16(&cmp, &s->calib.min); err = err || !cmp_read_u16(&cmp, &s->calib.max); err = err || !cmp_read_u8(&cmp, &s->calib.update_period); if (err || (char *)calib + RC_SERVO_CALIBRATION_BUFFER_SIZE != readp) { return NULL; } return readp; }
int stor_lookup_next_rsp_mashal(void *ptr, cmp_reader reader, cmp_writer writer, const struct _stor_lookup_next_rsp *in){ cmp_ctx_t cmp; cmp_init(&cmp, ptr, reader, writer); cmp_write_sint(&cmp, in->luid); { stor_fstat_rsp_t *obj; int i; fixarray_zip(in->rfiles); cmp_write_array(&cmp, fixarray_num(in->rfiles)); for (i = 0; i < fixarray_num(in->rfiles); i++){ if(fixarray_get(in->rfiles, i, (void **)&obj) != 0){ return -1; } cmp_write_sint(&cmp, obj->fid); if(obj->fname == NULL){ cmp_write_str(&cmp, obj->fname, 0); }else{ cmp_write_str(&cmp, obj->fname, strlen(obj->fname)); } if(obj->folder == NULL){ cmp_write_str(&cmp, obj->folder, 0); }else{ cmp_write_str(&cmp, obj->folder, strlen(obj->folder)); } cmp_write_sint(&cmp, obj->type); cmp_write_sint(&cmp, obj->fatime); cmp_write_sint(&cmp, obj->fmtime); cmp_write_sint(&cmp, obj->fctime); cmp_write_sint(&cmp, obj->fsize); cmp_write_bin(&cmp, obj->snap, obj->snap_len); } } return 0; }
int main(void) { /* Write your code here */ SystemCoreClockUpdate(); lvd_init(); led_sample_init(); mcu_tracer_config(); startup_reason_report(); //Inits FTM_init(); VREF_init(); cmp_init(); // printf("SystemBusClock = %ld\n", SystemBusClock); //printf("SystemCoreClock = %ld\n", SystemCoreClock); tracer_green=1; _taskcall_task_register_time(&task_watchdog_reset,(120000000*2)); _taskcall_task_register_time(&task_led_lauflicht,(120000000*3)); _taskcall_start(); while(1){ //put here low priority tasks, like communication mcu_tracer_process(); mainloop_iterations=mainloop_iterations+1; if(mainloop_iterations>1000000) mainloop_iterations=0; } /* This for loop should be replaced. By default this loop allows a single stepping. */ init_leds(); while(1); /* Never leave main */ return 0; }
int main(int argc, char** argv) { if( 1 >= argc){ printf("usage: %s file offset length\n", basename(argv[0])); return 0; } FILE *fh = NULL; cmp_ctx_t cmp; uint16_t year = 1983; uint8_t month = 5; uint8_t day = 28; int64_t sint = 0; uint64_t uint = 0; float flt = 0.0f; double dbl = 0.0; bool boolean = false; uint8_t fake_bool = 0; uint32_t string_size = 0; uint32_t array_size = 0; uint32_t binary_size = 0; uint32_t map_size = 0; int8_t ext_type = 0; uint32_t ext_size = 0; char sbuf[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; fh = fopen(argv[1], "rb"); if (fh == NULL){ error_and_exit(strerror(errno)); } cmp_init(&cmp, fh, file_reader, file_writer); /* Alternately, you can read objects until the stream is empty */ while (1) { cmp_object_t obj; if (!cmp_read_object(&cmp, &obj)) { if (feof(fh)) break; error_and_exit(cmp_strerror(&cmp)); } switch (obj.type) { case CMP_TYPE_POSITIVE_FIXNUM: case CMP_TYPE_UINT8: //printf("Unsigned Integer: %u\n", obj.as.u8); printf("Unsigned Integer: %u\n", obj.as.u8); break; case CMP_TYPE_FIXMAP: case CMP_TYPE_MAP16: case CMP_TYPE_MAP32: printf("Map: %u\n", obj.as.map_size); break; case CMP_TYPE_FIXARRAY: case CMP_TYPE_ARRAY16: case CMP_TYPE_ARRAY32: printf("Array: %u\n", obj.as.array_size); break; case CMP_TYPE_FIXSTR: case CMP_TYPE_STR8: case CMP_TYPE_STR16: case CMP_TYPE_STR32: if (!read_bytes(sbuf, obj.as.str_size, fh)) error_and_exit(strerror(errno)); sbuf[obj.as.str_size] = 0; printf("String: %s\n", sbuf); break; case CMP_TYPE_BIN8: case CMP_TYPE_BIN16: case CMP_TYPE_BIN32: memset(sbuf, 0, sizeof(sbuf)); if (!read_bytes(sbuf, obj.as.bin_size, fh)) error_and_exit(strerror(errno)); printf("Binary: %s\n", sbuf); break; case CMP_TYPE_NIL: printf("NULL\n"); break; case CMP_TYPE_BOOLEAN: if (obj.as.boolean) printf("Boolean: true\n"); else printf("Boolean: false\n"); break; case CMP_TYPE_EXT8: case CMP_TYPE_EXT16: case CMP_TYPE_EXT32: case CMP_TYPE_FIXEXT1: case CMP_TYPE_FIXEXT2: case CMP_TYPE_FIXEXT4: case CMP_TYPE_FIXEXT8: case CMP_TYPE_FIXEXT16: if (obj.as.ext.type == 1) { /* Date object */ if (!read_bytes(&year, sizeof(uint16_t), fh)) error_and_exit(strerror(errno)); if (!read_bytes(&month, sizeof(uint8_t), fh)) error_and_exit(strerror(errno)); if (!read_bytes(&day, sizeof(uint8_t), fh)) error_and_exit(strerror(errno)); printf("Date: %u/%u/%u\n", year, month, day); } else { printf("Extended type {%d, %u}: ", obj.as.ext.type, obj.as.ext.size); while (obj.as.ext.size--) { read_bytes(sbuf, sizeof(uint8_t), fh); printf("%02x ", sbuf[0]); } printf("\n"); } break; case CMP_TYPE_FLOAT: printf("Float: %f\n", obj.as.flt); break; case CMP_TYPE_DOUBLE: printf("Double: %f\n", obj.as.dbl); break; case CMP_TYPE_UINT16: printf("Unsigned Integer: %u\n", obj.as.u16); break; case CMP_TYPE_UINT32: printf("Unsigned Integer: %u\n", obj.as.u32); break; case CMP_TYPE_UINT64: printf("Unsigned Integer: %" PRIu64 "\n", obj.as.u64); break; case CMP_TYPE_NEGATIVE_FIXNUM: case CMP_TYPE_SINT8: printf("Signed Integer: %d\n", obj.as.s8); break; case CMP_TYPE_SINT16: printf("Signed Integer: %d\n", obj.as.s16); break; case CMP_TYPE_SINT32: printf("Signed Integer: %d\n", obj.as.s32); break; case CMP_TYPE_SINT64: printf("Signed Integer: %" PRId64 "\n", obj.as.s64); break; default: printf("Unrecognized object type %u\n", obj.type); break; } } fclose(fh); return EXIT_SUCCESS; }
int stor_fstat_rsp_unmash(void *ptr, cmp_reader reader, cmp_writer writer, struct _stor_fstat_rsp **out){ struct _stor_fstat_rsp *o; cmp_ctx_t cmp; cmp_init(&cmp, ptr, reader, writer); o = (struct _stor_fstat_rsp*)osapi_malloc(sizeof(*o)); if(o == NULL) return -ENOMEM; memset(o, 0, sizeof(*o)); cmp_read_long(&cmp,&o->fid); { uint32_t size; cmp_read_str_size(&cmp, &size); if(size == 0){ o->fname = NULL; }else{ o->fname = (char*)osapi_malloc(size+1); if(o->fname == NULL){ osapi_free(o); return -ENOMEM; } reader(&cmp, o->fname, size); o->fname[size] = 0; } } { uint32_t size; cmp_read_str_size(&cmp, &size); if(size == 0){ o->folder = NULL; }else{ o->folder = (char*)osapi_malloc(size+1); if(o->folder == NULL){ osapi_free(o); return -ENOMEM; } reader(&cmp, o->folder, size); o->folder[size] = 0; } } cmp_read_int(&cmp, &o->type); cmp_read_long(&cmp,&o->fatime); cmp_read_long(&cmp,&o->fmtime); cmp_read_long(&cmp,&o->fctime); cmp_read_long(&cmp,&o->fsize); cmp_read_bin_size(&cmp, &o->snap_len); if(o->snap_len == 0){ o->snap = NULL; }else{ o->snap = osapi_malloc(o->snap_len); if(o->snap == NULL){ stor_fstat_rsp_free(o); return -ENOMEM; } reader(&cmp, o->snap, o->snap_len); } *out = o; return 0; }
int audio_init(int type) { int arg; /* argument for ioctl calls */ int status; /* return status of system calls */ /* open sound device */ if (type == 0) { infd = open("/dev/dsp", O_RDONLY); outfd = open("/dev/dsp", O_WRONLY); if (infd < 0) { perror("open of /dev/dsp failed"); return 0; } /* set sampling parameters */ arg = SIZE; /* sample size */ status = ioctl(infd,SNDCTL_DSP_SETFMT, &arg); status = ioctl(outfd,SNDCTL_DSP_SETFMT, &arg); if (status == -1) { perror("SOUND_PCM_WRITE_BITS ioctl failed"); return 0; } if (arg != SIZE) { perror("unable to set sample size"); return 0; } arg = CHANNELS; /* mono or stereo */ status = ioctl(infd, SNDCTL_DSP_CHANNELS, &arg); status = ioctl(outfd, SNDCTL_DSP_CHANNELS, &arg); if (status == -1) { perror("SOUND_PCM_WRITE_CHANNELS ioctl failed"); return 0; } if (arg != CHANNELS) { perror("unable to set number of channels"); return 0; } int frag = (32 << 16) | 9; status = ioctl(infd, SNDCTL_DSP_SETFRAGMENT, &frag); status = ioctl(outfd,SNDCTL_DSP_SETFRAGMENT , &frag); if (status == -1) { perror("SOUND_PCM_SUBDIVIDE ioctl failed"); return 0; } arg=RATE; status = ioctl(infd, SNDCTL_DSP_SPEED, &arg); status = ioctl(outfd, SNDCTL_DSP_SPEED, &arg); if (status == -1) { perror("SOUND_PCM_WRITE_WRITE ioctl failed"); return 0; } } else { outfd = 1; infd = 0; } cmp_init(160, 8, 1); fprintf(stderr, "Audio initialized...\n"); return 1; }
int main(void) { FILE *fh = NULL; cmp_ctx_t cmp; uint16_t year = 1983; uint8_t month = 5; uint8_t day = 28; int64_t sint = 0; uint64_t uint = 0; float flt = 0.0f; double dbl = 0.0; bool boolean = false; uint8_t fake_bool = 0; uint32_t string_size = 0; uint32_t array_size = 0; uint32_t binary_size = 0; uint32_t map_size = 0; int8_t ext_type = 0; uint32_t ext_size = 0; char sbuf[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; fh = fopen("cmp_data.dat", "w+b"); if (fh == NULL) error_and_exit("Error opening data.dat"); cmp_init(&cmp, fh, file_reader, file_skipper, file_writer); /* * When you write an array, you first specify the number of array * elements, then you write that many elements. */ if (!cmp_write_array(&cmp, 9)) error_and_exit(cmp_strerror(&cmp)); if (!cmp_write_sint(&cmp, -14)) error_and_exit(cmp_strerror(&cmp)); if (!cmp_write_uint(&cmp, 38)) error_and_exit(cmp_strerror(&cmp)); if (!cmp_write_float(&cmp, 1.8f)) error_and_exit(cmp_strerror(&cmp)); if (!cmp_write_double(&cmp, 300.4)) error_and_exit(cmp_strerror(&cmp)); if (!cmp_write_nil(&cmp)) error_and_exit(cmp_strerror(&cmp)); if (!cmp_write_true(&cmp)) error_and_exit(cmp_strerror(&cmp)); if (!cmp_write_false(&cmp)) error_and_exit(cmp_strerror(&cmp)); if (!cmp_write_bool(&cmp, false)) error_and_exit(cmp_strerror(&cmp)); if (!cmp_write_u8_as_bool(&cmp, 1)) error_and_exit(cmp_strerror(&cmp)); /* Array full */ /* * Maps work similar to arrays, but the length is in "pairs", so this * writes 2 pairs to the map. Subsequently, pairs are written in key, * value order. */ if (!cmp_write_map(&cmp, 2)) error_and_exit(cmp_strerror(&cmp)); /* You can write string data all at once... */ if (!cmp_write_str(&cmp, "Greeting", 8)) error_and_exit(cmp_strerror(&cmp)); if (!cmp_write_str(&cmp, "Hello", 5)) error_and_exit(cmp_strerror(&cmp)); if (!cmp_write_str(&cmp, "Name", 4)) error_and_exit(cmp_strerror(&cmp)); /* ...or in chunks */ if (!cmp_write_str_marker(&cmp, 5)) error_and_exit(cmp_strerror(&cmp)); if (file_writer(&cmp, "Li", 2) != 2) error_and_exit(strerror(errno)); if (file_writer(&cmp, "nus", 3) != 3) error_and_exit(strerror(errno)); /* Map full */ /* Binary data functions the same as string data */ if (!cmp_write_bin(&cmp, "MessagePack", 11)) error_and_exit(cmp_strerror(&cmp)); if (!cmp_write_bin_marker(&cmp, 8)) error_and_exit(cmp_strerror(&cmp)); if (file_writer(&cmp, "is ", 3) != 3) error_and_exit(strerror(errno)); if (file_writer(&cmp, "great", 5) != 5) error_and_exit(strerror(errno)); /* * With extended types, you can create your own custom types. Here we * create a simple date type. */ /* cmp_write_ext_marker(type, size) */ if (!cmp_write_ext_marker(&cmp, 1, 4)) error_and_exit(cmp_strerror(&cmp)); file_writer(&cmp, &year, sizeof(uint16_t)); file_writer(&cmp, &month, sizeof(uint8_t)); file_writer(&cmp, &day, sizeof(uint8_t)); /* Now we can read the data back just as easily */ rewind(fh); if (!cmp_read_array(&cmp, &array_size)) error_and_exit(cmp_strerror(&cmp)); if (array_size != 9) error_and_exit("Array size was not 9"); if (!cmp_read_sinteger(&cmp, &sint)) error_and_exit(cmp_strerror(&cmp)); if (sint != -14) error_and_exit("Signed int was not -14"); if (!cmp_read_uinteger(&cmp, &uint)) error_and_exit(cmp_strerror(&cmp)); if (uint != 38) error_and_exit("Unsigned int was not 38"); if (!cmp_read_float(&cmp, &flt)) error_and_exit(cmp_strerror(&cmp)); if (flt != 1.8f) error_and_exit("Float was not 1.8f"); if (!cmp_read_double(&cmp, &dbl)) error_and_exit(cmp_strerror(&cmp)); if (dbl != 300.4) error_and_exit("Double was not 300.f"); if (!cmp_read_nil(&cmp)) error_and_exit(cmp_strerror(&cmp)); if (!cmp_read_bool(&cmp, &boolean)) error_and_exit(cmp_strerror(&cmp)); if (boolean != true) error_and_exit("First boolean was not true"); if (!cmp_read_bool(&cmp, &boolean)) error_and_exit(cmp_strerror(&cmp)); if (boolean != false) error_and_exit("Second boolean was not false"); if (!cmp_read_bool(&cmp, &boolean)) error_and_exit(cmp_strerror(&cmp)); if (boolean != false) error_and_exit("Third boolean was not false"); if (!cmp_read_bool_as_u8(&cmp, &fake_bool)) error_and_exit(cmp_strerror(&cmp)); if (fake_bool != 1) { fprintf(stderr, "%u.\n", fake_bool); error_and_exit("Third boolean (u8) was not 1"); } if (!cmp_read_map(&cmp, &map_size)) error_and_exit(cmp_strerror(&cmp)); if (map_size != 2) error_and_exit("Map size was not 2"); /* * String reading here. Note that normally strings are encoded using * UTF-8. I have cleverly restricted this example to ASCII, which overlaps * UTF-8 encoding, but this must not be assumed in real-world code. * * You can read strings in two ways. Either you can read the string's size * in bytes and then read the bytes manually... */ if (!cmp_read_str_size(&cmp, &string_size)) error_and_exit(cmp_strerror(&cmp)); if (string_size != 8) error_and_exit("Greeting string key size was not 8"); if (!read_bytes(sbuf, 8, fh)) error_and_exit(strerror(errno)); sbuf[string_size] = 0; if (strncmp(sbuf, "Greeting", 8) != 0) error_and_exit("Greeting string key name was not 'Greeting'"); /* * ...or you can set the maximum number of bytes to read and do it all in * one call. cmp_read_str will write no more than "size" bytes, including * the terminating NULL, to the passed buffer. If the string's size * exceeds the passed buffer size, the "size" input is set to the number of * bytes necessary, not including the terminating NULL. Otherwise, the * "size" input is set to the number of bytes written, not including the * terminating NULL. */ string_size = sizeof(sbuf); if (!cmp_read_str(&cmp, sbuf, &string_size)) error_and_exit(cmp_strerror(&cmp)); if (strncmp(sbuf, "Hello", 5) != 0) error_and_exit("Greeting string value was not 'Hello'"); string_size = sizeof(sbuf); if (!cmp_read_str(&cmp, sbuf, &string_size)) error_and_exit(cmp_strerror(&cmp)); if (strncmp(sbuf, "Name", 4) != 0) error_and_exit("Name key name was not 'Name'"); string_size = sizeof(sbuf); if (!cmp_read_str(&cmp, sbuf, &string_size)) error_and_exit(cmp_strerror(&cmp)); if (strncmp(sbuf, "Linus", 5) != 0) error_and_exit("Name key value was not 'Linus'"); memset(sbuf, 0, sizeof(sbuf)); binary_size = sizeof(sbuf); if (!cmp_read_bin(&cmp, &sbuf, &binary_size)) error_and_exit(cmp_strerror(&cmp)); if (memcmp(sbuf, "MessagePack", 11) != 0) error_and_exit("1st binary value was not 'MessagePack'"); memset(sbuf, 0, sizeof(sbuf)); binary_size = sizeof(sbuf); if (!cmp_read_bin(&cmp, &sbuf, &binary_size)) error_and_exit(cmp_strerror(&cmp)); if (memcmp(sbuf, "is great", 8) != 0) error_and_exit("2nd binary value was not 'is great'"); if (!cmp_read_ext_marker(&cmp, &ext_type, &ext_size)) error_and_exit(cmp_strerror(&cmp)); if (!read_bytes(&year, sizeof(uint16_t), fh)) error_and_exit(strerror(errno)); if (!read_bytes(&month, sizeof(uint8_t), fh)) error_and_exit(strerror(errno)); if (!read_bytes(&day, sizeof(uint8_t), fh)) error_and_exit(strerror(errno)); if (year != 1983) error_and_exit("Year was not 1983"); if (month != 5) error_and_exit("Month was not 5"); if (day != 28) error_and_exit("Day was not 28"); rewind(fh); /* Alternately, you can read objects until the stream is empty */ while (1) { cmp_object_t obj; if (!cmp_read_object(&cmp, &obj)) { if (feof(fh)) break; error_and_exit(cmp_strerror(&cmp)); } switch (obj.type) { case CMP_TYPE_POSITIVE_FIXNUM: case CMP_TYPE_UINT8: printf("Unsigned Integer: %u\n", obj.as.u8); break; case CMP_TYPE_FIXMAP: case CMP_TYPE_MAP16: case CMP_TYPE_MAP32: printf("Map: %u\n", obj.as.map_size); break; case CMP_TYPE_FIXARRAY: case CMP_TYPE_ARRAY16: case CMP_TYPE_ARRAY32: printf("Array: %u\n", obj.as.array_size); break; case CMP_TYPE_FIXSTR: case CMP_TYPE_STR8: case CMP_TYPE_STR16: case CMP_TYPE_STR32: if (!read_bytes(sbuf, obj.as.str_size, fh)) error_and_exit(strerror(errno)); sbuf[obj.as.str_size] = 0; printf("String: %s\n", sbuf); break; case CMP_TYPE_BIN8: case CMP_TYPE_BIN16: case CMP_TYPE_BIN32: memset(sbuf, 0, sizeof(sbuf)); if (!read_bytes(sbuf, obj.as.bin_size, fh)) error_and_exit(strerror(errno)); printf("Binary: %s\n", sbuf); break; case CMP_TYPE_NIL: printf("NULL\n"); break; case CMP_TYPE_BOOLEAN: if (obj.as.boolean) printf("Boolean: true\n"); else printf("Boolean: false\n"); break; case CMP_TYPE_EXT8: case CMP_TYPE_EXT16: case CMP_TYPE_EXT32: case CMP_TYPE_FIXEXT1: case CMP_TYPE_FIXEXT2: case CMP_TYPE_FIXEXT4: case CMP_TYPE_FIXEXT8: case CMP_TYPE_FIXEXT16: if (obj.as.ext.type == 1) { /* Date object */ if (!read_bytes(&year, sizeof(uint16_t), fh)) error_and_exit(strerror(errno)); if (!read_bytes(&month, sizeof(uint8_t), fh)) error_and_exit(strerror(errno)); if (!read_bytes(&day, sizeof(uint8_t), fh)) error_and_exit(strerror(errno)); printf("Date: %u/%u/%u\n", year, month, day); } else { printf("Extended type {%d, %u}: ", obj.as.ext.type, obj.as.ext.size ); while (obj.as.ext.size--) { read_bytes(sbuf, sizeof(uint8_t), fh); printf("%02x ", sbuf[0]); } printf("\n"); } break; case CMP_TYPE_FLOAT: printf("Float: %f\n", obj.as.flt); break; case CMP_TYPE_DOUBLE: printf("Double: %f\n", obj.as.dbl); break; case CMP_TYPE_UINT16: printf("Unsigned Integer: %u\n", obj.as.u16); break; case CMP_TYPE_UINT32: printf("Unsigned Integer: %u\n", obj.as.u32); break; case CMP_TYPE_UINT64: printf("Unsigned Integer: %" PRIu64 "\n", obj.as.u64); break; case CMP_TYPE_NEGATIVE_FIXNUM: case CMP_TYPE_SINT8: printf("Signed Integer: %d\n", obj.as.s8); break; case CMP_TYPE_SINT16: printf("Signed Integer: %d\n", obj.as.s16); break; case CMP_TYPE_SINT32: printf("Signed Integer: %d\n", obj.as.s32); break; case CMP_TYPE_SINT64: printf("Signed Integer: %" PRId64 "\n", obj.as.s64); break; default: printf("Unrecognized object type %u\n", obj.type); break; } } fclose(fh); return EXIT_SUCCESS; }
int stor_lookup_next_rsp_unmash(void *ptr, cmp_reader reader, cmp_writer writer, struct _stor_lookup_next_rsp **out){ struct _stor_lookup_next_rsp *o; cmp_ctx_t cmp; cmp_init(&cmp, ptr, reader, writer); o = (struct _stor_lookup_next_rsp*)osapi_malloc(sizeof(*o)); if(o == NULL) return -ENOMEM; memset(o, 0, sizeof(*o)); cmp_read_long(&cmp,&o->luid); { stor_fstat_rsp_t *obj; uint32_t size; int i; cmp_read_array(&cmp, &size); fixarray_create(size, &o->rfiles); for (i = 0; i < size; i++){ obj = osapi_malloc(sizeof(*obj)); if(obj == NULL) { osapi_free(o); return -ENOMEM; } cmp_read_long(&cmp,&obj->fid); { uint32_t size; cmp_read_str_size(&cmp, &size); if(size == 0){ obj->fname = NULL; }else{ obj->fname = (char*)osapi_malloc(size+1); if(obj->fname == NULL){ osapi_free(o); return -ENOMEM; } reader(&cmp, obj->fname, size); obj->fname[size] = 0; } } { uint32_t size; cmp_read_str_size(&cmp, &size); if(size == 0){ obj->folder = NULL; }else{ obj->folder = (char*)osapi_malloc(size+1); if(obj->folder == NULL){ osapi_free(o); return -ENOMEM; } reader(&cmp, obj->folder, size); obj->folder[size] = 0; } } cmp_read_int(&cmp, &obj->type); cmp_read_long(&cmp,&obj->fatime); cmp_read_long(&cmp,&obj->fmtime); cmp_read_long(&cmp,&obj->fctime); cmp_read_long(&cmp,&obj->fsize); cmp_read_bin_size(&cmp, &obj->snap_len); if(obj->snap_len == 0){ obj->snap = NULL; }else{ obj->snap = osapi_malloc(obj->snap_len); if(obj->snap == NULL){ return -ENOMEM; } reader(ptr, obj->snap, obj->snap_len); } fixarray_set(o->rfiles, i, obj); } } *out = o; return 0; }