char *getline(s_getline *buf)
{
char *string = NULL;
int i;
do
{
for (i = buf->offset; i < buf->size; i++)
{
if (buf->data[i] == '\n')
{
buf_str(&string, buf->data + buf->offset, i - buf->offset + 1);
buf->offset = i + 1;
return string;
}
}
if (buf->size - buf->offset > 0)
buf_str(&string, buf->data + buf->offset, buf->size - buf->offset);
buf->offset = 0;
buf->size = read(buf->fd, buf->data, GETLINE_BUF_SIZE);
if (buf->size < 0)
buf->size = 0;
}
while (buf->size > 0);
return string;
}
void
case_buf_lrm()
{
struct buf *buf = buf("testabcdef");
buf_lrm(buf, 4);
assert(strcmp(buf_str(buf), "abcdef") == 0);
buf_lrm(buf, 100);
assert(strcmp(buf_str(buf), "") == 0);
buf_free(buf);
}
static GLuint
glw_compile_shader(const char *path, int type, glw_root_t *gr)
{
GLint v, len;
GLuint s;
char log[4096];
buf_t *b;
if((b = fa_load(path,
FA_LOAD_VPATHS(gr->gr_vpaths),
FA_LOAD_ERRBUF(log, sizeof(log)),
NULL)) == NULL) {
TRACE(TRACE_ERROR, "glw", "Unable to load shader %s -- %s",
path, log);
return 0;
}
b = buf_make_writable(b);
char *src = buf_str(b);
s = glCreateShader(type);
glShaderSource(s, 1, (const char **)&src, NULL);
glCompileShader(s);
glGetShaderInfoLog(s, sizeof(log), &len, log);
glGetShaderiv(s, GL_COMPILE_STATUS, &v);
buf_release(b);
if(!v) {
TRACE(TRACE_ERROR, "GLW", "Unable to compile shader %s", path);
TRACE(TRACE_ERROR, "GLW", "%s", log);
return 0;
}
return s;
}
size_t decode_dict(const char *b,size_t len,const char *keylist)
{
size_t rl,dl,nl;
const char *pkey;
dl = 0;
if(2 > len || *b != 'd') return 0;
dl++; len--;
for(;len && *(b + dl) != 'e';){
rl = buf_str(b + dl,len,&pkey,&nl);
if( !rl || KEYNAME_SIZ < nl) return 0;
dl += rl;
len -= rl;
if(keylist && compare_key(pkey,nl,keylist) == 0){
pkey = next_key(keylist);
if(! *pkey ) return dl;
rl = decode_dict(b + dl,len, pkey);
if( !rl ) return 0;
return dl + rl;
}
rl = decode_rev(b + dl,len,(const char*) 0);
if( !rl ) return 0;
dl += rl;len -= rl;
}
if( !len || keylist) return 0;
return dl + 1; /* add the last char 'e' */
}
void menu_refresh(void) {
menu_t *temp;
uint8_t i;
if (currentPointer->parent) temp = (currentPointer->parent)->child;
else temp = &menu1;
for (i = 0; i != menu_index - lcd_row_pos; i++) {
temp = temp->next;
}
buf_clear();
for (i = 0; i < LCD_ROWS; i++) {
buf_locate(0, i);
if (temp == currentPointer) buf_char(62);
else buf_char(' ');
buf_locate(2, i);
buf_str(temp->name);
temp = temp->next;
if (!temp) break;
}
// lcd_refresh();
}
size_t decode_list2path(const char *b, size_t n, char *pathname, size_t maxlen)
{
const char *pb = b;
const char *s = (char *)0;
const char *endmax = pathname + maxlen - 1;
size_t r, q;
if( 'l' != *pb ) return 0;
pb++;
n--;
if( !n ) return 0;
while( n && pathname < endmax ){
if( !(r = buf_str(pb, n, &s, &q)) ) return 0;
if( q >= maxlen ) return 0;
memcpy(pathname, s, q);
pathname += q;
maxlen -= q;
pb += r;
n -= r;
if( 'e' == *pb ) break;
if( pathname >= endmax ) return 0;
*pathname++ = PATH_SP;
}
*pathname = '\0';
return (pb - b + 1);
}
void
case_buf_sprintf()
{
struct buf *buf = buf(NULL);
assert(buf_sprintf(buf, "%s %s!", "hello", "world") == BUF_OK);
assert(strcmp(buf_str(buf), "hello world!") == 0);
buf_free(buf);
}
size_t decode_query(const char *b,size_t len,const char *keylist,const char **ps,size_t *pi,int method)
{
size_t pos;
char kl[KEYNAME_LISTSIZ];
strcpy(kl,keylist);
pos = decode_rev(b, len, kl);
if( !pos ) return 0;
switch(method){
case QUERY_STR: return(buf_str(b + pos,len - pos, ps, pi));
case QUERY_INT: return(buf_int(b + pos,len - pos, 'i', 'e', pi));
case QUERY_POS:
if(pi) *pi = decode_rev(b + pos, len - pos, (const char*) 0);
return pos;
default: return 0;
}
}
static char *
read_inline_file (struct in_src *is, const char *close_tag)
{
char line[OPTION_LINE_SIZE];
struct buffer buf = alloc_buf (10000);
char *ret;
while (in_src_get (is, line, sizeof (line)))
{
if (!strncmp (line, close_tag, strlen (close_tag)))
break;
buf_printf (&buf, "%s", line);
}
ret = string_alloc (buf_str (&buf));
buf_clear (&buf);
free_buf (&buf);
CLEAR (line);
return ret;
}
size_t decode_list2path(const char *b, size_t n, char *pathname)
{
const char *pb = b;
const char *s = (char *) 0;
size_t r,q;
if( 'l' != *pb ) return 0;
pb++;
n--;
if( !n ) return 0;
for(; n;){
if(!(r = buf_str(pb, n, &s, &q)) ) return 0;
memcpy(pathname, s, q);
pathname += q;
pb += r; n -= r;
if( 'e' != *pb ){*pathname = PATH_SP, pathname++;} else break;
}
*pathname = '\0';
return (pb - b + 1);
}
static bool
check_inline_file (struct in_src *is, char *p[])
{
bool ret = false;
if (p[0] && !p[1])
{
char *arg = p[0];
if (arg[0] == '<' && arg[strlen(arg)-1] == '>')
{
struct buffer close_tag;
arg[strlen(arg)-1] = '\0';
p[0] = string_alloc (arg+1);
p[1] = string_alloc (INLINE_FILE_TAG);
close_tag = alloc_buf (strlen(p[0]) + 4);
buf_printf (&close_tag, "</%s>", p[0]);
p[2] = read_inline_file (is, buf_str (&close_tag));
p[3] = NULL;
free_buf (&close_tag);
ret = true;
}
}
return ret;
}
JSBool
js_cache_put(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
char stash[256];
const char *key,*lstash;
uint32_t len, maxage;
JSObject *o;
htsbuf_queue_t out;
js_plugin_t *jsp = JS_GetPrivate(cx, obj);
if (!JS_ConvertArguments(cx, argc, argv, "ssou",
&lstash, &key, &o, &maxage))
return JS_FALSE;
if (o == NULL) {
JS_ReportError(cx, "Not an object");
return JS_FALSE;
}
// json encode object
htsbuf_queue_init(&out, 0);
if (js_json_encode_from_object(cx, o, &out) != 0) {
JS_ReportError(cx, "Not an JSON object");
return JS_FALSE;
}
len = out.hq_size;
buf_t *b = buf_create(len + 1);
htsbuf_read(&out, b->b_ptr, len);
buf_str(b)[len] = '\0';
// put json encoded object onto cache
snprintf(stash, sizeof(stash), "plugin/%s/%s", jsp->jsp_id, lstash);
blobcache_put(key, stash, b, maxage, NULL, 0, 0);
buf_release(b);
return JS_TRUE;
}
size_t decode_str(const char *b,size_t len)
{
return (buf_str(b,len,(const char**) 0,(size_t*) 0));
}
static struct index_node_f *index_read(FILE *in, uint32_t offset)
{
struct index_node_f *node;
char *prefix;
int i, child_count = 0;
if ((offset & INDEX_NODE_MASK) == 0)
return NULL;
fseek(in, offset & INDEX_NODE_MASK, SEEK_SET);
if (offset & INDEX_NODE_PREFIX) {
struct buffer buf;
buf_init(&buf);
buf_freadchars(&buf, in);
prefix = buf_steal(&buf);
} else
prefix = NOFAIL(strdup(""));
if (offset & INDEX_NODE_CHILDS) {
char first = read_char(in);
char last = read_char(in);
child_count = last - first + 1;
node = NOFAIL(malloc(sizeof(struct index_node_f) +
sizeof(uint32_t) * child_count));
node->first = first;
node->last = last;
for (i = 0; i < child_count; i++)
node->children[i] = read_long(in);
} else {
node = NOFAIL(malloc(sizeof(struct index_node_f)));
node->first = INDEX_CHILDMAX;
node->last = 0;
}
node->values = NULL;
if (offset & INDEX_NODE_VALUES) {
int value_count;
struct buffer buf;
const char *value;
unsigned int priority;
value_count = read_long(in);
buf_init(&buf);
while (value_count--) {
priority = read_long(in);
buf_freadchars(&buf, in);
value = buf_str(&buf);
add_value(&node->values, value, buf.used, priority);
buf_clear(&buf);
}
buf_release(&buf);
}
node->prefix = prefix;
node->file = in;
return node;
}
