/**
* A function, which prints the full usage text for this program.
*
* @param
* argv0 the argv[0], or the command used to run this program
*
* @return This function always returns zero (0).
*/
int print_usage (const char *argv0) {
print_short_usage(argv0);
std::cout << "For the list of available parameter values\n"
"and additional options, run: " <<
argv0 << " -h\n";
return (0);
}
/**
* A function, which prints the help text for this program.
*
* @param
* argv0 the argv[0], or the command used to run this program
*
* @return This function always returns zero (0).
*/
int print_help (const char *argv0) {
print_short_usage(argv0);
std::cout << "Additional options:\n"
"-e <file_encoding>\tSpecifies the character encoding\n"
"\t\t\tof the input file 'filename'. The default value\n"
"\t\t\tis UTF-8. The valid encodings are all those\n"
"\t\t\tsupported by the iconv.\n"
"-v\t\t\tDisplays the number of character occurrences.\n";
return (0);
}
int main(int argc, char *argv[]) {
board_t *board = NULL;
int ret = 0;
encoder_module_t enc;
if (argc == 1) {
print_short_usage();
return 0;
}
if (process_cmd_line(argc, argv) == -1) {
return -1;
}
board_access.verbose = verbose_flag;
if (anyio_init(&board_access) != 0) { // init library
return -1;
}
ret = anyio_find_dev(&board_access); // find board
if (ret < 0) {
return -1;
}
board = anyio_get_dev(&board_access, 1); // if found the get board handle
if (board == NULL) {
printf("No %s board found\n", board_access.device_name);
return -1;
}
board->open(board); // open board for communication
board->print_info(board); // print what card it is
hm2_read_idrom(&(board->llio.hm2)); // read hostmot2 idrom
ret = encoder_init(&enc, board, instance, delay); // init encoder 'instance' module on 'board'
if (ret < 0) {
goto fail0;
}
while (1) {
encoder_read(&enc); // read encoder
printf("tsc = %u, raw_counts = %u, velocity = %.2f\n", enc.global_time_stamp, enc.raw_counts, enc.velocity);
usleep(delay*1000); // wait delay ms
}
encoder_cleanup(&enc); // cleanup enocder module
fail0:
board->close(board); // close board communication
anyio_cleanup(&board_access); // close library
return 0;
}
/**
* A function, which prints the help text for this program.
*
* @param
* argv0 the argv[0], or the command used to run this program
*
* @return This function always returns zero (0).
*/
int print_help (const char *argv0) {
print_short_usage(argv0);
std::cout << "The probability distribution can be specified\n"
"in the following ways:\n\n"
"-a <alphabet>\tThe output characters will be picked\n"
"\t\tfrom the specified alphabet\n"
"\t\tusing the uniform distribution.\n"
"\t\tThe 'alphabet' is a string representing\n"
"\t\tthe alphabet to be used.\n"
"\t\tFor example, 'abcdefghijklmnopqrstuvwxyz'\n"
"\t\tis a string representing the alphabet\n"
"\t\tconsisting of all the small English letters.\n"
"-s <alphabet_size>\tThe output characters will be picked\n"
"\t\t\tfrom the part of the Unicode starting\n"
"\t\t\tat the character 0x0100 and spanning\n"
"\t\t\t'alphabet_size' characters\n"
"\t\t\tusing the uniform distribution.\n"
"-f <ifname>\tThe output characters will be picked\n"
"\t\tfrom the input file 'ifname'\n"
"\t\tusing the uniform distribution.\n\n"
"Additional options:\n\n"
"-g <generator>\tSpecifies the desired pseudorandom\n"
"\t\tnumber generator (PRNG) to use.\n"
"\t\tThe available values are:\n"
"\t\tM\tMersenne twister\n"
"\t\tR\trandom() function\n"
"\t\tU\t/dev/urandom system file\n"
"\t\tThe default PRNG is the Mersenne twister.\n"
"-i <file_encoding>\tSpecifies the character encoding\n"
"\t\t\tof either the input alphabet string\n"
"\t\t\tor the input file.\n"
"\t\t\tThe default value is UTF-8.\n"
"\t\t\tThe valid encodings are all those\n"
"\t\t\tsupported by the iconv.\n"
"-e <file_encoding>\tSpecifies the character encoding\n"
"\t\t\tof the output file 'filename'.\n"
"\t\t\tThe default value is UTF-8.\n"
"\t\t\tThe valid encodings are all those\n"
"\t\t\tsupported by the iconv.\n"
"-v\t\tMakes the output more verbose.\n";
return (0);
}
/**
* A function, which prints the full usage text for this program.
*
* @param
* argv0 the argv[0], or the command used to run this program
*
* @return This function always returns zero (0).
*/
int print_usage (const char *argv0) {
print_short_usage(argv0);
std::cout << "For the list of additional options, run: " <<
argv0 << " -h\n";
return (0);
}
int main(int argc, char *argv[]) {
int ret = 0;
if (argc == 1) {
print_short_usage();
return 0;
}
if (process_cmd_line(argc, argv) == -1)
return -1;
if (info_flag == 1) {
anyio_bitfile_print_info(bitfile_name, 1);
} else if (device_flag == 1) {
board_t *board = NULL;
access.verbose = verbose_flag;
access.recover = recover_flag;
access.address = addr_flag;
if (anyio_init(&access) != 0)
exit(1);
ret = anyio_find_dev(&access);
if (ret < 0) {
return -1;
}
board = anyio_get_dev(&access, 1);
if (board == NULL) {
printf("No %s board found\n", access.device_name);
return -1;
}
board->open(board);
if (readhmid_flag == 1) {
anyio_dev_print_hm2_info(board, xml_flag);
} else if (sserial_flag == 1) {
anyio_dev_print_sserial_info(board);
} else if (rpo_flag == 1) {
u32 data;
board->llio.read(&(board->llio), rpo_addr, &data, sizeof(u32));
printf("%08X\n", data);
} else if (wpo_flag == 1) {
board->llio.write(&(board->llio), wpo_addr, &wpo_data, sizeof(u32));
} else if (set_flag == 1) {
ret = anyio_dev_set_remote_ip(board, lbp16_set_ip_addr);
} else if (write_flag == 1) {
ret = anyio_dev_write_flash(board, bitfile_name, fallback_flag);
if (reload_flag == 1) {
ret = anyio_dev_reload(board, fallback_flag);
if (ret == -1) {
printf("\nYou must power cycle the hardware to load a new firmware.\n");
}
} else {
printf("\nYou must power cycle the hardware or use the --reload command to load a new firmware.\n");
}
} else if (verify_flag == 1) {
ret = anyio_dev_verify_flash(board, bitfile_name, fallback_flag);
} else if (program_flag == 1) {
ret = anyio_dev_program_fpga(board, bitfile_name);
} else if (reload_flag == 1) {
anyio_dev_reload(board, fallback_flag);
} else if (reset_flag == 1) {
anyio_dev_reset(board);
} else {
board->print_info(board);
}
board->close(board);
anyio_cleanup(&access);
} else {
printf("No action requested. Please specify at least --device or --info.\n");
}
return ret;
}
int main(int argc, char **argv)
{
int c;
char *input_file_name = NULL;
char *output_file_name = NULL;
char *output_basename = NULL;
char *error_file_name = NULL;
FILE *input_file = NULL;
FILE *output_file = NULL;
FILE *error_file = NULL;
gregorio_file_format input_format = FORMAT_UNSET;
gregorio_file_format output_format = FORMAT_UNSET;
gregorio_verbosity verb_mode = 0;
bool point_and_click = false;
char *point_and_click_filename = NULL;
bool debug = false;
bool must_print_short_usage = false;
int option_index = 0;
static struct option long_options[] = {
{"output-file", 1, 0, 'o'},
{"stdout", 0, 0, 'S'},
{"output-format", 1, 0, 'F'},
{"messages-file", 1, 0, 'l'},
{"input-format", 1, 0, 'f'},
{"stdin", 0, 0, 's'},
{"help", 0, 0, 'h'},
{"version", 0, 0, 'V'},
{"licence", 0, 0, 'L'},
{"verbose", 0, 0, 'v'},
{"all-warnings", 0, 0, 'W'},
{"point-and-click", 0, 0, 'p'},
{"debug", 0, 0, 'd'},
};
gregorio_score *score = NULL;
gregorio_support_init("gregorio", argv[0]);
if (argc == 1) {
fprintf(stderr, "%s: missing file operand.\n", argv[0]);
print_short_usage(argv[0]);
gregorio_exit(0);
}
setlocale(LC_CTYPE, "C");
while (1) {
c = getopt_long(argc, argv, "o:SF:l:f:shOLVvWpd",
long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'o':
if (output_file_name) {
fprintf(stderr,
"warning: several output files declared, %s taken\n",
output_file_name);
must_print_short_usage = true;
break;
}
if (output_file) { /* means that stdout is defined */
fprintf(stderr,
"warning: can't write to file and stdout, writing on stdout\n");
must_print_short_usage = true;
break;
}
output_file_name = optarg;
break;
case 'S':
if (output_file_name) {
fprintf(stderr,
"warning: can't write to file and stdout, writing on %s\n",
output_file_name);
must_print_short_usage = true;
break;
}
if (output_file) { /* means that stdout is defined */
fprintf(stderr, "warning: option used several times: %c\n", c);
must_print_short_usage = true;
break;
}
output_file = stdout;
break;
case 'F':
if (output_format) {
fprintf(stderr,
"warning: several output formats declared, first taken\n");
must_print_short_usage = true;
break;
}
if (!strcmp(optarg, GABC_STR)) {
output_format = GABC;
break;
}
if (!strcmp(optarg, GTEX_STR)) {
output_format = GTEX;
break;
}
if (!strcmp(optarg, DUMP_STR)) {
output_format = DUMP;
break;
} else {
fprintf(stderr, "error: unknown output format: %s\n", optarg);
print_short_usage(argv[0]);
gregorio_exit(1);
}
break;
case 'l':
if (error_file_name) {
fprintf(stderr,
"warning: several error files declared, %s taken\n",
error_file_name);
must_print_short_usage = true;
break;
}
error_file_name = optarg;
break;
case 'f':
if (input_format) {
gregorio_set_error_out(error_file);
fprintf(stderr,
"warning: several output formats declared, first taken\n");
must_print_short_usage = true;
break;
}
if (!strcmp(optarg, GABC_STR)) {
input_format = GABC;
break;
} else {
fprintf(stderr, "error: unknown input format: %s\n", optarg);
print_short_usage(argv[0]);
gregorio_exit(1);
}
break;
case 's':
/* input_file_name will be null here because of the way
* we use getopt_long */
assert(!input_file_name);
if (input_file) { /* means that stdin is defined */
fprintf(stderr, "warning: option used several times: %c\n", c);
must_print_short_usage = true;
break;
}
input_file = stdin;
break;
case 'h':
print_usage(argv[0]);
gregorio_exit(0);
break;
case 'V':
gregorio_print_version(copyright);
gregorio_exit(0);
break;
case 'v':
if (verb_mode && verb_mode != VERBOSITY_WARNING) {
fprintf(stderr, "warning: verbose option passed several times\n");
must_print_short_usage = true;
break;
}
verb_mode = VERBOSITY_INFO;
break;
case 'W':
if (verb_mode == VERBOSITY_WARNING) {
fprintf(stderr,
"warning: all-warnings option passed several times\n");
must_print_short_usage = true;
break;
}
if (verb_mode != VERBOSITY_INFO) {
verb_mode = VERBOSITY_WARNING;
}
break;
case 'L':
print_licence();
gregorio_exit(0);
break;
case 'p':
if (point_and_click) {
fprintf(stderr,
"warning: point-and-click option passed several times\n");
must_print_short_usage = true;
break;
}
point_and_click = true;
break;
case 'd':
if (debug) {
fprintf(stderr,
"warning: debug option passed several times\n");
must_print_short_usage = true;
break;
}
debug = true;
break;
case '?':
must_print_short_usage = true;
break;
default:
/* not reachable unless there's a programming error */
/* LCOV_EXCL_START */
gregorio_fail2(main, "unknown option: %c", c);
print_short_usage(argv[0]);
gregorio_exit(1);
break;
/* LCOV_EXCL_STOP */
}
} /* end of while */
if (optind == argc) {
if (!input_file) { /* input not undefined (could be stdin) */
fprintf(stderr, "%s: missing file operand.\n", argv[0]);
print_short_usage(argv[0]);
gregorio_exit(1);
}
} else {
input_file_name = argv[optind++];
output_basename = get_base_filename(input_file_name);
if (input_file) {
fprintf(stderr,
"warning: can't read from both stdin and a file, reading from %s\n",
input_file_name);
input_file = NULL;
must_print_short_usage = true;
}
}
if (optind < argc) {
must_print_short_usage = true;
fprintf(stderr, "ignored arguments:");
for (; optind < argc; ++optind) {
fprintf(stderr, " %s", argv[optind]);
}
fprintf(stderr, "\n");
}
if (must_print_short_usage) {
print_short_usage(argv[0]);
fprintf(stderr, "Proceeding anyway...\n");
}
gregorio_set_debug_messages(debug);
if (!input_format) {
input_format = DEFAULT_INPUT_FORMAT;
}
if (!output_format) {
output_format = DEFAULT_OUTPUT_FORMAT;
}
/* then we act... */
if (!output_file_name && !output_file) {
if (!output_basename) {
output_file = stdout;
} else {
switch (output_format) {
case GABC:
output_file_name =
get_output_filename(output_basename, "gabc");
break;
case GTEX:
output_file_name =
get_output_filename(output_basename, "gtex");
break;
case DUMP:
output_file_name =
get_output_filename(output_basename, "dump");
break;
default:
/* not reachable unless there's a programming error */
/* LCOV_EXCL_START */
fprintf(stderr, "error: unsupported format");
print_short_usage(argv[0]);
gregorio_exit(1);
/* LCOV_EXCL_STOP */
}
}
}
if (output_basename) {
free(output_basename);
}
if (!output_file) {
if (!input_file) {
check_input_clobber(input_file_name, output_file_name);
}
gregorio_check_file_access(write, output_file_name, ERROR,
gregorio_exit(1));
output_file = fopen(output_file_name, "wb");
if (!output_file) {
fprintf(stderr, "error: can't write in file %s", output_file_name);
gregorio_exit(1);
}
}
/* we always have input_file or input_file_name */
if (input_file) {
if (point_and_click) {
fprintf(stderr,
"warning: disabling point-and-click since reading from stdin\n");
}
} else {
gregorio_check_file_access(read, input_file_name, ERROR,
gregorio_exit(1));
input_file = fopen(input_file_name, "r");
if (!input_file) {
fprintf(stderr, "error: can't open file %s for reading\n",
input_file_name);
gregorio_exit(1);
}
if (point_and_click) {
point_and_click_filename = encode_point_and_click_filename(
input_file_name);
}
}
if (!error_file_name) {
error_file = stderr;
gregorio_set_error_out(error_file);
} else {
gregorio_check_file_access(write, error_file_name, ERROR,
gregorio_exit(1));
error_file = fopen(error_file_name, "wb");
if (!error_file) {
fprintf(stderr, "error: can't open file %s for writing\n",
error_file_name);
gregorio_exit(1);
}
gregorio_set_error_out(error_file);
}
if (!verb_mode) {
verb_mode = VERBOSITY_DEPRECATION;
}
gregorio_set_verbosity_mode(verb_mode);
switch (input_format) {
case GABC:
score = gabc_read_score(input_file);
break;
default:
/* not reachable unless there's a programming error */
/* LCOV_EXCL_START */
fprintf(stderr, "error : invalid input format\n");
fclose(input_file);
fclose(output_file);
gregorio_exit(1);
break;
/* LCOV_EXCL_STOP */
}
fclose(input_file);
if (score == NULL) {
/* score should never be NULL on return from gabc_read_score */
/* LCOV_EXCL_START */
fclose(output_file);
fprintf(stderr, "error in file parsing\n");
gregorio_exit(1);
/* LCOV_EXCL_STOP */
}
switch (output_format) {
case GABC:
gabc_write_score(output_file, score);
break;
case GTEX:
gregoriotex_write_score(output_file, score, point_and_click_filename);
break;
case DUMP:
dump_write_score(output_file, score);
break;
default:
/* not reachable unless there's a programming error */
/* LCOV_EXCL_START */
fprintf(stderr, "error : invalid output format\n");
gregorio_free_score(score);
fclose(output_file);
gregorio_exit(1);
break;
/* LCOV_EXCL_STOP */
}
fclose(output_file);
if (point_and_click_filename) {
free(point_and_click_filename);
}
gregorio_free_score(score);
gregorio_vowel_tables_free();
gabc_score_determination_lex_destroy();
gabc_notes_determination_lex_destroy();
gregorio_vowel_rulefile_lex_destroy();
if (error_file_name) {
fclose(error_file);
}
gregorio_exit(gregorio_get_return_value());
} /* due to exit on prior line, this will never be reached; LCOV_EXCL_LINE */
