Main Page | Modules | Data Structures | File List | Data Fields

buf.c

00001 /* 
00002  * Copyright (c) 2005, 2006 by KoanLogic s.r.l. - All rights reserved.  
00003  */
00004 
00005 static const char rcsid[] =
00006     "$Id: buf.c,v 1.1 2006/05/28 15:39:43 tat Exp $";
00007 
00008 #include <sys/types.h>
00009 #include <sys/stat.h>
00010 #include <unistd.h>
00011 #include <u/libu.h>
00012 #include <u/buf.h>
00013 
00014 struct u_buf_s
00015 {
00016     char *data;
00017     size_t size, len;
00018 };
00019 
00035 int u_buf_reserve(u_buf_t *ubuf, size_t size)
00036 {
00037     char *nbuf;
00038 
00039     dbg_err_if(ubuf == NULL);
00040 
00041     if(size <= ubuf->size)
00042         return 0; /* nothing to do */
00043    
00044     /* size plus 1 char to store a '\0' */
00045     nbuf = u_realloc(ubuf->data, size+1);
00046     dbg_err_if(nbuf == NULL);
00047 
00048     /* buffer data will always be zero-terminated (but the len field will not
00049      * count the last '\0') */
00050     nbuf[size] = 0;
00051 
00052     ubuf->data = (void*)nbuf;
00053     ubuf->size = size;
00054 
00055     return 0;
00056 err:
00057     return ~0;
00058 }
00059 
00072 int u_buf_append(u_buf_t *ubuf, void *data, size_t size)
00073 {
00074     dbg_err_if(ubuf == NULL);
00075     dbg_err_if(data == NULL);
00076     dbg_err_if(size == 0);
00077 
00078     if(ubuf->size - ubuf->len < size)
00079     {   /* buffer too small, need to resize */
00080         dbg_err_if(u_buf_reserve(ubuf, ubuf->size + ubuf->len + 2*size));
00081     }
00082    
00083     memcpy(ubuf->data + ubuf->len, data, size);
00084     ubuf->len += size;
00085 
00086     /* zero term the buffer so it can be used (when applicable) as a string */
00087     ubuf->data[ubuf->len] = 0;
00088 
00089     return 0;
00090 err:
00091     return ~0;
00092 }
00093 
00104 int u_buf_load(u_buf_t *ubuf, char *filename)
00105 {
00106     enum { BUFSZ = 4096 };
00107     struct stat st;
00108     char buf[BUFSZ];
00109     FILE *fp = NULL;
00110 
00111     dbg_err_if(ubuf == NULL);
00112     dbg_err_if(filename == NULL);
00113 
00114     dbg_err_if(stat(filename, &st));
00115 
00116     /* clear the current data */
00117     dbg_err_if(u_buf_clear(ubuf));
00118 
00119     /* be sure to have a big enough buffer */
00120     dbg_err_if(u_buf_reserve(ubuf, st.st_size));
00121 
00122     warn_err_sif((fp = fopen(filename, "r")) == NULL);
00123 
00124     /* fill the buffer with the whole file content */
00125     dbg_err_if(fread(ubuf->data, st.st_size, 1, fp) == 0);
00126     ubuf->len = st.st_size;
00127 
00128     fclose(fp);
00129 
00130     return 0;
00131 err:
00132     if(fp)
00133         fclose(fp);
00134     return ~0;
00135 }
00136 
00151 int u_buf_detach(u_buf_t *ubuf)
00152 {
00153     dbg_err_if(ubuf == NULL);
00154 
00155     ubuf->data = NULL;
00156     ubuf->size = 0;
00157     ubuf->len = 0;
00158 
00159     return 0;
00160 err:
00161     return ~0;
00162 }
00163 
00173 size_t u_buf_size(u_buf_t *ubuf)
00174 {
00175     dbg_err_if(ubuf == NULL);
00176 
00177     return ubuf->size;
00178 err:
00179     return 0;
00180 }
00181 
00191 size_t u_buf_len(u_buf_t *ubuf)
00192 {
00193     dbg_err_if(ubuf == NULL);
00194 
00195     return ubuf->len;
00196 err:
00197     return 0;
00198 }
00199 
00210 int u_buf_clear(u_buf_t *ubuf)
00211 {
00212     dbg_err_if(ubuf == NULL);
00213     
00214     ubuf->len = 0;
00215 
00216     return 0;
00217 err:
00218     return ~0;
00219 }
00220 
00233 int u_buf_set(u_buf_t *ubuf, void *data, size_t size)
00234 {
00235     dbg_err_if(ubuf == NULL);
00236     dbg_err_if(data == NULL);
00237     dbg_err_if(size == 0);
00238 
00239     dbg_err_if(u_buf_clear(ubuf));
00240 
00241     dbg_err_if(u_buf_append(ubuf, data, size));
00242 
00243     return 0;
00244 err:
00245     return ~0;
00246 }
00247 
00257 void* u_buf_ptr(u_buf_t *ubuf)
00258 {
00259     dbg_err_if(ubuf == NULL);
00260     
00261     return ubuf->data;
00262 err:
00263     return NULL;
00264 }
00265 
00275 int u_buf_free(u_buf_t *ubuf)
00276 {
00277     dbg_err_if(ubuf == NULL);
00278 
00279     if(ubuf->data)
00280         u_free(ubuf->data);
00281 
00282     return 0;
00283 err:
00284     return ~0;
00285 }
00286 
00296 int u_buf_create(u_buf_t **pubuf)
00297 {
00298     u_buf_t *ubuf = NULL;
00299 
00300     dbg_err_if(pubuf == NULL);
00301 
00302     ubuf = (u_buf_t*)u_zalloc(sizeof(u_buf_t));
00303     dbg_err_if(ubuf == NULL);
00304 
00305     *pubuf = ubuf;
00306 
00307     return 0;
00308 err:
00309     return ~0;
00310 }
00311 

←Products
© 2005-2006 - KoanLogic S.r.l. - All rights reserved