void *malloc(size_t size)
{
t_mdata last;
t_mdata mem_node;
size_t aligned_size;
last = NULL;
aligned_size = ROUND4(size);
if (!g_beg)
{
if (!(mem_node = get_more_heap(NULL, aligned_size)))
return (NULL);
g_beg = mem_node;
}
else
{
last = g_beg;
if (!(mem_node = find_space(&last, aligned_size)))
{
if (!(mem_node = get_more_heap(last, aligned_size)))
return (NULL);
}
else
node_resizing(mem_node, aligned_size);
}
return (size <= 0 ? NULL : mem_node->d_beg);
}
char *
iks_stack_strcat (ikstack *s, char *old, size_t old_len, const char *src, size_t src_len)
{
char *ret;
ikschunk *c;
if (!old) {
return iks_stack_strdup (s, src, src_len);
}
if (0 == old_len) old_len = strlen (old);
if (0 == src_len) src_len = strlen (src);
for (c = s->data; c; c = c->next) {
if (c->data + c->last == old) break;
}
if (!c) {
c = find_space (s, s->data, old_len + src_len + 1);
if (!c) return NULL;
ret = c->data + c->used;
c->last = c->used;
c->used += old_len + src_len + 1;
memcpy (ret, old, old_len);
memcpy (ret + old_len, src, src_len);
ret[old_len + src_len] = '\0';
return ret;
}
if (c->size - c->used > src_len) {
ret = c->data + c->last;
memcpy (ret + old_len, src, src_len);
c->used += src_len;
ret[old_len + src_len] = '\0';
} else {
/* FIXME: decrease c->used before moving string to new place */
c = find_space (s, s->data, old_len + src_len + 1);
if (!c) return NULL;
c->last = c->used;
ret = c->data + c->used;
memcpy (ret, old, old_len);
c->used += old_len;
memcpy (c->data + c->used, src, src_len);
c->used += src_len;
c->data[c->used] = '\0';
c->used++;
}
return ret;
}
void *
iks_stack_alloc (ikstack *s, size_t size)
{
ikschunk *c;
void *mem;
if (size < MIN_ALLOC_SIZE) size = MIN_ALLOC_SIZE;
if (size & ALIGN_MASK) size = ALIGN (size);
c = find_space (s, s->meta, size);
if (!c) return NULL;
mem = c->data + c->used;
c->used += size;
return mem;
}
char *
iks_stack_strdup (ikstack *s, const char *src, size_t len)
{
ikschunk *c;
char *dest;
if (!src) return NULL;
if (0 == len) len = strlen (src);
c = find_space (s, s->data, len + 1);
if (!c) return NULL;
dest = c->data + c->used;
c->last = c->used;
c->used += len + 1;
memcpy (dest, src, len);
dest[len] = '\0';
return dest;
}
const struct dfont_rect *
dfont_insert(struct dfont *df, int c, int font, int width, int height) {
if (width > df->width)
return NULL;
assert(dfont_lookup(df,c,font) == NULL);
for (;;) {
struct font_line *line = find_line(df, width, height);
if (line == NULL)
break;
struct hash_rect * hr = find_space(df, line, width);
if (hr) {
return insert_char(df,c,font,hr);
}
}
struct hash_rect * hr = release_space(df, width, height);
if (hr) {
return insert_char(df,c,font,hr);
}
return NULL;
}
static bool handle_first_line( p_data_ctx dctx )
{
char *space, *s = ( char * )dctx->buffer;
if ( !check_first_line( s ) )
return false;
if ( *s == '>' ) s++;
space = find_space( s );
if ( space == NULL ) {
space = s + strlen(s);
} else {
*space = 0;
}
if ( !dctx->quiet )
KOutMsg( "SEQ_ID: %s\n", s );
write_default_str( s, ewrefseq_cn_SEQ_ID, dctx->wr );
space++;
if ( !dctx->quiet )
KOutMsg( "DEF_LINE: %s\n", space );
write_default_str( space, ewrefseq_cn_DEF_LINE, dctx->wr );
return true;
}
char * rev_line_rev_alt_word(char *input,int len)
{
int i=0,j=0,flag=1;
input=rev_line(input,0,len-1);
find_non_space(input,&i);
while(input[i]!=NULL)
{
j=i;
find_space(input,&j);
if(flag==1)
{
flag=0;
}
else
{
input=rev_line(input,i,j);
flag=1;
}
i=j+1;
find_non_space(input,&i);
}
return input;
}
void move_list(t_win *win, t_ios *term, int x, int y)
{
char *buf;
int select;
t_wsize ws;
int resize;
if (tcsetattr(0, TCSADRAIN, term) == -1)
leave_term();
buf = ft_memalloc(5);
win->stop = 0;
read(0, buf, 3);
resize = reset_val(term, &ws, 0);
if (resize != 0)
{
y = win->position / win->max_y;
x = win->position % win->max_y;
check_move(buf, &y, &x, win);
select = check_buf(buf, win, win->position, term);
get_position(win, select, &x, &y);
print_arg(&(win->arg), win, win->position, find_space(win->arg));
}
free(buf);
}
void parse_kkdcp_string(char *str, int *socktype, char **_port, char **_server, char **_path, char **_realm)
{
char *path, *server, *port, *realm, *p;
path = str;
realm = find_space(path);
if (realm == NULL) {
fprintf(stderr, "Cannot parse kkdcp string: %s\n", path);
exit(1);
}
*realm = 0;
realm++;
while (c_isspace(*realm))
realm++;
server = find_space(realm);
if (server == NULL) {
fprintf(stderr, "Cannot parse kkdcp string: %s\n", realm);
exit(1);
}
/* null terminate the realm */
*server = 0;
server++;
while (c_isspace(*server))
server++;
if (strncmp(server, "udp@", 4) == 0) {
*socktype = SOCK_DGRAM;
} else if (strncmp(server, "tcp@", 4) == 0) {
*socktype = SOCK_STREAM;
} else {
fprintf(stderr, "cannot handle protocol %s\n", server);
exit(1);
}
server += 4;
p = strchr(server, ']');
if (p == NULL) { /* IPv4 address or server.name:port */
port = strchr(server, ':');
} else { /* [::IPV6address]:PORT */
port = strchr(p, ':');
if (port) {
*p = 0;
p = strchr(server, '[');
if (p)
server = p+1;
}
}
if (port == NULL) {
fprintf(stderr, "No server port specified in: %s\n", server);
exit(1);
}
*port = 0;
port++;
*_port = port;
*_realm = realm;
*_path = path;
*_server = server;
return;
}
