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;
}
