include/vec.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
vec *	vec_init (unsigned long int initsize)
vec *	vec_read (int srcfd, unsigned int size)
vec *	vec_copy (const struct vec *vec)
vec *	vec_reinit (struct vec *v, unsigned long int initsize)
int	vec_free (struct vec *vec)
void	vec_resetpos (struct vec *vec)
void	vec_reseterr (struct vec *vec)
unsigned long int	vec_putvbyte (struct vec *vec, unsigned long int n)
unsigned long int	vec_getvbyte (struct vec *vec, unsigned long int *n)
unsigned long int	vec_scanvbyte (struct vec *vec)
unsigned int	vec_vbyte_len (unsigned long int n)
int	vec_err (const struct vec *vec)
int	vec_eof (const struct vec *vec)
unsigned long int	vec_length (const struct vec *vec)
unsigned long int	vec_position (const struct vec *vec)
unsigned int	vec_write (struct vec *src, int dstfd)
unsigned int	vec_append (struct vec *dst, const struct vec *src)
int	vec_cmp (const struct vec *one, const struct vec *two)

---

Function Documentation

unsigned int vec_append	(	struct vec *	dst,
		const struct vec *	src
	)

Definition at line 96 of file vec.c.

References vec::err, vec::len, vec::pos, vec::size, vec_expand(), and vec::vector.

                                                                {
    unsigned int size = src->len - src->pos;

    /* expand vector if required */
    while ((dst->size < dst->pos + size) && vec_expand(dst, dst->pos + size)) ;

    if (!dst->err && (dst != src)) {
        /* append stuff */
        memcpy(dst->vector + dst->pos, src->vector + src->pos, size);
        dst->pos += size;
        dst->len = dst->pos;
        return size;
    } else {
        return 0;
    }
}

Here is the call graph for this function:

int vec_cmp	(	const struct vec *	one,
		const struct vec *	two
	)

Definition at line 293 of file vec.c.

References vec::len, and vec::vector.

                                                          {
    if (one->len != two->len) {
        return one->len - two->len;
    } else {
        return (memcmp(one->vector, two->vector, one->len));
    }
}

struct vec* vec_copy

(

const struct vec *

vec

)

[read]

Definition at line 219 of file vec.c.

References vec::len, vec::pos, and vec::vector.

                                          {
    struct vec* nv = malloc(sizeof(*nv));

    if (nv && (nv->vector = malloc(v->len))) {
        nv->pos = v->pos;
        nv->len = v->len;
        nv->size = v->len;
        nv->err = 0;
        memcpy(nv->vector, v->vector, nv->size);
    } else if (nv) {
        free(nv);
        return NULL;
    }

    return nv;
}

int vec_eof

(

const struct vec *

vec

)

Definition at line 207 of file vec.c.

References vec::len, and vec::pos.

                                 {
    return (v->pos == v->len);
}

int vec_err

(

const struct vec *

vec

)

Definition at line 203 of file vec.c.

References vec::err.

                                 {
    return v->err;
}

int vec_free

(

struct vec *

vec

)

Definition at line 82 of file vec.c.

References vec::vector.

Referenced by get_list_at().

                            {
    free(v->vector);
    free(v);
    return 1;
}

Here is the caller graph for this function:

unsigned long int vec_getvbyte	(	struct vec *	vec,
		unsigned long int *	n
	)

Definition at line 139 of file vec.c.

References vec::err, vec::len, vec::pos, and vec::vector.

Referenced by get_list_at().

                                                                    {
    unsigned long int ret = 1, 
                      count = 0, 
                      get = 0;

    *n = 0;
    while (v->pos < v->len) {
        if (((get = ((uint8_t) v->vector[v->pos++])) & 0x80) == 0x80) {
            /* For each time we get a group of 7 bits, need to left-shift the 
               latest group by an additional 7 places, since the groups were 
               effectively stored in reverse order.*/
            *n |= ((get & 0x7f) << count);
            ret++;
            count += 7;
        } else if (ret > (sizeof(*n))) {
            if (ret == ((sizeof(*n) + 1)) 
              && (get < (1 << (sizeof(*n) + 1)))) {
                /* its a large, but valid number */
                *n |= get << count;
                return ret;
            } else {
                /* we've overflowed, return error */
                return 0;
            }
        } else {
            /* Now get the final 7 bits, which need to be left-shifted by a 
               factor of 7. */
            *n |= get << count;
            return ret;
        }
    }

    v->err = ENOSPC;
    return 0;
}

Here is the caller graph for this function:

struct vec* vec_init

