int main(int argc, char* argv[])
{
// setup help & options
optparse::OptionParser parser;
parser.description("bam2sam converts a BAM file to SAM. It is essentially a stripped-down "
"'samtools view', mostly useful for testing/debugging without requiring samtools. "
"Input BAM file is read from a file or stdin, and SAM output is written to stdout."
);
parser.prog("bam2sam");
parser.usage("bam2sam [options] [input]");
parser.version(bam2sam::Version);
parser.add_version_option(true);
parser.add_help_option(true);
auto optionGroup = optparse::OptionGroup(parser, "Options");
optionGroup.add_option("")
.dest("input")
.metavar("input")
.help("Input BAM file. If not provided, stdin will be used as input.");
optionGroup.add_option("--no-header")
.dest("no_header")
.action("store_true")
.help("Omit header from output.");
optionGroup.add_option("--header-only")
.dest("header_only")
.action("store_true")
.help("Print only the header (no records).");
parser.add_option_group(optionGroup);
// parse command line for settings
const bam2sam::Settings settings = fromCommandLine(parser, argc, argv);
if (!settings.errors_.empty()) {
std::cerr << std::endl;
for (const auto e : settings.errors_)
std::cerr << "ERROR: " << e << std::endl;
std::cerr << std::endl;
parser.print_help();
return EXIT_FAILURE;
}
// run tool
try {
bam2sam::PbBam2Sam::Run(settings);
return EXIT_SUCCESS;
}
catch (std::exception& e) {
std::cerr << "ERROR: " << e.what() << std::endl;
return EXIT_FAILURE;
}
}
/** evaluates command line parameters and runs GCG appropriately in the given SCIP instance */
static
SCIP_RETCODE SCIPprocessGCGShellArguments(
SCIP* scip, /**< SCIP data structure */
int argc, /**< number of shell parameters */
char** argv, /**< array with shell parameters */
const char* defaultsetname /**< name of default settings file */
)
{ /*lint --e{850}*/
char* probname = NULL;
char* decname = NULL;
char* settingsname = NULL;
char* mastersetname = NULL;
char* logname = NULL;
SCIP_Bool quiet;
SCIP_Bool paramerror;
SCIP_Bool interactive;
int i;
/********************
* Parse parameters *
********************/
quiet = FALSE;
paramerror = FALSE;
interactive = FALSE;
for( i = 1; i < argc; ++i )
{
if( strcmp(argv[i], "-l") == 0 )
{
i++;
if( i < argc )
logname = argv[i];
else
{
SCIPinfoMessage(scip, NULL, "missing log filename after parameter '-l'\n");
paramerror = TRUE;
}
}
else if( strcmp(argv[i], "-q") == 0 )
quiet = TRUE;
else if( strcmp(argv[i], "-s") == 0 )
{
i++;
if( i < argc )
settingsname = argv[i];
else
{
SCIPinfoMessage(scip, NULL, "missing settings filename after parameter '-s'\n");
paramerror = TRUE;
}
}
else if( strcmp(argv[i], "-m") == 0 )
{
i++;
if( i < argc )
mastersetname = argv[i];
else
{
SCIPinfoMessage(scip, NULL, "missing master settings filename after parameter '-m'\n");
paramerror = TRUE;
}
}
else if( strcmp(argv[i], "-f") == 0 )
{
i++;
if( i < argc )
probname = argv[i];
else
{
SCIPinfoMessage(scip, NULL, "missing problem filename after parameter '-f'\n");
paramerror = TRUE;
}
}
else if( strcmp(argv[i], "-d") == 0 )
{
i++;
if( i < argc )
decname = argv[i];
else
{
SCIPinfoMessage(scip, NULL, "missing decomposition filename after parameter '-d'\n");
paramerror = TRUE;
}
}
else if( strcmp(argv[i], "-c") == 0 )
{
i++;
if( i < argc )
{
SCIP_CALL( SCIPaddDialogInputLine(scip, argv[i]) );
interactive = TRUE;
}
else
{
SCIPinfoMessage(scip, NULL, "missing command line after parameter '-c'\n");
paramerror = TRUE;
}
}
else if( strcmp(argv[i], "-b") == 0 )
{
i++;
if( i < argc )
{
SCIP_FILE* file;
file = SCIPfopen(argv[i], "r");
if( file == NULL )
{
SCIPinfoMessage(scip, NULL, "cannot read command batch file <%s>\n", argv[i]);
SCIPprintSysError(argv[i]);
paramerror = TRUE;
}
else
{
while( !SCIPfeof(file) )
{
char buffer[SCIP_MAXSTRLEN];
(void)SCIPfgets(buffer, sizeof(buffer), file);
if( buffer[0] != '\0' )
{
SCIP_CALL( SCIPaddDialogInputLine(scip, buffer) );
}
}
SCIPfclose(file);
interactive = TRUE;
}
}
else
{
SCIPinfoMessage(scip, NULL, "missing command batch filename after parameter '-b'\n");
paramerror = TRUE;
}
}
else
{
SCIPinfoMessage(scip, NULL, "invalid parameter <%s>\n", argv[i]);
paramerror = TRUE;
}
}
if( interactive && probname != NULL )
{
SCIPinfoMessage(scip, NULL, "cannot mix batch mode '-c' and '-b' with file mode '-f'\n");
paramerror = TRUE;
}
if( probname == NULL && decname != NULL )
{
SCIPinfoMessage(scip, NULL, "cannot read decomposition file without given problem\n");
paramerror = TRUE;
}
if( !paramerror )
{
/***********************************
* create log file message handler *
***********************************/
if( quiet )
{
SCIPsetMessagehdlrQuiet(scip, quiet);
}
if( logname != NULL )
{
SCIPsetMessagehdlrLogfile(scip, logname);
}
/***********************************
* Version and library information *
***********************************/
SCIPprintVersion(scip, NULL);
SCIPinfoMessage(scip, NULL, "\n");
SCIPprintExternalCodes(scip, NULL);
SCIPinfoMessage(scip, NULL, "\n");
/*****************
* Load settings *
*****************/
if( settingsname != NULL )
{
SCIP_CALL( readParams(scip, settingsname) );
}
else if( defaultsetname != NULL )
{
SCIP_CALL( readParams(scip, defaultsetname) );
}
if( mastersetname != NULL )
{
SCIP_CALL( readParams(GCGrelaxGetMasterprob(scip), mastersetname) );
}
/**************
* Start SCIP *
**************/
if( probname != NULL )
{
SCIP_CALL( fromCommandLine(scip, probname, decname) );
}
else
{
SCIPinfoMessage(scip, NULL, "\n");
SCIP_CALL( SCIPstartInteraction(scip) );
}
}
else
{
SCIPinfoMessage(scip, NULL, "\nsyntax: %s [-l <logfile>] [-q] [-s <settings>] [-f <problem>] [-m <mastersettings>] [-d <decomposition>] [-b <batchfile>] [-c \"command\"]\n"
" -l <logfile> : copy output into log file\n"
" -q : suppress screen messages\n"
" -s <settings> : load parameter settings (.set) file\n"
" -m <mastersettings> : load master parameter settings (.set) file\n"
" -f <problem> : load and solve problem file\n"
" -d <decomposition> : load decomposition file\n"
" -b <batchfile> : load and execute dialog command batch file (can be used multiple times)\n"
" -c \"command\" : execute single line of dialog commands (can be used multiple times)\n\n",
argv[0]);
}
return SCIP_OKAY;
}
/** creates a SCIP instance with default plugins, evaluates command line parameters, runs SCIP appropriately,
* and frees the SCIP instance
*/
static
SCIP_RETCODE runSCIP(
int argc, /**< number of shell parameters */
char** argv /**< array with shell parameters */
)
{
SCIP* scip = NULL;
/*********
* Setup *
*********/
/* initialize SCIP */
SCIP_CALL( SCIPcreate(&scip) );
/***********************
* Version information *
***********************/
SCIPprintVersion(scip, NULL);
std::cout << std::endl;
/* include default SCIP plugins */
SCIP_CALL( SCIPincludeDefaultPlugins(scip) );
/**************
* Parameters *
**************/
if( argc >= 3 )
{
SCIP_CALL( readParams(scip, argv[2]) );
}
else
{
SCIP_CALL( readParams(scip, NULL) );
}
/*CHECK_OKAY( SCIPwriteParams(scip, "scipmip.set", TRUE) );*/
/**************
* Start SCIP *
**************/
if( argc >= 2 )
{
SCIP_CALL( fromCommandLine(scip, argv[1]) );
}
else
{
printf("\n");
SCIP_CALL( interactive(scip) );
}
/********************
* Deinitialization *
********************/
SCIP_CALL( SCIPfree(&scip) );
BMScheckEmptyMemory();
return SCIP_OKAY;
}
