/*====================================+
* request_file -- Prompt user for file name
* returns open file pointer, or NULL if error
* handles error message
* Created: 2002/01/18
*===================================*/
static BOOLEAN
request_file (BOOLEAN *eflg)
{
STRING rptdir = getlloptstr("LLREPORTS", ".");
STRING fname=0, fullpath=0;
Poutfp = rptui_ask_for_output_file(LLWRITETEXT, _(qSwhtout), &fname
, &fullpath, rptdir, NULL);
if (!Poutfp || !fname || !fname[0]) {
if (fname)
prog_error(0, _("Report stopping due to error opening output file"));
else
prog_error(0, _("Report stopping due to lack of output file"));
/* set error flag to stop interpreter */
*eflg = TRUE;
/* set cancel flag to suppress traceback */
rpt_cancelled = TRUE;
strfree(&fname);
return FALSE;
}
if (outfilename)
stdfree(outfilename);
outfilename = fullpath;
strfree(&fname);
prefix_file_for_report(Poutfp);
return TRUE;
}
static bool reopen_input_file(int i,progress_info *proginfo)
{
unsigned char *header;
if (!open_input_stream(files[i])) {
prog_error(proginfo);
st_warning("could not reopen input file: [%s]",files[i]->filename);
return FALSE;
}
if (NULL == (header = malloc(files[i]->header_size * sizeof(unsigned char)))) {
prog_error(proginfo);
st_warning("could not allocate %d-byte WAVE header",files[i]->header_size);
return FALSE;
}
if (read_n_bytes(files[i]->input,header,files[i]->header_size,NULL) != files[i]->header_size) {
prog_error(proginfo);
st_warning("error while reading %d-byte WAVE header",files[i]->header_size);
st_free(header);
return FALSE;
}
st_free(header);
return TRUE;
}
/*================================================+
* evaluate_cond -- Evaluate conditional expression
*===============================================*/
BOOLEAN
evaluate_cond (PNODE node, SYMTAB stab, BOOLEAN *eflg)
{
PVALUE val;
BOOLEAN rc;
PNODE var = node, expr = inext(node);
if (!expr) {
expr = var;
var = NULL;
}
if (var && !iistype(var, IIDENT)) {
*eflg = TRUE;
prog_error(node, "1st arg in conditional must be variable");
return FALSE;
}
val = evaluate(expr, stab, eflg);
if (*eflg || !val) {
*eflg = TRUE;
prog_error(node, "error in conditional expression");
return FALSE;
}
#ifdef DEBUG
llwprintf("interp_if: cond = ");
show_pvalue(val);
wprintf("\n");
#endif
if (var) assign_iden(stab, iident(node), copy_pvalue(val));
coerce_pvalue(PBOOL, val, eflg);
rc = pvalue_to_bool(val);
delete_pvalue(val);
return rc;
}
void get_soil_params(char *soil_type, double *c_theta, double *n_theta) {
/* For a given soil type, get the parameters for the soil
moisture availability based on Landsberg and Waring, with updated
parameters from Landsberg and Sands (2011), pg 190, Table 7.1
Table also has values from Saxton for soil texture, perhaps makes more
sense to use those than Cosby? Investigate?
Reference
---------
* Landsberg and Sands (2011) Physiological ecology of forest production.
* Landsberg and Waring (1997) Forest Ecology & Management, 95, 209-228.
* Clapp & Hornberger (1978) Water Resources Research, 14, 601–604.
*/
if (strcmp(soil_type, "clay") == 0) {
*c_theta = 0.4;
*n_theta = 3.0;
} else if (strcmp(soil_type, "clay_loam") == 0) {
*c_theta = 0.5;
*n_theta = 5.0;
} else if (strcmp(soil_type, "loam") == 0) {
*c_theta = 0.55;
*n_theta = 6.0;
} else if (strcmp(soil_type, "loamy_sand") == 0) {
*c_theta = 0.65;
*n_theta = 8.0;
} else if (strcmp(soil_type, "sand") == 0) {
*c_theta = 0.7;
*n_theta = 9.0;
} else if (strcmp(soil_type, "sandy_clay") == 0) {
*c_theta = 0.45;
*n_theta = 4.0;
} else if (strcmp(soil_type, "sandy_clay_loam") == 0) {
*c_theta = 0.525;
*n_theta = 5.5;
} else if (strcmp(soil_type, "sandy_loam") == 0) {
*c_theta = 0.6;
*n_theta = 7.0;
} else if (strcmp(soil_type, "silt") == 0) {
*c_theta = 0.625;
*n_theta = 7.5;
} else if (strcmp(soil_type, "silty_clay") == 0) {
*c_theta = 0.425;
*n_theta = 3.5;
} else if (strcmp(soil_type, "silty_clay_loam") == 0) {
*c_theta = 0.475;
*n_theta = 4.5;
} else if (strcmp(soil_type, "silty_loam") == 0) {
*c_theta = 0.575;
*n_theta = 6.5;
} else {
prog_error("There are no parameters for your soil type", __LINE__);
}
return;
}
double *get_soil_fracs(char *soil_type) {
/*
* Based on Table 2 in Cosby et al 1984, page 2.
* Fractions of silt, sand and clay (in that order)
*/
double *fsoil = malloc(3 * sizeof(double));
if (strcmp(soil_type, "sand") == 0) {
fsoil[0] = 0.05;
fsoil[1] = 0.92;
fsoil[2] = 0.03;
} else if (strcmp(soil_type, "loamy_sand") == 0) {
fsoil[0] = 0.12;
fsoil[1] = 0.82;
fsoil[2] = 0.06;
} else if (strcmp(soil_type, "sandy_loam") == 0) {
fsoil[0] = 0.32;
fsoil[1] = 0.58;
fsoil[2] = 0.1;
} else if (strcmp(soil_type, "loam") == 0) {
fsoil[0] = 0.39;
fsoil[1] = 0.43;
fsoil[2] = 0.18;
} else if (strcmp(soil_type, "silty_loam") == 0) {
fsoil[0] = 0.7;
fsoil[1] = 0.17;
fsoil[2] = 0.13;
} else if (strcmp(soil_type, "sandy_clay_loam") == 0) {
fsoil[0] = 0.15;
fsoil[1] = 0.58;
fsoil[2] = 0.27;
} else if (strcmp(soil_type, "clay_loam") == 0) {
fsoil[0] = 0.34;
fsoil[1] = 0.32;
fsoil[2] = 0.34;
} else if (strcmp(soil_type, "silty_clay_loam") == 0) {
fsoil[0] = 0.56;
fsoil[1] = 0.1;
fsoil[2] = 0.34;
} else if (strcmp(soil_type, "sandy_clay") == 0) {
fsoil[0] = 0.06;
fsoil[1] = 0.52;
fsoil[2] = 0.42;
} else if (strcmp(soil_type, "silty_clay") == 0) {
fsoil[0] = 0.47;
fsoil[1] = 0.06;
fsoil[2] = 0.47;
} else if (strcmp(soil_type, "clay") == 0) {
fsoil[0] = 0.2;
fsoil[1] = 0.22;
fsoil[2] = 0.58;
} else {
prog_error("Could not understand soil type", __LINE__);
}
return (fsoil);
}
/*==================================+
* llrpt_addtoset -- Add person to INDISEQ
* usage: addtoset(SET, INDI, ANY) -> VOID
*=================================*/
PVALUE
llrpt_addtoset (PNODE node, SYMTAB stab, BOOLEAN *eflg)
{
NODE indi=0;
STRING key=0;
INDISEQ seq=0;
PNODE arg1 = builtin_args(node), arg2 = inext(arg1),
arg3 = inext(arg2);
PVALUE val1 = eval_and_coerce(PSET, arg1, stab, eflg);
PVALUE val2=0;
if (*eflg) {
prog_var_error(node, stab, arg1, val1, nonsetx, "addtoset", "1");
return NULL;
}
ASSERT(seq = pvalue_to_seq(val1));
indi = eval_indi(arg2, stab, eflg, NULL);
if (*eflg) {
prog_var_error(node, stab, arg2, NULL, nonindx, "addtoset","2");
goto ats_exit;
}
if (!indi) goto ats_exit;
*eflg = TRUE;
if (!(key = strsave(rmvat(nxref(indi))))) {
prog_error(node, "major error in addtoset.");
goto ats_exit;
}
*eflg = FALSE;
val2 = evaluate(arg3, stab, eflg);
if (*eflg) {
prog_error(node, "3rd arg to addtoset is in error.");
goto ats_exit;
}
append_indiseq_pval(seq, key, NULL, val2, FALSE);
ats_exit:
if (key) strfree(&key); /* append made its own copy */
/* delay to last minute val1 cleanup lest it is a temp owning seq,
eg, addtoset(ancestorset(i),j) */
if (val1) delete_pvalue(val1);
return NULL;
}
static bool open_this_file(int i,char *outfilename,progress_info *proginfo)
{
unsigned char header[CANONICAL_HEADER_SIZE];
create_output_filename(files[i]->filename,files[i]->input_format->extension,outfilename);
proginfo->filename1 = files[i]->filename;
proginfo->filedesc1 = files[i]->m_ss;
proginfo->filename2 = outfilename;
if (NULL == (files[i]->output = open_output_stream(outfilename,&files[i]->output_proc))) {
prog_error(proginfo);
st_error("could not open output file: [%s]",outfilename);
}
make_canonical_header(header,files[i]);
if ((numfiles - 1 == i) && pad)
put_data_size(header,CANONICAL_HEADER_SIZE,files[i]->new_data_size+pad_bytes);
else {
put_data_size(header,CANONICAL_HEADER_SIZE,files[i]->new_data_size);
if (files[i]->new_data_size & 1)
put_chunk_size(header,(files[i]->new_data_size + 1) + CANONICAL_HEADER_SIZE - 8);
}
if (write_n_bytes(files[i]->output,header,CANONICAL_HEADER_SIZE,proginfo) != CANONICAL_HEADER_SIZE) {
prog_error(proginfo);
st_warning("error while writing %d-byte WAVE header",CANONICAL_HEADER_SIZE);
return FALSE;
}
proginfo->filename2 = outfilename;
proginfo->bytes_total = files[i]->new_data_size + CANONICAL_HEADER_SIZE;
return TRUE;
}
/*===========================================+
* llrpt_deletefromset -- Remove person from INDISEQ
* usage: deletefromset(SET, INDI, BOOL) -> VOID
*==========================================*/
PVALUE
llrpt_deletefromset (PNODE node, SYMTAB stab, BOOLEAN *eflg)
{
NODE indi;
STRING key=0;
BOOLEAN all, rc;
INDISEQ seq;
PNODE arg1 = builtin_args(node), arg2 = inext(arg1),
arg3 = inext(arg2);
PVALUE val1 = eval_and_coerce(PSET, arg1, stab, eflg);
PVALUE val3=0;
if (*eflg) {
prog_var_error(node, stab, arg1, val1, nonsetx, "deletefromset", "1");
goto dfs_exit;
}
ASSERT(seq = pvalue_to_seq(val1));
indi = eval_indi(arg2, stab, eflg, NULL);
if (*eflg) {
prog_var_error(node, stab, arg2, NULL, nonindx, "deletefromset", "2");
goto dfs_exit;
}
if (!indi) goto dfs_exit;
*eflg = TRUE;
if (!(key = strsave(rmvat(nxref(indi))))) {
prog_error(node, "major error in deletefromset.");
goto dfs_exit;
}
*eflg = FALSE;
val3 = eval_and_coerce(PBOOL, arg3, stab, eflg);
if (*eflg) {
prog_var_error(node, stab, arg2, NULL, nonboox, "deletefromset", "3");
goto dfs_exit;
}
all = pvalue_to_bool(val3);
delete_pvalue(val3);
do {
rc = delete_indiseq(seq, key, NULL, 0);
} while (rc && all);
dfs_exit:
/* delay delete of val1 to last minute lest it is a temp owning seq,
eg, deletefromset(ancestorset(i),j) */
if (val1) delete_pvalue(val1);
if (key) strfree(&key);
return NULL;
}
/*===================================
* llrpt_valuesort -- Sort INDISEQ by value
* usage: valuesort(SET) -> VOID
*=================================*/
PVALUE
llrpt_valuesort (PNODE node, SYMTAB stab, BOOLEAN *eflg)
{
INDISEQ seq;
PNODE arg1 = builtin_args(node);
PVALUE val1 = eval_and_coerce(PSET, arg1, stab, eflg);
if (*eflg) {
prog_var_error(node, stab, arg1, val1, nonset1, "valuesort");
return NULL;
}
ASSERT(seq = pvalue_to_seq(val1));
valuesort_indiseq(seq,eflg);
if (*eflg) {
prog_error(node, _("missing or incorrect value for sort"));
return NULL;
}
/* delay to last minute lest it is a temp owning seq,
eg, valuesort(ancestorset(i) */
delete_pvalue(val1);
return NULL;
}
/*====================================+
* llrpt_inset -- See if person is in INDISEQ
* usage: inset(SET, INDI) -> BOOL
*==========================================*/
PVALUE
llrpt_inset (PNODE node, SYMTAB stab, BOOLEAN *eflg)
{
NODE indi;
STRING key=0;
INDISEQ seq;
BOOLEAN rel;
PNODE arg1 = builtin_args(node), arg2 = inext(arg1);
PVALUE val1 = eval_and_coerce(PSET, arg1, stab, eflg);
PVALUE valr=0;
if (*eflg ||!val1 || !(seq = pvalue_to_seq(val1))) {
*eflg = TRUE;
prog_var_error(node, stab, arg1, val1, nonsetx, "inset", "1");
goto inset_exit;
}
indi = eval_indi(arg2, stab, eflg, NULL);
if (*eflg) {
prog_var_error(node, stab, arg2, NULL, nonindx, "inset", "2");
goto inset_exit;
}
if (!indi) {
rel = FALSE;
} else {
if (!(key = strsave(rmvat(nxref(indi))))) {
*eflg = TRUE;
prog_error(node, "major error in inset.");
goto inset_exit;
}
rel = in_indiseq(seq, key);
}
valr = create_pvalue_from_bool(rel);
inset_exit:
/* delay delete of val1 to last minute lest it is a temp owning seq,
eg, inset(ancestorset(i),j) */
if (val1) delete_pvalue(val1);
if (key) strfree(&key);
return valr;
}
/*=======================================+
* valueof_iden - Find value of identifier
* makes & returns copy
*======================================*/
PVALUE
valueof_iden (PNODE node, SYMTAB stab, STRING iden, BOOLEAN *eflg)
{
BOOLEAN there;
PVALUE val;
#ifdef DEBUG
llwprintf("valueof_iden: iden, stab, globtab: %s, %d, %d\n",
iden, stab, globtab);
#endif
*eflg = FALSE;
val = symtab_valueofbool(stab, iden, &there);
if (there) return copy_pvalue(val);
val = symtab_valueofbool(globtab, iden, &there);
if (there) return copy_pvalue(val);
/* undeclared identifier */
if (explicitvars) {
*eflg = TRUE;
prog_error(node, "Undeclared identifier: %s", iden);
}
return create_pvalue_any();
}
/*=============================================+
* prog_var_error_zstr -- Report a run time program error
* node: [IN] current parse node
* stab: [IN] current symbol table (lexical scope)
* arg: [IN] if non-null, parse node of troublesome argument
* val: [IN] if non-null, PVALUE of troublesome argument
* zstr: [IN] message
*
* Inline debugger is implemented here
* See vprog_error
* Created: 2002/02/17, Perry Rapp
*============================================*/
static void
prog_var_error_zstr (PNODE node, SYMTAB stab, PNODE arg, PVALUE val, ZSTR zstr)
{
STRING choices[5];
INT rtn=0;
SYMTAB curstab = stab; /* currently displayed symbol table */
INT nlevels=0; /* number frames on callstack */
INT curlevel=0; /* 0 is lowest */
ASSERT(zstr);
if (val) {
ZSTR zval = describe_pvalue(val);
zs_appf(zstr, " (value: %s)", zs_str(zval));
} else if (arg) {
INT max=40 + zs_len(zstr); /* not too much argument description */
/* arg isn't evaluated, but describe will at least give its type */
zs_apps(zstr, " (arg: ");
describe_pnode(arg, zstr, max);
zs_apps(zstr, ")");
}
prog_error(node, zs_str(zstr));
zs_free(&zstr);
if (dbg_mode != -99 && dbg_mode != 3) {
INT ch = 0;
while (!(ch=='d' || ch=='q'))
ch = rptui_prompt_stdout(_("Enter d for debugger, q to quit"));
if (ch == 'q')
dbg_mode = -99;
}
/* call stack size & location */
nlevels = count_symtab_ancestors(stab) + 1;
curlevel = 0;
/* report debugger loop */
while (dbg_mode != -99) {
ZSTR zstr=zs_new();
INT n=0;
/* 0: display local variable(s) */
n = (curstab->tab ? get_table_count(curstab->tab) : 0);
zs_setf(zstr, _pl("Display local (%d var)",
"Display locals (%d vars)", n), n);
zs_appf(zstr, " [%s]", curstab->title);
choices[0] = strsave(zs_str(zstr));
/* 1: display global variables */
n = (globtab->tab ? get_table_count(globtab->tab) : 0);
zs_setf(zstr, _pl("Display global (%d var)",
"Display globals (%d vars)", n), n);
choices[1] = strsave(zs_str(zstr));
/* 2: up call stack */
n = nlevels - curlevel - 1;
zs_setf(zstr, _pl("Call stack has %d higher level", "Call stack has %d higher levels", n), n);
zs_apps(zstr, ". ");
if (n > 0) {
zs_apps(zstr, _(" Go up one level"));
zs_appf(zstr, "(%s)", curstab->parent->title);
}
choices[2] = strsave(zs_str(zstr));
/* 3: down call stack */
n = curlevel;
zs_setf(zstr, _pl("Call stack has %d lower level", "Call stack has %d lower levels", n), n);
zs_apps(zstr, ". ");
if (n > 0) {
CNSTRING title = get_symtab_ancestor(stab, n-1)->title;
zs_apps(zstr, _(" Go down one level"));
zs_appf(zstr, "(%s)", title);
}
choices[3] = strsave(zs_str(zstr));
/* quit */
choices[4] = strsave(_("Quit debugger"));
dbgloop:
rtn = rptui_choose_from_array(_("Report debugger"), ARRSIZE(choices), choices);
if (rtn == 4 || rtn == -1) {
dbg_mode = -99;
} else if (rtn == 0) {
disp_symtab(_("Local variables"), curstab);
goto dbgloop;
} else if (rtn == 1) {
disp_symtab(_("Global variables"), globtab);
goto dbgloop;
} else if (rtn == 2) {
if (curlevel+1 < nlevels) {
curstab = curstab->parent;
++curlevel;
ASSERT(curstab);
}
} else if (rtn == 3) {
if (curlevel > 0) {
curstab = get_symtab_ancestor(stab, curlevel-1);
--curlevel;
ASSERT(curstab);
}
}
zs_free(&zstr);
free_array_strings(ARRSIZE(choices), choices);
}
}
static bool do_join()
{
int i,bytes_to_skip,bytes_to_xfer;
proc_info output_proc;
char outfilename[FILENAME_SIZE];
wlong total=0;
unsigned char header[CANONICAL_HEADER_SIZE];
FILE *output;
wave_info *joined_info;
bool success;
progress_info proginfo;
success = FALSE;
create_output_filename("","",outfilename);
for (i=0;i<numfiles;i++)
total += files[i]->data_size;
if (all_files_cd_quality && (total % CD_BLOCK_SIZE) != 0) {
pad_bytes = CD_BLOCK_SIZE - (total % CD_BLOCK_SIZE);
if (JOIN_NOPAD != pad_type)
total += pad_bytes;
}
if (NULL == (joined_info = new_wave_info(NULL))) {
st_error("could not allocate memory for joined file information");
}
joined_info->chunk_size = total + CANONICAL_HEADER_SIZE - 8;
joined_info->channels = files[0]->channels;
joined_info->samples_per_sec = files[0]->samples_per_sec;
joined_info->avg_bytes_per_sec = files[0]->avg_bytes_per_sec;
joined_info->rate = files[0]->rate;
joined_info->block_align = files[0]->block_align;
joined_info->bits_per_sample = files[0]->bits_per_sample;
joined_info->data_size = total;
joined_info->wave_format = files[0]->wave_format;
joined_info->problems = (files[0]->problems & PROBLEM_NOT_CD_QUALITY);
if (PROB_ODD_SIZED_DATA(joined_info))
joined_info->chunk_size++;
joined_info->total_size = joined_info->chunk_size + 8;
joined_info->length = joined_info->data_size / joined_info->rate;
joined_info->exact_length = (double)joined_info->data_size / (double)joined_info->rate;
length_to_str(joined_info);
proginfo.initialized = FALSE;
proginfo.prefix = "Joining";
proginfo.clause = "-->";
proginfo.filename1 = files[0]->filename;
proginfo.filedesc1 = files[0]->m_ss;
proginfo.filename2 = outfilename;
proginfo.filedesc2 = joined_info->m_ss;
proginfo.bytes_total = files[0]->total_size;
prog_update(&proginfo);
if (NULL == (output = open_output_stream(outfilename,&output_proc))) {
st_error("could not open output file");
}
make_canonical_header(header,joined_info);
if (write_n_bytes(output,header,CANONICAL_HEADER_SIZE,&proginfo) != CANONICAL_HEADER_SIZE) {
prog_error(&proginfo);
st_warning("error while writing %d-byte WAVE header",CANONICAL_HEADER_SIZE);
goto cleanup;
}
if (all_files_cd_quality && (JOIN_PREPAD == pad_type) && pad_bytes) {
if (pad_bytes != write_padding(output,pad_bytes,&proginfo)) {
prog_error(&proginfo);
st_warning("error while pre-padding with %d zero-bytes",pad_bytes);
goto cleanup;
}
}
for (i=0;i<numfiles;i++) {
proginfo.bytes_total = files[i]->total_size;
proginfo.filename1 = files[i]->filename;
proginfo.filedesc1 = files[i]->m_ss;
prog_update(&proginfo);
if (!open_input_stream(files[i])) {
prog_error(&proginfo);
st_warning("could not reopen input file");
goto cleanup;
}
bytes_to_skip = files[i]->header_size;
while (bytes_to_skip > 0) {
bytes_to_xfer = min(bytes_to_skip,CANONICAL_HEADER_SIZE);
if (read_n_bytes(files[i]->input,header,bytes_to_xfer,NULL) != bytes_to_xfer) {
prog_error(&proginfo);
st_warning("error while reading %d bytes of data",bytes_to_xfer);
goto cleanup;
}
bytes_to_skip -= bytes_to_xfer;
}
if (transfer_n_bytes(files[i]->input,output,files[i]->data_size,&proginfo) != files[i]->data_size) {
prog_error(&proginfo);
st_warning("error while transferring %lu bytes of data",files[i]->data_size);
goto cleanup;
}
prog_success(&proginfo);
close_input_stream(files[i]);
}
if (all_files_cd_quality && JOIN_POSTPAD == pad_type && pad_bytes) {
if (pad_bytes != write_padding(output,pad_bytes,NULL)) {
prog_error(&proginfo);
st_warning("error while post-padding with %d zero-bytes",pad_bytes);
goto cleanup;
}
}
if ((JOIN_NOPAD == pad_type) && PROB_ODD_SIZED_DATA(joined_info) && (1 != write_padding(output,1,NULL))) {
prog_error(&proginfo);
st_warning("error while NULL-padding odd-sized data chunk");
goto cleanup;
}
if (all_files_cd_quality) {
if (JOIN_NOPAD != pad_type) {
if (pad_bytes)
st_info("%s-padded output file with %d zero-bytes.\n",((JOIN_PREPAD == pad_type)?"Pre":"Post"),pad_bytes);
else
st_info("No padding needed.\n");
}
else {
st_info("Output file was not padded, ");
if (pad_bytes)
st_info("though it needs %d bytes of padding.\n",pad_bytes);
else
st_info("nor was it needed.\n");
}
}
success = TRUE;
cleanup:
if ((CLOSE_CHILD_ERROR_OUTPUT == close_output(output,output_proc)) || !success) {
success = FALSE;
remove_file(outfilename);
st_error("failed to join files");
}
return success;
}
static bool write_fixed_files()
{
int cur_input,cur_output;
unsigned long bytes_have,bytes_needed,bytes_to_xfer;
char outfilename[FILENAME_SIZE];
bool success;
progress_info proginfo;
success = FALSE;
cur_input = cur_output = 0;
bytes_have = (unsigned long)files[cur_input]->data_size;
bytes_needed = (unsigned long)files[cur_output]->new_data_size;
proginfo.initialized = FALSE;
proginfo.prefix = "Fixing";
proginfo.clause = "-->";
proginfo.filename1 = files[0]->filename;
proginfo.filedesc1 = files[0]->m_ss;
proginfo.filename2 = NULL;
proginfo.filedesc2 = NULL;
proginfo.bytes_total = 1;
if (!open_this_file(cur_output,outfilename,&proginfo))
goto cleanup;
if (!reopen_input_file(cur_input,&proginfo))
goto cleanup;
while (cur_input < numfiles && cur_output < numfiles) {
bytes_to_xfer = min(bytes_have,bytes_needed);
if (transfer_n_bytes(files[cur_input]->input,files[cur_output]->output,bytes_to_xfer,&proginfo) != bytes_to_xfer) {
prog_error(&proginfo);
st_warning("error while transferring %lu bytes of data",bytes_to_xfer);
goto cleanup;
}
bytes_have -= bytes_to_xfer;
bytes_needed -= bytes_to_xfer;
if (0 == bytes_have) {
close_input_stream(files[cur_input]);
files[cur_input]->input = NULL;
cur_input++;
if (cur_input < numfiles) {
bytes_have = (unsigned long)files[cur_input]->data_size;
if (!reopen_input_file(cur_input,&proginfo))
goto cleanup;
}
}
if (0 == bytes_needed) {
prog_success(&proginfo);
if (numfiles - 1 == cur_output) {
if (pad) {
if (pad_bytes) {
if (pad_bytes != write_padding(files[cur_output]->output,pad_bytes,NULL)) {
prog_error(&proginfo);
st_warning("error while padding with %d zero-bytes",pad_bytes);
goto cleanup;
}
st_info("Padded last file with %d zero-bytes.\n",pad_bytes);
}
else
st_info("No padding needed.\n");
}
else {
st_info("Last file was not padded, ");
if (pad_bytes)
st_info("though it needs %d bytes of padding.\n",pad_bytes);
else
st_info("nor was it needed.\n");
if ((files[cur_output]->new_data_size & 1) && (1 != write_padding(files[cur_output]->output,1,NULL))) {
prog_error(&proginfo);
st_warning("error while NULL-padding odd-sized data chunk");
goto cleanup;
}
}
}
close_output_stream(files[cur_output]);
files[cur_output]->output = NULL;
cur_output++;
if (cur_output < numfiles) {
bytes_needed = (unsigned long)files[cur_output]->new_data_size;
if (!open_this_file(cur_output,outfilename,&proginfo))
goto cleanup;
}
}
}
success = TRUE;
cleanup:
if (!success) {
close_output_stream(files[cur_output]);
remove_file(outfilename);
st_error("failed to fix files");
}
return success;
}
int parse_ini_file(control *c, params *p, state *s)
{
/*
Loop through the file which is passed on the standard in, and break
the file up into the relevant sections...
*/
char line[STRING_LENGTH];
char section[STRING_LENGTH] = "";
char prev_name[STRING_LENGTH] = "";
char *start;
char *end;
char *name;
char *value;
int error = 0;
int line_number = 0;
if ((c->ifp = fopen(c->cfg_fname, "r")) == NULL){
prog_error("Error opening output file for write on line", __LINE__);
}
while (fgets(line, sizeof(line), c->ifp) != NULL) {
line_number++;
start = lskip(rstrip(line));
if (*start == ';' || *start == '#') {
/* Per Python ConfigParser, allow '#' comments at start of line */
}
else if (*start == '[') {
/* A "[section]" line */
end = find_char_or_comment(start + 1, ']');
if (*end == ']') {
*end = '\0';
strncpy0(section, start + 1, sizeof(section));
*prev_name = '\0';
}
else if (!error) {
/* No ']' found on section line */
error = line_number;
}
}
else if (*start && *start != ';') {
/* Not a comment, must be a name[=:]value pair */
end = find_char_or_comment(start, '=');
if (*end != '=') {
end = find_char_or_comment(start, ':');
}
if (*end == '=' || *end == ':') {
*end = '\0';
name = rstrip(start);
value = lskip(end + 1);
end = find_char_or_comment(value, '\0');
if (*end == ';')
*end = '\0';
rstrip(value);
/* Valid name[=:]value pair found, call handler */
strncpy0(prev_name, name, sizeof(prev_name));
if (!handler(section, name, value, c, p, s) && !error)
error = line_number;
}
else if (!error) {
/* No '=' or ':' found on name[=:]value line */
error = line_number;
break;
}
}
}
if (c->print_options == END) {
/* we need to re-read this file to dump the final state */
rewind(c->ifp);
}
return error;
}
static bool split_file(wave_info *info)
{
unsigned char header[CANONICAL_HEADER_SIZE];
char outfilename[FILENAME_SIZE],filenum[FILENAME_SIZE];
int current;
wint discard,bytes;
bool success;
wlong leadin_bytes, leadout_bytes, bytes_to_xfer;
progress_info proginfo;
// uwe
double start_time, end_time, last_end_time;
success = FALSE;
proginfo.initialized = FALSE;
proginfo.prefix = "Splitting";
proginfo.clause = "-->";
proginfo.filename1 = info->filename;
proginfo.filedesc1 = info->m_ss;
proginfo.filename2 = NULL;
proginfo.filedesc2 = NULL;
proginfo.bytes_total = 0;
if (!open_input_stream(info)) {
prog_error(&proginfo);
st_error("could not reopen input file: [%s]",info->filename);
}
discard = info->header_size;
while (discard > 0) {
bytes = min(discard,CANONICAL_HEADER_SIZE);
if (read_n_bytes(info->input,header,bytes,NULL) != bytes) {
prog_error(&proginfo);
st_error("error while discarding %d-byte WAVE header",info->header_size);
}
discard -= bytes;
}
leadin_bytes = (leadin) ? smrt_parse((unsigned char *)leadin,info) : 0;
leadout_bytes = (leadout) ? smrt_parse((unsigned char *)leadout,info) : 0;
adjust_for_leadinout(leadin_bytes,leadout_bytes);
// uwe transcription
st_output("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n");
st_output("<Trans version=\"2\">\n\n");
start_time = end_time = last_end_time = 0;
for (current=0;current<numfiles;current++) {
if (SPLIT_INPUT_CUE == input_type && cueinfo.format) {
create_output_filename(cueinfo.filenames[current],"",outfilename);
}
else {
st_snprintf(filenum,8,num_format,current+offset);
create_output_filename(filenum,"",outfilename);
}
files[current]->chunk_size = files[current]->data_size + CANONICAL_HEADER_SIZE - 8;
files[current]->channels = info->channels;
files[current]->samples_per_sec = info->samples_per_sec;
files[current]->avg_bytes_per_sec = info->avg_bytes_per_sec;
files[current]->block_align = info->block_align;
files[current]->bits_per_sample = info->bits_per_sample;
files[current]->wave_format = info->wave_format;
files[current]->rate = info->rate;
files[current]->length = files[current]->data_size / (wlong)info->rate;
files[current]->exact_length = (double)files[current]->data_size / (double)info->rate;
files[current]->total_size = files[current]->chunk_size + 8;
length_to_str(files[current]);
proginfo.filedesc2 = files[current]->m_ss;
proginfo.bytes_total = files[current]->total_size;
if (extract_track[current]) {
proginfo.prefix = "Splitting";
proginfo.filename2 = outfilename;
// uwe transcription
start_time += last_end_time;
end_time += files[current]->data_size / (wlong)info->rate;
last_end_time = end_time;
printf("<Turn startTime=\"%.2f\"", start_time); // %.2f
st_output(" endTime=\"%.2f\"", end_time);
st_output(" splitFilename=\"%s\"", outfilename);
st_output(" speaker=\"spk1\">\n");
st_output("<Sync time=\"%.2f\"/>\n", start_time);
st_output("***Include transcript words here***\n");
st_output("</Turn>\n");
if (NULL == (files[current]->output = open_output_stream(outfilename,&files[current]->output_proc))) {
prog_error(&proginfo);
st_error("could not open output file");
}
}
else {
proginfo.prefix = "Skipping ";
proginfo.filename2 = NULLDEVICE;
if (NULL == (files[current]->output = open_output(NULLDEVICE))) {
prog_error(&proginfo);
st_error("while skipping track %d: could not open output file: [%s]",current+1,NULLDEVICE);
}
files[current]->output_proc.pid = NO_CHILD_PID;
}
if (PROB_ODD_SIZED_DATA(files[current]))
files[current]->chunk_size++;
make_canonical_header(header,files[current]);
// uwe disable
//prog_update(&proginfo);
if (write_n_bytes(files[current]->output,header,CANONICAL_HEADER_SIZE,&proginfo) != CANONICAL_HEADER_SIZE) {
prog_error(&proginfo);
st_warning("error while writing %d-byte WAVE header",CANONICAL_HEADER_SIZE);
goto cleanup;
}
/* if this is not the first file, finish up writing previous file, and simultaneously start writing to current file */
if (0 != current) {
/* write overlapping lead-in/lead-out data to both previous and current files */
if (transfer_n_bytes2(info->input,files[current]->output,files[current-1]->output,leadin_bytes+leadout_bytes,&proginfo) != leadin_bytes+leadout_bytes) {
prog_error(&proginfo);
st_warning("error while transferring %ld bytes of lead-in/lead-out",leadin_bytes+leadout_bytes);
goto cleanup;
}
/* pad and close previous file */
if (PROB_ODD_SIZED_DATA(files[current-1]) && (1 != write_padding(files[current-1]->output,1,&proginfo))) {
prog_error(&proginfo);
st_warning("error while NULL-padding odd-sized data chunk");
goto cleanup;
}
close_output(files[current-1]->output,files[current-1]->output_proc);
}
/* transfer unique non-overlapping data from input file to current file */
bytes_to_xfer = files[current]->new_data_size;
if (0 != current)
bytes_to_xfer -= leadout_bytes;
if (numfiles - 1 != current)
bytes_to_xfer -= leadin_bytes;
if (transfer_n_bytes(info->input,files[current]->output,bytes_to_xfer,&proginfo) != bytes_to_xfer) {
prog_error(&proginfo);
st_warning("error while transferring %ld bytes of data",bytes_to_xfer);
goto cleanup;
}
/* if this is the last file, close it */
if (numfiles - 1 == current) {
/* pad and close current file */
if (PROB_ODD_SIZED_DATA(files[current]) && (1 != write_padding(files[current]->output,1,&proginfo))) {
prog_error(&proginfo);
st_warning("error while NULL-padding odd-sized data chunk");
goto cleanup;
}
close_output(files[current]->output,files[current]->output_proc);
// uwe transcription
st_output("</Trans>\n");
}
// uwe disable
// prog_success(&proginfo);
}
close_input_stream(info);
success = TRUE;
cleanup:
if (!success) {
close_output(files[current]->output,files[current]->output_proc);
remove_file(outfilename);
st_error("failed to split file");
}
return success;
}
/*================================================+
* evaluate_ufunc -- Evaluate user defined function
* node: [in] parsed node of function definition
* stab: [in] function's symbol table
* eflg: [out] error flag
*===============================================*/
PVALUE
evaluate_ufunc (PNODE node, SYMTAB stab, BOOLEAN *eflg)
{
STRING procname = (STRING) iname(node);
PNODE func, arg, parm;
SYMTAB newstab = NULL;
PVALUE val=NULL;
INTERPTYPE irc;
INT count=0;
*eflg = TRUE;
/* find func in local or global table */
func = get_proc_node(procname, irptinfo(node)->functab, gfunctab, &count);
if (!func) {
if (!count)
prog_error(node, _("Undefined func: %s"), procname);
else
prog_error(node, _("Ambiguous call to func: %s"), procname);
goto ufunc_leave;
}
newstab = create_symtab_proc(procname, stab);
arg = (PNODE) iargs(node);
parm = (PNODE) iargs(func);
while (arg && parm) {
BOOLEAN eflg=TRUE;
PVALUE value = evaluate(arg, stab, &eflg);
if (eflg) {
if (getlloptint("FullReportCallStack", 0) > 0)
prog_error(node, "In user function %s()", procname);
return INTERROR;
}
insert_symtab(newstab, iident(parm), value);
arg = inext(arg);
parm = inext(parm);
}
if (arg || parm) {
prog_error(node, "``%s'': mismatched args and params\n", procname);
goto ufunc_leave;
}
irc = interpret((PNODE) ibody(func), newstab, &val);
switch (irc) {
case INTRETURN:
case INTOKAY:
#ifdef DEBUG
llwprintf("Successful ufunc call -- val returned was ");
show_pvalue(val);
llwprintf("\n");
#endif
*eflg = FALSE;
goto ufunc_leave;
case INTBREAK:
case INTCONTINUE:
case INTERROR:
break;
}
if (getlloptint("FullReportCallStack", 0) > 0)
prog_error(node, "In user function %s()", procname);
*eflg = TRUE;
delete_pvalue(val);
val=NULL;
ufunc_leave:
if (newstab) {
remove_symtab(newstab);
newstab = NULL;
}
return val;
}
void open_output_file(control *c, char *fname, FILE **fp) {
*fp = fopen(fname, "w");
if (*fp == NULL)
prog_error("Error opening output file for write on line", __LINE__);
}
/*=======================================
* llrpt_addnode -- Add a node to a GEDCOM tree
* usage: addnode(NODE, NODE, NODE) -> VOID
* args: (node being added, parent, previous child)
*=====================================*/
PVALUE
llrpt_addnode (PNODE node, SYMTAB stab, BOOLEAN *eflg)
{
PNODE arg = iargs(node);
NODE newchild, next, prnt, prev;
/* first argument, node (must be nonnull) */
PVALUE val = eval_and_coerce(PGNODE, arg, stab, eflg);
if (*eflg) {
prog_var_error(node, stab, arg, val, nonnodx, "addnode", "1");
delete_pvalue(val);
return NULL;
}
newchild = remove_node_and_delete_pvalue(&val);
if (!newchild) {
prog_var_error(node, stab, arg, val, nonnodx, "addnode", "1");
return NULL;
}
/* second argument, parent (must be nonnull) */
val = eval_and_coerce(PGNODE, arg=inext(arg), stab, eflg);
if (*eflg) {
prog_var_error(node, stab, arg, val, nonnodx, "addnode", "2");
return NULL;
}
prnt = remove_node_and_delete_pvalue(&val);
if (!prnt) {
prog_var_error(node, stab, arg, val, nonnodx, "addnode", "2");
return NULL;
}
/* third argument, prior sibling (may be null) */
val = eval_and_coerce(PGNODE, arg=inext(arg), stab, eflg);
if (*eflg) {
prog_var_error(node, stab, arg, val, nonnodx, "addnode", "3");
delete_pvalue(val);
return NULL;
}
prev = remove_node_and_delete_pvalue(&val);
if (prev) {
/* Check that previous sibling actually is child of new parent */
if (prnt != nparent(prev)) {
prog_error(node, "2nd arg to addnode must be parent of 3rd arg");
*eflg = 1;
return NULL;
}
}
/* reparent node, but ensure its locking is only relative to new parent */
dolock_node_in_cache(newchild, FALSE);
nparent(newchild) = prnt;
newchild->n_cel = prnt->n_cel;
set_temp_node(newchild, is_temp_node(prnt));
dolock_node_in_cache(newchild, TRUE);
if (prev == NULL) {
next = nchild(prnt);
nchild(prnt) = newchild;
} else {
next = nsibling(prev);
nsibling(prev) = newchild;
}
nsibling(newchild) = next;
return NULL;
}