(

unsigned long int

initsize

)

[read]

Definition at line 36 of file vec.c.

Referenced by get_list_at().

                                                 {
    struct vec* v = malloc(sizeof(*v));

    if (v && (v->vector = malloc(initsize))) {
        v->size = initsize;
        v->pos = v->len = 0;
        v->err = 0;
        return v;
    } else if (v) {
        free(v);
    }

    return NULL;
}

Here is the caller graph for this function:

unsigned long int vec_length

(

const struct vec *

vec

)

Definition at line 215 of file vec.c.

References vec::len.

                                                  {
    return v->len;
}

unsigned long int vec_position

(

const struct vec *

vec

)

Definition at line 211 of file vec.c.

References vec::pos.

                                                    {
    return v->pos;
}

unsigned long int vec_putvbyte	(	struct vec *	vec,
		unsigned long int	n
	)

Definition at line 114 of file vec.c.

References vec::err, GROWTHFACTOR, vec::len, vec::pos, vec::size, vec_expand(), and vec::vector.

                                                                   {
    unsigned long int ret = 1;

    while (n >= 128) {
        if ((v->pos >= v->size) && !vec_expand(v, GROWTHFACTOR * v->size + 1)) {
            v->err = ENOSPC;
            return 0;
        }
        
        v->vector[v->pos++] = (char) ((n & 0x7f) | 0x80);
        n >>= 7;
        ret++;
    }

    if ((v->pos >= v->size) && !vec_expand(v, GROWTHFACTOR * v->size + 1)) {
        v->err = ENOSPC;
        return 0;
    }
    
    v->vector[v->pos++] = (char) n;
    v->len = v->pos;                 /* truncate vector */
    
    return ret;
}

Here is the call graph for this function:

struct vec* vec_read	(	int	srcfd,
		unsigned int	size
	)			[read]

Definition at line 261 of file vec.c.

References vec_read_inplace().

                                                  {
    struct vec* v;

    if ((v = malloc(sizeof(*v))) && vec_read_inplace(srcfd, v, len)) {
        return v;
    } else {
        if (v) {
            free(v);
        }
        return NULL;
    }
}

Here is the call graph for this function:

struct vec* vec_reinit	(	struct vec *	v,
		unsigned long int	initsize
	)			[read]

Definition at line 51 of file vec.c.

References vec::err, vec::len, vec::pos, vec::size, and vec::vector.

                                                                  {
    void* newmem;

    if (!v) {
        /* need to allocate a new vector */
        if ((v = malloc(sizeof(*v))) 
          && (v->vector = malloc(initsize))) {
            v->size = initsize;
            v->pos = v->len = 0;
            v->err = 0;
        } else if (v) {
            free(v);
            return NULL;
        } else {
            return NULL;
        }
    } else {
        /* reinit old one */
        if ((newmem = realloc(v->vector, initsize))) {
            v->size = initsize;
            v->vector = newmem;
            v->pos = v->len = 0;
            v->err = 0;
        } else {
            return NULL;
        }
    }

    return v;
}

void vec_reseterr

(

struct vec *

vec

)

Definition at line 92 of file vec.c.

References vec::err.

                                 {
    v->err = 0;
}

void vec_resetpos

(

struct vec *

vec

)

Definition at line 88 of file vec.c.

References vec::pos.

                                 {
    v->pos = 0;
}

unsigned long int vec_scanvbyte

(

struct vec *

vec

)

Definition at line 175 of file vec.c.

References vec::err, vec::len, vec::pos, and vec::vector.

                                               {
    unsigned long int ret = 1;

    while ((v->pos < v->len)) {
        if (!(v->vector[v->pos++] & 0x80)) { 
            return ret;
        }
        ret++;
    }

    v->err = ENOSPC;
    return 0;
}

unsigned int vec_vbyte_len

(

unsigned long int

n

)

Definition at line 301 of file vec.c.

                                                {
    unsigned int ret = 1;
    while (n >= 128) {
        n >>= 7;
        ret++;
    }
    return ret;
}

unsigned int vec_write	(	struct vec *	src,
		int	dstfd
	)

Definition at line 274 of file vec.c.

References vec::err, vec::len, vec::pos, and vec::vector.

                                                   {
    unsigned int wlen,
                 len = src->len - src->pos;
    char *srcbuf = src->vector;


    while (len && ((wlen = write(dstfd, srcbuf, len)) >= 0)) {
        len -= wlen;
        srcbuf += wlen;
    }

    if (!len) {
        return src->len - src->pos;
    } else {
        src->err = errno;
        return 0;
    }
}

---