char * octstr_putc(octstr_t *octstr, char c) { assert(octstr != NULL); buffer_putc(octstr->buf, c); return buffer_ptr(octstr->buf); }
int main() { struct buffer *a, *b; a = buffer_new(); b = buffer_new(); buffer_putc(a, 'a'); buffer_putc(a, 'g'); buffer_copy(b, a, buffer_size(a)); buffer_copy(b, a, buffer_size(a)); buffer_zero(b); printf("buf sz = %d\n", buffer_size(b)); return 0; }
char* binary_node_inspect(binary_node* binary) { buffer b; buffer_create(&b, 10); char* tmp = expression_node_inspect(binary->lhs); buffer_puts(&b, tmp); free(tmp); buffer_putc(&b, ' '); buffer_puts(&b, get_binop_str(binary->op)); buffer_putc(&b, ' '); tmp = expression_node_inspect(binary->rhs); buffer_puts(&b, tmp); free(tmp); buffer_putc(&b, '\0'); return b.buf; }
static void buffer_putn(struct buffer *b, unsigned long x, int sign, int base, int fieldlen, int padchar, int upcase) { static char lc_digits[]= "0123456789abcdef"; static char uc_digits[]= "0123456789ABCDEF"; char buf[32], *s= buf; if (sign && (long)x < 0) { *s++= '-'; x= -x; } do { unsigned long j= x % base; *s++= upcase ? uc_digits[j] : lc_digits[j]; x -= j; x /= base; } while (x); for (fieldlen -= (s - buf); fieldlen > 0; --fieldlen) buffer_putc(b, padchar); for (--s; s >= buf; --s) buffer_putc(b, *s); }
static void write_list(struct buffer *buf, const char *header, const alpm_list_t *lst) { if (lst == NULL) return; buffer_printf(buf, "%%%s%%\n", header); for (; lst; lst = lst->next) { const char *str = lst->data; buffer_printf(buf, "%s\n", str); } buffer_putc(buf, '\n'); }
static void print_strarray(buffer* b, array* a) { size_t i, n = array_length(a, sizeof(char *)); char** x = array_start(a); for(i = 0; i < n; ++i) { char* s = x[i]; if(s == 0) break; buffer_puts(b, x[i]); buffer_putc(b, '\n'); } buffer_flush(b); }
void buffer_putdata(struct buffer *b, struct data_item* d) { int len; len = d->key_len + d->value_len; if(b->NUL + len + 21 >= b->buflen)//21 is the other member of data_item:int int int int64 char = 21 _buffer_extendby(b, 1024); buffer_putint(b,len); buffer_putint(b,d->key_len); buffer_putint(b,d->value_len); buffer_putc(b,d->type); buffer_putlong(b,d->version); buffer_putnstr(b,d->key,d->key_len); buffer_putnstr(b,d->value,d->value_len); }
static void lexer_error(lexer_state* ls, const char* fmt, ...) { va_list ap; va_start(ap, fmt); // make sure buffer doesn't have any garbage buffer_putc(ls->buf, '\0'); fprintf(stderr, "Syntax error on line %d at '%s': ", ls->linenum, ls->buf->buf); vfprintf(stderr, fmt, ap); fprintf(stderr, "\n"); va_end(ap); longjmp(ls->error.buf, 1); }
void vbprintf(struct buffer *b, const char *fmt, va_list ap) { int c; int fieldlen; int padchar; while ((c= *fmt++)) { if (c != '%') { buffer_putc(b, c); continue; } if ((c= *fmt++) == '\0') goto out; if (c == '.') if ((c= *fmt++) == '\0') goto out; padchar= ' '; if (c == '0') { padchar= c; if ((c= *fmt++) == '\0') goto out; } fieldlen= 0; while (c >= '0' && c <= '9') { fieldlen= (fieldlen * 10) + (c - '0'); if ((c= *fmt++) == '\0') goto out; } for (;;) { switch (c) { case 'h': case 'j': case 'l': case 't': case 'z': if ((c= *fmt++) == '\0') goto out; break; default: goto cont; } } cont: switch (c) { case 'p': case 'x': buffer_putn(b, va_arg(ap, unsigned long), 0, 16, fieldlen, padchar, 0); break; case 'P': case 'X': buffer_putn(b, va_arg(ap, unsigned long), 0, 16, fieldlen, padchar, 1); break; case 'o': buffer_putn(b, va_arg(ap, unsigned long), 0, 8, fieldlen, padchar, 0); break; case 'd': buffer_putn(b, va_arg(ap, unsigned long), 1, 10, fieldlen, padchar, 0); break; case 'i': buffer_putn(b, va_arg(ap, unsigned long), 1, 10, fieldlen, padchar, 0); break; case 'u': buffer_putn(b, va_arg(ap, unsigned long), 0, 10, fieldlen, padchar, 0); break; case 'c': buffer_putc(b, va_arg(ap, int)); break; case 's': buffer_puts(b, va_arg(ap, char *)); break; case '%': buffer_putc(b, c); break; default: buffer_putc(b, c); buffer_putc(b, '<'); buffer_putn(b, va_arg(ap, unsigned long), 0, 16, fieldlen, padchar, 1); buffer_putc(b, '>'); break; } } out: return; }
static void buffer_puts(struct buffer *b, char *s) { while (*s) buffer_putc(b, *s++); }
static muse_cell json_read_string( muse_port_t p ) { muse_char c = port_getchar(p); assert( c == '"' ); { buffer_t *b = buffer_alloc(); while ( !port_eof(p) ) { c = port_getchar(p); if ( c == '"' ) break; else if ( c == '\\' ) { c = port_getchar(p); switch( c ) { case '"': buffer_putc( b, c ); break; case '\\': buffer_putc( b, c ); break; case '/': buffer_putc( b, c ); break; case 'b': buffer_putc( b, '\b' ); break; case 'f': buffer_putc( b, '\f' ); break; case 'n': buffer_putc( b, '\n' ); break; case 'r': buffer_putc( b, '\r' ); break; case 't': buffer_putc( b, '\t' ); break; case 'u': { muse_char d[4]; d[0] = port_getchar(p); d[1] = port_getchar(p); d[2] = port_getchar(p); d[3] = port_getchar(p); buffer_putc( b, hex2word(d) ); break; } default: muse_raise_error( p->env, muse_csymbol(p->env,L"json:invalid-escape-code"), MUSE_NIL ); buffer_putc( b, c ); break; } } else { buffer_putc( b, c ); } } { muse_cell str = buffer_to_string( b, p->env ); buffer_free(b); return str; } } }
void *_write_mmap(struct silopit *silopit, struct skipnode *x, size_t count, int need_new) { int i, j, c_clone; int fd; int sizes; int result; char file[FILE_PATH_SIZE]; struct skipnode *last; struct footer footer; struct stats stats; int fsize = sizeof(struct footer); memset(&footer, 0, fsize); _prepare_stats(x, count, &stats); sizes = stats.mmap_size; struct inner_block { char key[stats.max_len]; char offset[8]; }; struct inner_block *blks; memset(file, 0, FILE_PATH_SIZE); snprintf(file, FILE_PATH_SIZE, "%s/%s", silopit->basedir, silopit->name); fd = open(file, O_RDWR | O_CREAT | O_TRUNC, 0644); if (fd == -1) __PANIC("error creating silopit file"); if (lseek(fd, sizes - 1, SEEK_SET) == -1) __PANIC("error lseek silopit"); result = write(fd, "", 1); if (result == -1) __PANIC("error writing empty"); blks = mmap(0, sizes, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); if (blks == MAP_FAILED) { __PANIC("error mapping block when write on process"); } last = x; c_clone = count; for (i = 0, j = 0; i < c_clone; i++) { if (x->opt == ADD) { buffer_putstr(silopit->buf, x->key); buffer_putc(silopit->buf, 0); buffer_putlong(silopit->buf, x->val); j++; } else count--; last = x; x = x->forward[0]; } char *strings = buffer_detach(silopit->buf); memcpy(blks, strings, sizes); #ifdef MSYNC if (msync(blks, sizes, MS_SYNC) == -1) { __ERROR("Error Msync"); } #endif if (munmap(blks, sizes) == -1) { __ERROR("Un-mmapping the file"); } footer.count = to_be32(count); footer.crc = to_be32(F_CRC); footer.size = to_be32(sizes); footer.max_len = to_be32(stats.max_len); memcpy(footer.key, last->key, strlen(last->key)); result = write(fd, &footer, fsize); if (result == -1) __PANIC("writing the footer"); struct meta_node mn; mn.count = count; memset(mn.end, 0, SILOKATANA_MAX_KEY_SIZE); memcpy(mn.end, last->key, SILOKATANA_MAX_KEY_SIZE); memset(mn.index_name, 0, FILE_NAME_SIZE); memcpy(mn.index_name, silopit->name, FILE_NAME_SIZE); if (need_new) meta_set(silopit->meta, &mn); else meta_set_byname(silopit->meta, &mn); close(fd); return x; }
int main() { struct tm t; time_t zero = 0; struct buffer b[1]; buffer_init(b); assert(b->base == NULL); assert(b->pos == 0); assert(b->size == 0); buffer_putc(b, 'a'); assert(b->base != NULL); assert(!strncmp(b->base, "a", 1)); assert(b->pos == 1); assert(b->pos < b->size); buffer_putc(b, 'b'); assert(b->base != NULL); assert(!strncmp(b->base, "ab", 2)); assert(b->pos == 2); assert(b->pos < b->size); buffer_append(b, "12345678901234567890"); assert(b->base != NULL); assert(!strncmp(b->base, "ab12345678901234567890", 22)); assert(b->pos == 22); assert(b->pos < b->size); buffer_append_n(b, "spong", 4); assert(b->base != NULL); assert(!strncmp(b->base, "ab12345678901234567890spon", 26)); assert(b->pos == 26); assert(b->pos < b->size); buffer_printf(b, "%s", ""); assert(b->base != NULL); assert(!strncmp(b->base, "ab12345678901234567890spon", 26)); assert(b->pos == 26); assert(b->pos < b->size); buffer_printf(b, "%s", "123456"); assert(b->base != NULL); assert(!strncmp(b->base, "ab12345678901234567890spon123456", 32)); assert(b->pos == 32); assert(b->pos < b->size); b->pos -= 6; buffer_printf(b, "%s", "ABCDEFGHIJKLMNOPQRSTUVWXYZ"); assert(b->base != NULL); assert(!strncmp(b->base, "ab12345678901234567890sponABCDEFGHIJKLMNOPQRSTUVWXYZ", 52)); assert(b->pos == 52); assert(b->pos < b->size); buffer_terminate(b); assert(b->base != NULL); assert(!strcmp(b->base, "ab12345678901234567890sponABCDEFGHIJKLMNOPQRSTUVWXYZ")); assert(b->pos == 52); assert(b->pos < b->size); b->pos = 0; gmtime_r(&zero, &t); buffer_strftime(b, "", &t); assert(b->pos == 0); buffer_strftime(b, "%F %T", &t); buffer_terminate(b); assert(!strcmp(b->base, "1970-01-01 00:00:00")); free(b->base); return 0; }