/* binary_search():
An array of data structures is in memory, as above. However, the
structs must be stored in forward order of their keys (taking each key
to be a multibyte unsigned integer.) There can be no duplicate keys.
numstructs must indicate the exact length of the array; it cannot
be -1.
The KeyIndirect and ReturnIndex options may be used.
*/
glui32 binary_search(glui32 key, glui32 keysize,
glui32 start, glui32 structsize, glui32 numstructs,
glui32 keyoffset, glui32 options)
{
unsigned char keybuf[4];
unsigned char byte, byte2;
glui32 top, bot, val, addr;
int ix;
int retindex = ((options & serop_ReturnIndex) != 0);
fetchkey(keybuf, key, keysize, options);
bot = 0;
top = numstructs;
while (bot < top) {
int cmp = 0;
val = (top+bot) / 2;
addr = start + val * structsize;
if (keysize <= 4) {
for (ix=0; (!cmp) && ix<keysize; ix++) {
byte = Mem1(addr + keyoffset + ix);
byte2 = keybuf[ix];
if (byte < byte2)
cmp = -1;
else if (byte > byte2)
cmp = 1;
}
}
else {
for (ix=0; (!cmp) && ix<keysize; ix++) {
byte = Mem1(addr + keyoffset + ix);
byte2 = Mem1(key + ix);
if (byte < byte2)
cmp = -1;
else if (byte > byte2)
cmp = 1;
}
}
if (!cmp) {
if (retindex)
return val;
else
return addr;
}
if (cmp < 0) {
bot = val+1;
}
else {
top = val;
}
}
if (retindex)
return -1;
else
return 0;
}
void interface(int interactive) {
if(interactive) {
int key, result;
char customkey[8] = { 0 }, * marked = NULL;
canon(0);
fflush(stderr);
if((key = fetchkey(1000000)) == -1)
return;
if(key == 27) {
int ch;
while((ch = fetchkey(100000)) != -1 && !strchr("ABCDEFGHMPQRSZojmk~", ch));
return;
}
switch(key) {
case 'l':
puts(rate("L") ? "Loved." : "Sorry, failed.");
break;
case 'U':
puts(rate("U") ? "Unloved." : "Sorry, failed.");
break;
case 'B':
puts(rate("B") ? "Banned." : "Sorry, failed.");
kill(playfork, SIGUSR1);
break;
case 'n':
rate("S");
break;
case 'Q':
unlink(rcpath("session"));
exit(EXIT_SUCCESS);
case 'i':
if(playfork) {
const char * path = rcpath("i-template");
if(path && !access(path, R_OK)) {
char ** template = slurp(path);
if(template != NULL) {
/* linear_search():
An array of data structures is stored in memory, beginning at start,
each structure being structsize bytes. Within each struct, there is
a key value keysize bytes long, starting at position keyoffset (from
the start of the structure.) Search through these in order. If one
is found whose key matches, return it. If numstructs are searched
with no result, return NULL.
numstructs may be -1 (0xFFFFFFFF) to indicate no upper limit to the
number of structures to search. The search will continue until a match
is found, or (if ZeroKeyTerminates is set) a zero key.
The KeyIndirect, ZeroKeyTerminates, and ReturnIndex options may be
used.
*/
glui32 linear_search(glui32 key, glui32 keysize,
glui32 start, glui32 structsize, glui32 numstructs,
glui32 keyoffset, glui32 options)
{
unsigned char keybuf[4];
glui32 count;
int ix;
int retindex = ((options & serop_ReturnIndex) != 0);
int zeroterm = ((options & serop_ZeroKeyTerminates) != 0);
fetchkey(keybuf, key, keysize, options);
for (count=0; count<numstructs; count++, start+=structsize) {
int match = TRUE;
if (keysize <= 4) {
for (ix=0; match && ix<keysize; ix++) {
if (Mem1(start + keyoffset + ix) != keybuf[ix])
match = FALSE;
}
}
else {
for (ix=0; match && ix<keysize; ix++) {
if (Mem1(start + keyoffset + ix) != Mem1(key + ix))
match = FALSE;
}
}
if (match) {
if (retindex)
return count;
else
return start;
}
if (zeroterm) {
match = TRUE;
for (ix=0; match && ix<keysize; ix++) {
if (Mem1(start + keyoffset + ix) != 0)
match = FALSE;
}
if (match) {
break;
}
}
}
if (retindex)
return -1;
else
return 0;
}
/* linked_search():
The structures may be anywhere in memory, in any order. They are
linked by a four-byte address field, which is found in each struct
at position nextoffset. If this field contains zero, it indicates
the end of the linked list.
The KeyIndirect and ZeroKeyTerminates options may be used.
*/
glui32 linked_search(glui32 key, glui32 keysize,
glui32 start, glui32 keyoffset, glui32 nextoffset, glui32 options)
{
unsigned char keybuf[4];
int ix;
glui32 val;
int zeroterm = ((options & serop_ZeroKeyTerminates) != 0);
fetchkey(keybuf, key, keysize, options);
while (start != 0) {
int match = TRUE;
if (keysize <= 4) {
for (ix=0; match && ix<keysize; ix++) {
if (Mem1(start + keyoffset + ix) != keybuf[ix])
match = FALSE;
}
}
else {
for (ix=0; match && ix<keysize; ix++) {
if (Mem1(start + keyoffset + ix) != Mem1(key + ix))
match = FALSE;
}
}
if (match) {
return start;
}
if (zeroterm) {
match = TRUE;
for (ix=0; match && ix<keysize; ix++) {
if (Mem1(start + keyoffset + ix) != 0)
match = FALSE;
}
if (match) {
break;
}
}
val = start + nextoffset;
start = Mem4(val);
}
return 0;
}
void tag(struct hash data) {
char key, * tagstring;
struct prompt setup = {
.prompt = "Tags (comma separated): ",
.line = NULL,
.history = NULL,
.callback = tagcomplete,
};
if(!data.content)
return;
fputs("Tag (a)rtist, a(l)bum, (t)rack or (c)ancel?\n", stderr);
while(!strchr("altc", (key = fetchkey(2))));
if(key == 'c')
return;
popular = merge(toptags(key, data), usertags(value(& rc, "username")), 0);
setup.line = oldtags(key, data);
assert((tagstring = strdup(readline(& setup))) != NULL);
if(setup.line) {
free(setup.line);
setup.line = NULL;
}
purge(popular);
popular = NULL;
sendtag(key, tagstring, data);
free(tagstring);
}
char * oldtags(char key, struct hash track) {
unsigned length, x;
char * tags = NULL, * url = calloc(512, sizeof(char)),
* user = NULL, * artist = NULL, * arg = NULL,
* file = NULL, ** resp;
assert(url != NULL);
switch(key) {
case 'a':
file = "artisttags.xml";
break;
case 'l':
file = "albumtags.xml";
break;
case 't':
default:
file = "tracktags.xml";
}
encode(value(& track, "creator"), & artist);
stripslashes(artist);
encode(value(& rc, "username"), & user);
length = snprintf(
url, 512, "http://ws.audioscrobbler.com/1.0/user/%s/%s?artist=%s",
user, file, artist);
free(user);
free(artist);
if(key == 'l') {
encode(value(& track, "album"), & arg);
stripslashes(arg);
length += snprintf(url + length, 512 - length, "&album=%s", arg);
} else if(key == 't') {
encode(value(& track, "title"), & arg);
stripslashes(arg);
length += snprintf(url + length, 512 - length, "&track=%s", arg);
}
if(arg)
free(arg);
resp = fetch(url, NULL, NULL, NULL);
free(url);
if(!resp)
return NULL;
for(x = 0, length = 0; resp[x]; ++x) {
char * pbeg = strstr(resp[x], "<name>"), * pend;
if(pbeg) {
pbeg += 6;
pend = strstr(pbeg, "</name>");
if(pend) {
char * thistag = strndup(pbeg, pend - pbeg);
unsigned nlength = strlen(thistag) + length;
assert(thistag != NULL);
if(length)
++nlength;
tags = realloc(tags, nlength + 1);
assert(tags != NULL);
sprintf(tags + length, "%s%s", length ? "," : "", thistag);
free(thistag);
length = nlength;
}
}
}
purge(resp);
return tags;
}
