/*
* main:
* Drive the sucker. There are two main modes -- either we store
* the seek pointers, if the table is to be sorted or randomized,
* or we write the pointer directly to the file, if we are to stay
* in file order. If the former, we allocate and re-allocate in
* CHUNKSIZE blocks; if the latter, we just write each pointer,
* and then seek back to the beginning to write in the table.
*/
int
main(int ac, char *av[])
{
char *sp, *nsp, dc;
FILE *inf, *outf;
off_t last_off, pos, *p;
size_t length;
int first;
uint32_t cnt;
STR *fp;
static char string[257];
setlocale(LC_ALL, "");
getargs(ac, av); /* evalute arguments */
dc = Delimch;
if ((inf = fopen(Infile, "r")) == NULL) {
perror(Infile);
exit(1);
}
if ((outf = fopen(Outfile, "w")) == NULL) {
perror(Outfile);
exit(1);
}
if (!STORING_PTRS)
fseek(outf, (long)sizeof(Tbl), SEEK_SET);
/*
* Write the strings onto the file
*/
Tbl.str_longlen = 0;
Tbl.str_shortlen = 0xffffffff;
Tbl.str_delim = dc;
Tbl.str_version = VERSION;
first = Oflag;
add_offset(outf, ftello(inf));
last_off = 0;
do {
sp = fgets(string, 256, inf);
if (sp == NULL || (sp[0] == dc && sp[1] == '\n')) {
pos = ftello(inf);
length = (size_t)(pos - last_off) -
(sp != NULL ? strlen(sp) : 0);
last_off = pos;
if (length == 0)
continue;
add_offset(outf, pos);
if ((size_t)Tbl.str_longlen < length)
Tbl.str_longlen = length;
if ((size_t)Tbl.str_shortlen > length)
Tbl.str_shortlen = length;
first = Oflag;
}
else if (first) {
for (nsp = sp; !isalnum((unsigned char)*nsp); nsp++)
continue;
ALLOC(Firstch, Num_pts);
fp = &Firstch[Num_pts - 1];
if (Iflag && isupper((unsigned char)*nsp))
fp->first = tolower((unsigned char)*nsp);
else
fp->first = *nsp;
fp->pos = Seekpts[Num_pts - 1];
first = false;
}
} while (sp != NULL);
/*
* write the tables in
*/
fclose(inf);
Tbl.str_numstr = Num_pts - 1;
if (Cflag)
Tbl.str_flags |= STR_COMMENTS;
if (Oflag)
do_order();
else if (Rflag)
randomize();
if (Xflag)
Tbl.str_flags |= STR_ROTATED;
if (!Sflag) {
printf("\"%s\" created\n", Outfile);
if (Num_pts == 2)
puts("There was 1 string");
else
printf("There were %u strings\n", Num_pts - 1);
printf("Longest string: %u byte%s\n", Tbl.str_longlen,
Tbl.str_longlen == 1 ? "" : "s");
printf("Shortest string: %u byte%s\n", Tbl.str_shortlen,
Tbl.str_shortlen == 1 ? "" : "s");
}
rewind(outf);
Tbl.str_version = htobe32(Tbl.str_version);
Tbl.str_numstr = htobe32(Tbl.str_numstr);
Tbl.str_longlen = htobe32(Tbl.str_longlen);
Tbl.str_shortlen = htobe32(Tbl.str_shortlen);
Tbl.str_flags = htobe32(Tbl.str_flags);
fwrite((char *)&Tbl, sizeof(Tbl), 1, outf);
if (STORING_PTRS) {
for (p = Seekpts, cnt = Num_pts; cnt--; ++p)
*p = htobe64(*p);
fwrite(Seekpts, sizeof(*Seekpts), (size_t)Num_pts, outf);
}
fclose(outf);
exit(0);
}
static unsigned int vlog_reply(struct httpd_request *request, void *data)
{
struct vlog_priv_t *vlog;
int ret;
char *limit = NULL;
char *p;
char *tag = NULL;
char *itag = NULL;
struct agent_core_t *core = data;
GET_PRIV(data,vlog);
p = next_slash(request->url + 1);
assert(vlog->tag==NULL);
assert(vlog->answer == NULL);
if (p) {
limit = strdup(p);
assert(limit);
char *tmp2 = index(limit,'/');
if (tmp2 && *tmp2) *tmp2 = '\0';
if(!(atoi(limit) > 0)) {
free(limit);
send_response_fail(request->connection,"Not a number");
return 0;
}
p = next_slash(p);
}
if (p) {
tag = strdup(p);
char *tmp2 = index(tag,'/');
if (tmp2 && *tmp2) *tmp2 = '\0';
p = next_slash(p);
}
if (p) {
itag = strdup(p);
char *tmp2 = index(itag,'/');
if (tmp2 && *tmp2) *tmp2 = '\0';
p = next_slash(p);
}
vlog->answer = VSB_new_auto();
assert(vlog->answer != NULL);
vlog->vd = VSM_New();
assert(VSL_Arg(vlog->vd, 'n', core->config->n_arg));
VSL_Setup(vlog->vd);
VSL_Arg(vlog->vd, 'd', "");
if (tag) {
VSL_Arg(vlog->vd, 'i', tag);
if (itag)
VSL_Arg(vlog->vd,'I',itag);
} else {
VSL_Arg(vlog->vd, 'k', limit ? limit : "10");
}
if (limit)
free(limit);
VSB_printf(vlog->answer, "{ \"log\": [");
ret = VSL_Open(vlog->vd, 1);
assert(!ret);
if (tag == NULL) {
do_order(vlog);
} else {
do_unorder(vlog);
}
if (tag)
free(tag);
if (itag)
free(itag);
VSB_printf(vlog->answer, "\n] }\n");
assert(VSB_finish(vlog->answer) == 0);
if (VSB_len(vlog->answer) > 1) {
send_response(request->connection, 200, VSB_data(vlog->answer), VSB_len(vlog->answer));
} else {
send_response_fail(request->connection, "FAIL");
}
VSB_clear(vlog->answer);
VSM_Close(vlog->vd);
vlog->answer = NULL;
vlog->entries = 0;
return 0;
}
/*
* main:
* Drive the sucker. There are two main modes -- either we store
* the seek pointers, if the table is to be sorted or randomized,
* or we write the pointer directly to the file, if we are to stay
* in file order. If the former, we allocate and re-allocate in
* CHUNKSIZE blocks; if the latter, we just write each pointer,
* and then seek back to the beginning to write in the table.
*/
int
main(int ac, char *av[])
{
char *sp, dc;
FILE *inf, *outf;
int32_t last_off, length, pos;
int32_t *p;
int first, cnt;
char *nsp;
STR *fp;
static char string[257];
getargs(ac, av); /* evalute arguments */
dc = Delimch;
if ((inf = fopen(Infile, "r")) == NULL)
err(1, "%s", Infile);
if ((outf = fopen(Outfile, "w")) == NULL)
err(1, "%s", Outfile);
if (!STORING_PTRS)
(void) fseek(outf, sizeof Tbl, SEEK_SET);
/*
* Write the strings onto the file
*/
Tbl.str_longlen = 0;
Tbl.str_shortlen = (unsigned int) 0xffffffff;
Tbl.str_delim = dc;
Tbl.str_version = VERSION;
first = Oflag;
add_offset(outf, ftell(inf));
last_off = 0;
do {
sp = fgets(string, sizeof(string), inf);
if (sp == NULL || (sp[0] == dc && sp[1] == '\n')) {
pos = ftell(inf);
length = pos - last_off - (sp ? strlen(sp) : 0);
last_off = pos;
if (!length)
continue;
add_offset(outf, pos);
if (Tbl.str_longlen < (u_int32_t)length)
Tbl.str_longlen = length;
if (Tbl.str_shortlen > (u_int32_t)length)
Tbl.str_shortlen = length;
first = Oflag;
}
else if (first) {
for (nsp = sp; !isalnum(*nsp); nsp++)
continue;
ALLOC(Firstch, Num_pts);
fp = &Firstch[Num_pts - 1];
if (Iflag && isupper(*nsp))
fp->first = tolower(*nsp);
else
fp->first = *nsp;
fp->pos = Seekpts[Num_pts - 1];
first = FALSE;
}
} while (sp != NULL);
/*
* write the tables in
*/
(void) fclose(inf);
Tbl.str_numstr = Num_pts - 1;
if (Tbl.str_numstr == 0)
Tbl.str_shortlen = 0;
if (Oflag)
do_order();
else if (Rflag)
randomize();
if (Xflag)
Tbl.str_flags |= STR_ROTATED;
if (!Sflag) {
printf("\"%s\" created\n", Outfile);
if (Tbl.str_numstr == 1)
puts("There was 1 string");
else
printf("There were %u strings\n", Tbl.str_numstr);
printf("Longest string: %lu byte%s\n",
(unsigned long) Tbl.str_longlen,
Tbl.str_longlen == 1 ? "" : "s");
printf("Shortest string: %lu byte%s\n",
(unsigned long) Tbl.str_shortlen,
Tbl.str_shortlen == 1 ? "" : "s");
}
(void) fseek(outf, 0, SEEK_SET);
Tbl.str_version = htonl(Tbl.str_version);
Tbl.str_numstr = htonl(Tbl.str_numstr);
Tbl.str_longlen = htonl(Tbl.str_longlen);
Tbl.str_shortlen = htonl(Tbl.str_shortlen);
Tbl.str_flags = htonl(Tbl.str_flags);
(void) fwrite(&Tbl.str_version, sizeof(Tbl.str_version), 1, outf);
(void) fwrite(&Tbl.str_numstr, sizeof(Tbl.str_numstr), 1, outf);
(void) fwrite(&Tbl.str_longlen, sizeof(Tbl.str_longlen), 1, outf);
(void) fwrite(&Tbl.str_shortlen, sizeof(Tbl.str_shortlen), 1, outf);
(void) fwrite(&Tbl.str_flags, sizeof(Tbl.str_flags), 1, outf);
(void) fwrite( Tbl.stuff, sizeof(Tbl.stuff), 1, outf);
if (STORING_PTRS)
for (p = Seekpts, cnt = Num_pts; cnt--; ++p) {
*p = htonl(*p);
(void) fwrite(p, sizeof(*p), 1, outf);
}
if (fclose(outf))
err(1, "fclose `%s'", Outfile);
exit(0);
}
/*
* main:
* Drive the sucker. There are two main modes -- either we store
* the seek pointers, if the table is to be sorted or randomized,
* or we write the pointer directly to the file, if we are to stay
* in file order. If the former, we allocate and re-allocate in
* CHUNKSIZE blocks; if the latter, we just write each pointer,
* and then seek back to the beginning to write in the table.
*/
int main(int ac, char **av)
{
register unsigned char *sp;
register FILE *inf, *outf;
register int32_t last_off, length, pos, *p;
register int first, cnt;
register char *nsp;
register STR *fp;
static char string[257];
getargs(ac, av); /* evalute arguments */
if ((inf = fopen(Infile, "r")) == NULL)
{
perror(Infile);
exit(1);
}
if ((outf = fopen(Outfile, "w")) == NULL)
{
perror(Outfile);
exit(1);
}
if (!STORING_PTRS)
(void) fseek(outf, sizeof Tbl, 0);
/*
* Write the strings onto the file
*/
Tbl.str_longlen = 0;
Tbl.str_shortlen = (unsigned int) 0xffffffff;
Tbl.str_delim = Delimch;
Tbl.str_version = VERSION;
first = Oflag;
add_offset(outf, ftell(inf));
last_off = 0;
do
{
sp = (unsigned char*)fgets(string, 256, inf);
if (sp == NULL || STR_ENDSTRING(sp, Tbl))
{
pos = ftell(inf);
length = pos - last_off - (sp ? strlen((const char*)sp) : 0);
if (!length)
/* Here's where we go back and fix things, if the
* 'fortune' just read was the null string.
* We had to make the assignment of last_off slightly
* redundant to achieve this.
*/
{
if (pos - last_off == 2)
fix_last_offset(outf, pos);
last_off = pos;
continue;
}
last_off = pos;
add_offset(outf, pos);
if (Tbl.str_longlen < length)
Tbl.str_longlen = length;
if (Tbl.str_shortlen > length)
Tbl.str_shortlen = length;
first = Oflag;
}
else if (first)
{
for (nsp = (char*)sp; !isalnum(*nsp); nsp++)
continue;
ALLOC(Firstch, Num_pts);
fp = &Firstch[Num_pts - 1];
if (Iflag && isupper(*nsp))
fp->first = tolower(*nsp);
else
fp->first = *nsp;
fp->pos = Seekpts[Num_pts - 1];
first = FALSE;
}
}
while (sp != NULL);
/*
* write the tables in
*/
fclose(inf);
if (Oflag)
do_order();
else if (Rflag)
randomize();
if (Xflag)
Tbl.str_flags |= STR_ROTATED;
if (!Sflag)
{
printf("\"%s\" created\n", Outfile);
if (Num_pts == 1)
puts("There was no string");
else
{
if (Num_pts == 2)
puts("There was 1 string");
else
printf("There were %ld strings\n", Num_pts - 1);
printf("Longest string: %u byte%s\n", Tbl.str_longlen,
Tbl.str_longlen == 1 ? "" : "s");
printf("Shortest string: %u byte%s\n", Tbl.str_shortlen,
Tbl.str_shortlen == 1 ? "" : "s");
}
}
fseek(outf, (off_t) 0, 0);
Tbl.str_version = htonl(Tbl.str_version);
Tbl.str_numstr = htonl(Num_pts - 1);
/* Look, Ma! After using the variable three times, let's store
* something in it!
*/
Tbl.str_longlen = htonl(Tbl.str_longlen);
Tbl.str_shortlen = htonl(Tbl.str_shortlen);
Tbl.str_flags = htonl(Tbl.str_flags);
fwrite(&Tbl.str_version, sizeof Tbl.str_version, 1, outf);
fwrite(&Tbl.str_numstr, sizeof Tbl.str_numstr, 1, outf);
fwrite(&Tbl.str_longlen, sizeof Tbl.str_longlen, 1, outf);
fwrite(&Tbl.str_shortlen, sizeof Tbl.str_shortlen, 1, outf);
fwrite(&Tbl.str_flags, sizeof Tbl.str_flags, 1, outf);
fwrite( Tbl.stuff, sizeof Tbl.stuff, 1, outf);
if (STORING_PTRS)
{
for (p = Seekpts, cnt = Num_pts; cnt--; ++p)
{
*p = htonl(*p);
fwrite(p, sizeof *p, 1, outf);
}
}
fclose(outf);
exit(0);
}
int do_file_sorting(dataptr dz)
{
int exit_status;
int n;
int a_srate = 0;
double sum;
int infilecnt = dz->all_words-1;
int fileno = 0, namestoresize = 0;
char *filename = dz->wordstor[infilecnt]; /* name of input list file */
char *monofile=NULL, *stereofile = NULL, *analfile = NULL, *quadfile = NULL;
char *pitchfile = NULL, *transfile = NULL, *formantfile = NULL;
char *envfile = NULL, *otherfile = NULL, *namestore = NULL;
int *posstore = NULL;
int *lcnt = NULL;
char ***lstore = NULL;
double *lenstore = NULL;
double *sortlens = NULL;
char *file48 = ENDOFSTR, *file44 = ENDOFSTR, *file32 = ENDOFSTR;
char *file24 = ENDOFSTR, *file22 = ENDOFSTR, *file16 = ENDOFSTR;
int is_file48=FALSE, is_file44=FALSE, is_file32=FALSE, is_file24=FALSE, is_file22=FALSE, is_file16=FALSE;
int is_mono_list=FALSE, is_stereo_list=FALSE,is_quad_list=FALSE, is_anal_list=FALSE,is_pitch_list=FALSE;
int is_trans_list=FALSE, is_fmnt_list=FALSE, is_env_list=FALSE, is_other_list=FALSE;
FILE *fp48 = NULL, *fp44 = NULL, *fp32 = NULL, *fp24 = NULL, *fp22 = NULL, *fp16 = NULL,
*fpm = NULL, *fps = NULL, *fpa = NULL, *fpp = NULL, *fpt = NULL, *fpf = NULL, *fpe = NULL, *fpo = NULL, *fpq = NULL;
char *p;
int done_errmsg = 0;
switch(dz->mode) {
case(BY_DURATION):
case(BY_LOG_DUR):
if((lcnt = (int *)malloc((dz->iparam[SORT_LENCNT]+1) * sizeof(int)))==NULL) {
sprintf(errstr,"INSUFFICIENT MEMORY for lcnt store.\n");
return(MEMORY_ERROR);
}
if((sortlens = (double *)malloc(dz->iparam[SORT_LENCNT] * sizeof(double)))==NULL) {
sprintf(errstr,"INSUFFICIENT MEMORY for lens store.\n");
return(MEMORY_ERROR);
}
sum = dz->param[SORT_SMALL];
for(n=0;n<dz->iparam[SORT_LENCNT];n++) {
lcnt[n] = 0;
sortlens[n] = sum;
if(dz->mode==BY_LOG_DUR)
sum *= dz->param[SORT_STEP];
else
sum += dz->param[SORT_STEP];
}
lcnt[dz->iparam[SORT_LENCNT]] = 0;
sortlens[dz->iparam[SORT_LENCNT]-1] = dz->param[SORT_LARGE];
dz->iparam[SORT_LENCNT]++;
/* fall thro */
case(IN_DUR_ORDER):
if((lstore = (char ***)malloc((dz->iparam[SORT_LENCNT]+1) * sizeof(char **)))==NULL) {
sprintf(errstr,"INSUFFICIENT MEMORY for length store.\n");
return(MEMORY_ERROR);
}
for(n=0;n<dz->iparam[SORT_LENCNT]+1;n++) {
// AVOID realloc
if((lstore[n] = (char **)malloc(infilecnt * sizeof(char *)))==NULL) {
sprintf(errstr,"INSUFFICIENT MEMORY for length store %d.\n",n+1);
return(MEMORY_ERROR);
}
}
break;
}
strip_extension(filename);
if(sloom && (dz->mode == BY_FILETYPE || dz->mode == BY_SRATE)) {
p = filename + strlen(filename) - 1; /* Strip trailing zero from generic tempfilename */
*p = ENDOFSTR;
}
for(n=0;n<infilecnt;n++) {
if(!strcmp(dz->wordstor[infilecnt],dz->wordstor[n])) {
sprintf(errstr,"The name of the listfile cannot be included in the listing!!\n");
return(DATA_ERROR);
}
}
// AVOID realloc
for(n=0;n<infilecnt;n++)
namestoresize += strlen(dz->wordstor[n]) + 1;
if((namestore = (char *)malloc(namestoresize * sizeof(char)))==NULL) {
sprintf(errstr,"INSUFFICIENT MEMORY for name store.\n");
return(MEMORY_ERROR);
}
namestoresize = 0;
for(n=0;n<infilecnt;n++) {
if((dz->ifd[0] = sndopenEx(dz->wordstor[n],0,CDP_OPEN_RDONLY)) < 0) {
if(dz->mode!=BY_FILETYPE) {
if(!done_errmsg) {
sprintf(errstr,"Some files are NOT soundfiles.\n");
print_outmessage_flush(errstr);
done_errmsg = 1;
}
}
dz->ifd[0] = -1;
continue;
} else if((dz->mode!=BY_FILETYPE) && filename_extension_is_not_sound(dz->wordstor[n])) {
if(!done_errmsg) {
sprintf(errstr,"Some files are NOT soundfiles.\n");
print_outmessage_flush(errstr);
done_errmsg = 1;
}
continue;
}
switch(dz->mode) {
case(BY_SRATE):
if((exit_status = do_srates(filename,dz->wordstor[n],&file48,&file44,&file32,&file24,&file22,&file16,
&is_file48,&is_file44,&is_file32,&is_file24,&is_file22,&is_file16,
&fp48,&fp44,&fp32,&fp24,&fp22,&fp16,dz))<0)
return(exit_status);
break;
case(BY_DURATION):
case(BY_LOG_DUR):
if((exit_status = do_lenths(filename,dz->wordstor[n],&namestore,lstore,&namestoresize,lcnt,sortlens,dz))<0)
return(exit_status);
break;
case(IN_DUR_ORDER):
if((exit_status = do_order
(filename,dz->wordstor[n],&namestore,&lenstore,&posstore,&lstore,&fileno,&namestoresize,dz))<0)
return(exit_status);
break;
case(BY_FILETYPE):
if((exit_status = do_types(filename,dz->wordstor[n],
&monofile,&stereofile,&quadfile,&analfile,&pitchfile,&transfile,&formantfile,&envfile,&otherfile,
&is_mono_list,&is_stereo_list,&is_quad_list,&is_anal_list,
&is_pitch_list,&is_trans_list,&is_fmnt_list,&is_env_list,&is_other_list,
&fpm,&fps,&fpa,&fpp,&fpt,&fpf,&fpe,&fpo,&fpq,dz))<0)
return(exit_status);
break;
case(FIND_ROGUES):
do_rogues(dz->wordstor[n],&a_srate,dz);
break;
}
if(dz->ifd[0]!=-1 && sndcloseEx(dz->ifd[0])<0)
fprintf(stdout,"WARNING: Failed to close sndfile %s.\n",dz->wordstor[n]);
dz->ifd[0] = -1;
}
switch(dz->mode) {
case(BY_LOG_DUR):
case(BY_DURATION):
if((exit_status = output_lenths(filename,&otherfile,lstore,sortlens,lcnt,dz))<0)
return(exit_status);
break;
case(BY_SRATE):
output_srates(is_file48,is_file44,is_file32,is_file24,is_file22,is_file16,
file48, file44,file32,file24,file22,file16);
break;
case(IN_DUR_ORDER):
if((exit_status = output_order(filename,&otherfile,posstore,lenstore,lstore,fileno,dz))<0)
return(exit_status);
break;
case(BY_FILETYPE):
output_types(filename,is_mono_list,is_stereo_list,is_quad_list,
is_anal_list,is_pitch_list,is_trans_list,is_fmnt_list,is_env_list,
is_other_list,monofile,stereofile,quadfile,analfile,pitchfile,
transfile,formantfile,envfile,otherfile);
break;
}
fflush(stdout);
return(FINISHED);
}