fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-01-06 15:20:17 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

util: implement Jose Fonseca's suggestions for u_buffer.h -> u_dynarray.h

Browse source 
Also describe invariants explicitly and use char* for arithmetic.
This commit is contained in:
Luca Barbieri 2010-04-13 06:05:12 +02:00
parent c2e804a7e1
commit 5f968a64dc
2 changed files with 96 additions and 57 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

57
src/gallium/auxiliary/util/u_buffer.h
View file

@ -1,57 +0,0 @@
#ifndef U_BUFFER_H
#define U_BUFFER_H
struct util_buffer
{
void* data;
unsigned size;
unsigned capacity;
};
static inline void
util_buffer_init(struct util_buffer* buf)
{
memset(buf, 0, sizeof(*buf));
}
static inline void
util_buffer_fini(struct util_buffer* buf)
{
if(buf->data) {
free(buf->data);
util_buffer_init(buf);
}
}
static inline void*
util_buffer_grow(struct util_buffer* buf, int size)
{
unsigned newsize = buf->size + size;
char* p;
if(newsize > buf->capacity) {
buf->capacity <<= 1;
if(newsize > buf->capacity)
buf->capacity = newsize;
buf->data = realloc(buf->data, buf->capacity);
}
p = (char*)buf->data + buf->size;
buf->size = newsize;
return p;
}
static inline void
util_buffer_trim(struct util_buffer* buf)
{
buf->data = realloc(buf->data, buf->size);
buf->capacity = buf->size;
}
#define util_buffer_append(buf, type, v) do {type __v = (v); memcpy(util_buffer_grow((buf), sizeof(type)), &__v, sizeof(type));} while(0)
#define util_buffer_top_ptr(buf, type) (type*)((buf)->data + (buf)->size - sizeof(type))
#define util_buffer_top(buf, type) *util_buffer_top_ptr(buf, type)
#define util_buffer_pop_ptr(buf, type) (type*)((buf)->data + ((buf)->size -= sizeof(type)))
#define util_buffer_pop(buf, type) *util_buffer_pop_ptr(buf, type)
#define util_buffer_contains(buf, type) ((buf)->size >= sizeof(type))
#endif /* U_BUFFER_H */

96
src/gallium/auxiliary/util/u_dynarray.h Normal file
View file

@ -0,0 +1,96 @@
/**************************************************************************
*
* Copyright 2010 Luca Barbieri
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial
* portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#ifndef U_DYNARRAY_H
#define U_DYNARRAY_H
#include "pipe/p_compiler.h"
#include "util/u_memory.h"
/* A zero-initialized version of this is guaranteed to represent an
* empty array.
*
* Also, size <= capacity and data != 0 if and only if capacity != 0
* capacity will always be the allocation size of data
*/
struct util_dynarray
{
void *data;
unsigned size;
unsigned capacity;
};
static INLINE void
util_dynarray_init(struct util_dynarray *buf)
{
memset(buf, 0, sizeof(*buf));
}
static INLINE void
util_dynarray_fini(struct util_dynarray *buf)
{
if(buf->data)
{
FREE(buf->data);
util_dynarray_init(buf);
}
}
static INLINE void *
util_dynarray_grow(struct util_dynarray *buf, int size)
{
unsigned newsize = buf->size + size;
char *p;
if(newsize > buf->capacity)
{
unsigned newcap = buf->capacity << 1;
if(newsize > newcap)
newcap = newsize;
buf->data = REALLOC(buf->data, buf->capacity, newcap);
buf->capacity = newcap;
}
p = (char *)buf->data + buf->size;
buf->size = newsize;
return p;
}
static INLINE void
util_dynarray_trim(struct util_dynarray *buf)
{
buf->data = REALLOC(buf->data, buf->capacity, buf->size);
buf->capacity = buf->size;
}
#define util_dynarray_append(buf, type, v) do {type __v = (v); memcpy(util_dynarray_grow((buf), sizeof(type)), &__v, sizeof(type));} while(0)
#define util_dynarray_top_ptr(buf, type) (type*)((char*)(buf)->data + (buf)->size - sizeof(type))
#define util_dynarray_top(buf, type) *util_dynarray_top_ptr(buf, type)
#define util_dynarray_pop_ptr(buf, type) (type*)((char*)(buf)->data + ((buf)->size -= sizeof(type)))
#define util_dynarray_pop(buf, type) *util_dynarray_pop_ptr(buf, type)
#define util_dynarray_contains(buf, type) ((buf)->size >= sizeof(type))
#endif /* U_DYNARRAY_H */