On Dec 11, 2014 11:55 AM, "Carl Worth" <<a href="mailto:cworth@cworth.org">cworth@cworth.org</a>> wrote: > > From: Tapani Pälli <<a href="mailto:tapani.palli@intel.com">tapani.palli@intel.com</a>> > > These functions are useful when serializing an unknown number of items > to a blob. The caller can first save the current offset, write a > placeholder uint32, write out (and count) the items, then use > blob_overwrite_uint32 with the saved offset to replace the placeholder > value. > > Then, when deserializing, the reader will first read the count and > know how many subsequent items to expect. > > (I wrote this code after reading a very similar patch written by > Tapani when he wrote serialization code for IR. Since I re-used the > idea of his code so directly, I've credited him as the author of this > code. --Carl) > --- > src/glsl/blob.c | 23 +++++++++++++++++++++++ > src/glsl/blob.h | 25 +++++++++++++++++++++++++ > 2 files changed, 48 insertions(+) > > diff --git a/src/glsl/blob.c b/src/glsl/blob.c > index 0af71fc..dbd698a 100644 > --- a/src/glsl/blob.c > +++ b/src/glsl/blob.c > @@ -101,6 +101,21 @@ blob_create (void *mem_ctx) > } > > bool > +blob_overwrite_bytes (struct blob *blob, > + size_t offset, > + const void *bytes, > + size_t to_write) > +{ > + /* Detect an attempt to overwrite data out of bounds. */ > + if (offset < 0 || blob->size - offset < to_write) > + return false; > + > + memcpy (blob->data + offset, bytes, to_write); > + > + return true; > +} > + > +bool > blob_write_bytes (struct blob *blob, const void *bytes, size_t to_write) > { > if (! grow_to_fit (blob, to_write)) > @@ -135,6 +150,14 @@ blob_write_uint32 (struct blob *blob, uint32_t value) > } > > bool > +blob_overwrite_uint32 (struct blob *blob, > + size_t offset, > + uint32_t value) > +{ > + return blob_overwrite_bytes(blob, offset, &value, sizeof(value)); > +} > + > +bool > blob_write_uint64 (struct blob *blob, uint64_t value) > { > align_blob(blob, sizeof(value)); > diff --git a/src/glsl/blob.h b/src/glsl/blob.h > index 374b21e..165de13 100644 > --- a/src/glsl/blob.h > +++ b/src/glsl/blob.h > @@ -138,6 +138,31 @@ bool > blob_write_uint32 (struct blob *blob, uint32_t value); The header entry for overwrite_bytes should go in this patch rather than the first one. > > /** > + * Overwrite a uint32_t previously written to the blob. > + * > + * Writes a uint32_t value to an existing portion of the blob at an offset of > + * \offset. This data range must have previously been written to the blob by > + * one of the blob_write_* calls. > + * > + * > + * The expected usage is something like the following pattern: > + * > + * size_t offset; > + * > + * offset = blob->size; > + * blob_write_uint32 (blob, 0); // placeholder > + * ... various blob write calls, writing N items ... > + * blob_overwrite_uint32 (blob, offset, N); > + * > + * \return True unless the requested position or position+to_write lie outside > + * the current blob's size. > + */ > +bool > +blob_overwrite_uint32 (struct blob *blob, > + size_t offset, > + uint32_t value); > + > +/** > * Add a uint64_t to a blob. > * > * Note: This function will only write to a uint64_t-aligned offset from the > -- > 2.1.1 > > _______________________________________________ > mesa-dev mailing list > <a href="mailto:mesa-dev@lists.freedesktop.org">mesa-dev@lists.freedesktop.org</a> > <a href="http://lists.freedesktop.org/mailman/listinfo/mesa-dev">http://lists.freedesktop.org/mailman/listinfo/mesa-dev</a>