void sym_set_scalar(int width, int *eval_flags,
scalar_t sc, ident_t id, sym_t sym){
int ivalue;
/* Find the symbol - it is does not exist make a new one */
sym_t newsym = sym_lookup(id, sym);
if (newsym == NULL) {
newsym = new_sym(id, sym);
}
/* Make sure that any existing one is of the right type */
if (newsym->type == SYM_VECTOR) {
/* errx(1, "%s is not a scalar", ident_str(id)); */
fprintf(stderr, "%s is not a scalar(lowercase)\n", ident_str(id));
exit(1);
}
/* Create a new scalar if needed */
if (newsym->type == SYM_UNKNOWN || newsym->scalar->width < width) {
if (newsym->type == SYM_SCALAR)
scalar_free(newsym->scalar);
newsym->type = SYM_SCALAR;
newsym->scalar = new_scalar(width);
}
/* Copy in the values */
for (ivalue=0; ivalue < width; ivalue++) {
if (eval_flags != NULL && !eval_flags[ivalue]) continue;
newsym->scalar->vals[ivalue] = sc->vals[ivalue];
}
return;
}
jl_value_t *jl_arrayref(jl_array_t *a, size_t i)
{
jl_type_t *el_type = (jl_type_t*)jl_tparam0(jl_typeof(a));
jl_value_t *elt;
if (jl_is_bits_type(el_type)) {
if (el_type == (jl_type_t*)jl_bool_type) {
if (((int8_t*)a->data)[i] != 0)
return jl_true;
return jl_false;
}
elt = new_scalar((jl_bits_type_t*)el_type);
size_t nb = a->elsize;
switch (nb) {
case 1:
*(int8_t*)jl_bits_data(elt) = ((int8_t*)a->data)[i]; break;
case 2:
*(int16_t*)jl_bits_data(elt) = ((int16_t*)a->data)[i]; break;
case 4:
*(int32_t*)jl_bits_data(elt) = ((int32_t*)a->data)[i]; break;
case 8:
*(int64_t*)jl_bits_data(elt) = ((int64_t*)a->data)[i]; break;
case 16:
*(bits128_t*)jl_bits_data(elt) = ((bits128_t*)a->data)[i]; break;
default:
memcpy(jl_bits_data(elt), &((char*)a->data)[i*nb], nb);
}
}
else {
elt = ((jl_value_t**)a->data)[i];
if (elt == NULL) {
jl_undef_ref_error();
}
}
return elt;
}
void sym_set_vector(int width, int *eval_flags,
vector_t v, ident_t id, sym_t sym){
int ivalue, iel;
scalar_t sc;
/* Find the symbol - it is does not exist make a new one */
sym_t newsym = sym_lookup(id, sym);
if (newsym == NULL) {
newsym = new_sym(id, sym);
}
/* Make sure that any existing one is of the right type */
if (newsym->type == SYM_SCALAR) {
/* errx(1, "%s is not a vector", ident_str(id)); */
fprintf(stderr, "%s is not a vector\n", ident_str(id));
exit(1);
}
/* Create a new vector if needed - either it does not exist or the
length is changing or the width is increasing*/
if (newsym->type == SYM_UNKNOWN || newsym->vector->len != v->len ||
(newsym->vector->len > 0 && newsym->vector->el[0]->width < width) ) {
/* Free an existing vector. If eval_flags is set, then we cannot
change the length of the vector */
if (newsym->type == SYM_VECTOR) {
if (eval_flags != NULL && newsym->vector->len != v->len) {
/* errx(1, "assigned vector must match length of %s in if",
ident_str(id)); */
fprintf(stderr, "assigned vector must match length of %s in if",
ident_str(id));
exit(1);
}
vector_free(newsym->vector);
}
newsym->type = SYM_VECTOR;
newsym->vector = new_vector();
for (iel=0; iel < v->len; iel++) {
sc = new_scalar(width);
vector_append(newsym->vector, sc);
scalar_free(sc);
}
}
/* Copy in the values */
for (ivalue=0; ivalue < width; ivalue++) {
if (eval_flags != NULL && !eval_flags[ivalue]) continue;
for (iel=0; iel < v->len; iel++) {
newsym->vector->el[iel]->vals[ivalue] = v->el[iel]->vals[ivalue];
}
}
return;
}
/* Main program */
int main(int argc, char *argv[]){
char **infiles, **outfiles;
int nfiles, nout;
char *arg_string;
Loop_Options *loop_options;
char *pname;
int i;
ident_t ident;
scalar_t scalar;
/* Save time stamp and args */
arg_string = time_stamp(argc, argv);
/* Get arguments */
pname = argv[0];
if (ParseArgv(&argc, argv, argTable, 0) || (argc < 2)) {
(void) fprintf(stderr,
"\nUsage: %s [options] [<in1.mnc> ...] <out.mnc>\n",
pname);
(void) fprintf(stderr,
" %s -help\n\n", pname);
exit(EXIT_FAILURE);
}
/* Get output file names */
nout = (Output_list == NULL ? 1 : Output_list_size);
outfiles = malloc(nout * sizeof(*outfiles));
if (Output_list == NULL) {
outfiles[0] = argv[argc-1];
}
else {
for (i=0; i < Output_list_size; i++) {
outfiles[i] = Output_list[i].file;
}
}
/* check for output files */
for (i=0; i < nout; i++){
if(access(outfiles[i], F_OK) == 0 && !clobber){
fprintf(stderr, "%s: %s exists, use -clobber to overwrite\n\n",
argv[0], outfiles[i]);
exit(EXIT_FAILURE);
}
}
/* Get the list of input files either from the command line or
from a file, or report an error if both are specified.
Note that if -outfile is given then there is no output file name
left on argv after option parsing. */
nfiles = argc - 2;
if (Output_list != NULL) nfiles++;
if (filelist == NULL) {
infiles = &argv[1];
}
else if (nfiles <= 0) {
infiles = read_file_names(filelist, &nfiles);
if (infiles == NULL) {
(void) fprintf(stderr,
"Error reading in file names from file \"%s\"\n",
filelist);
exit(EXIT_FAILURE);
}
}
else {
(void) fprintf(stderr,
"Do not specify both -filelist and input file names\n");
exit(EXIT_FAILURE);
}
/* Make sure that we have something to process */
if (nfiles == 0) {
(void) fprintf(stderr, "No input files specified\n");
exit(EXIT_FAILURE);
}
/* Get the expression from the file if needed */
if ((expression == NULL) && (expr_file == NULL)) {
(void) fprintf(stderr,
"An expression must be specified on the command line\n");
exit(EXIT_FAILURE);
}
else if (expression == NULL) {
expression = read_expression_file(expr_file);
}
/* Parse expression argument */
if (debug) fprintf(stderr, "Feeding in expression %s\n", expression);
lex_init(expression);
if (debug) yydebug = 1; else yydebug = 0;
yyparse();
lex_finalize();
/* Optimize the expression tree */
root = optimize(root);
/* Setup the input vector from the input files */
A = new_vector();
for (i=0; i<nfiles; i++) {
if (debug) fprintf(stderr,"Getting file[%d] %s\n", i, argv[i+1]);
scalar = new_scalar(eval_width);
vector_append(A, scalar);
scalar_free(scalar);
}
/* Construct initial symbol table from the A vector. Since setting
a symbol makes a copy, we have to get a handle to that copy. */
rootsym = sym_enter_scope(NULL);
ident = new_ident("A");
sym_set_vector(eval_width, NULL, A, ident, rootsym);
vector_free(A);
A = sym_lookup_vector(ident, rootsym);
if (A==NULL) {
(void) fprintf(stderr, "Error initializing symbol table\n");
exit(EXIT_FAILURE);
}
vector_incr_ref(A);
/* Add output symbols to the table */
if (Output_list == NULL) {
Output_values = NULL;
}
else {
Output_values = malloc(Output_list_size * sizeof(*Output_values));
for (i=0; i < Output_list_size; i++) {
ident = ident_lookup(Output_list[i].symbol);
scalar = new_scalar(eval_width);
sym_set_scalar(eval_width, NULL, scalar, ident, rootsym);
scalar_free(scalar);
Output_values[i] = sym_lookup_scalar(ident, rootsym);
}
}
/* Set default copy_all_header according to number of input files */
if (copy_all_header == DEFAULT_BOOL)
copy_all_header = (nfiles == 1);
if (value_for_illegal_operations == DEFAULT_DBL) {
if (use_nan_for_illegal_values)
value_for_illegal_operations = INVALID_DATA;
else
value_for_illegal_operations = 0.0;
}
/* Do math */
loop_options = create_loop_options();
set_loop_verbose(loop_options, verbose);
set_loop_clobber(loop_options, clobber);
#if MINC2
set_loop_v2format(loop_options, minc2_format);
#endif /* MINC2 */
set_loop_datatype(loop_options, datatype, is_signed,
valid_range[0], valid_range[1]);
set_loop_copy_all_header(loop_options, copy_all_header);
/* only set buffer size if specified */
if(max_buffer_size_in_kb != 0){
set_loop_buffer_size(loop_options, (long) 1024 * max_buffer_size_in_kb);
}
set_loop_check_dim_info(loop_options, check_dim_info);
voxel_loop(nfiles, infiles, nout, outfiles, arg_string, loop_options,
do_math, NULL);
free_loop_options(loop_options);
/* Clean up */
vector_free(A);
sym_leave_scope(rootsym);
if (expr_file != NULL) free(expression);
free(outfiles);
if (Output_list != NULL) free(Output_list);
if (Output_values != NULL) free(Output_values);
exit(EXIT_SUCCESS);
}
