rc_t CC KMain ( int argc, char *argv [] ) { rc_t rc = 0; Args * args; rc = ArgsMakeAndHandle (&args, argc, argv, 0); if (rc == 0) { do { uint32_t pcount; rc = ArgsParamCount (args, &pcount); if (rc) break; if (pcount == 0) { MiniUsage(args); rc = RC(rcExe, rcNoTarg, rcAllocating, rcParam, rcInvalid); } else { const char * pc; rc_t exp; uint32_t ix; /* over rule any set log level */ rc = KLogLevelSet (klogInfo); for (ix = 0; ix < pcount; ++ix) { rc = ArgsParamValue (args, ix, (const void **)&pc); if (rc) break; exp = AsciiToU32 (pc, NULL, NULL); rc = LOGERR (klogInfo, exp, pc); } } } while (0); ArgsWhack (args); } return rc; }
rc_t CC KMain ( int argc, char *argv [] ) { Args * args; rc_t rc; rc = ArgsMakeAndHandle (&args, argc, argv, 1, Options, sizeof (Options) / sizeof (OptDef)); if (rc == 0) { do { uint32_t pcount; rc = ArgsOptionCount (args, OPTION_FORCE, &pcount); if (rc) break; force = (pcount > 0); rc = ArgsOptionCount (args, OPTION_RECURSE, &pcount); if (rc) break; recurse = (pcount > 0); rc = ArgsOptionCount (args, OPTION_TEST, &pcount); if (rc) break; test = (pcount > 0); rc = ArgsOptionCount (args, OPTION_PRESERVE, &pcount); if (rc) break; clobber_protections = (pcount > 0); rc = run (args); }while (0); ArgsWhack (args); } return rc; }
rc_t CC KMain ( int argc, char *argv [] ) { Args * args; rc_t rc = ArgsMakeAndHandle ( &args, argc, argv, 1, CompressOptions, sizeof ( CompressOptions ) / sizeof ( OptDef ) ); if ( rc == 0 ) { /* rc = compress_main( args ); */ rc = copy2_main( args ); ArgsWhack ( args ); } else OUTMSG( ( "ArgsMakeAndHandle() failed %R\n", rc ) ); return rc; }
rc_t CC KMain ( int argc, char *argv [] ) { Args * args; rc_t rc = ArgsMakeAndHandle ( &args, argc, argv, 0 ); KLogHandlerSetStdErr(); if ( rc != 0 ) { LOGERR( klogErr, rc, "error creating internal structure" ); } else { uint32_t count; rc = ArgsParamCount( args, &count ); if ( rc != 0 ) LOGERR( klogErr, rc, "ArgsParamCount failed" ); else { if ( count < 1 ) { rc = RC( rcExe, rcNoTarg, rcAllocating, rcParam, rcInvalid ); LOGERR( klogErr, rc, "object(s) missing" ); Usage ( args ); } else { uint32_t idx; for ( idx = 0; idx < count && rc == 0; ++idx ) { const char *obj; rc = ArgsParamValue( args, idx, (const void **)&obj ); if ( rc != 0 ) LOGERR( klogErr, rc, "error reading commandline-parameter" ); else rc = correct( obj ); /* ** <<<<<<<<<<<<<<<<<< ** */ } } } ArgsWhack ( args ); } return rc; }
rc_t CC KMain ( int argc, char *argv [] ) { Args * args; uint32_t num_options = sizeof ToolOptions / sizeof ToolOptions [ 0 ]; rc_t rc = ArgsMakeAndHandle ( &args, argc, argv, 1, ToolOptions, num_options ); if ( rc != 0 ) ErrMsg( "ArgsMakeAndHandle() -> %R", rc ); if ( rc == 0 ) { uint32_t param_count; rc = ArgsParamCount( args, ¶m_count ); if ( rc != 0 ) ErrMsg( "ArgsParamCount() -> %R", rc ); else { if ( param_count == 0 || param_count > 1 ) rc = Usage ( args ); else { tool_ctx_t tool_ctx; rc = populate_tool_ctx( &tool_ctx, args ); /* above */ if ( rc == 0 ) { if ( !( tool_ctx . force ) && file_exists( tool_ctx . dir, "%s", tool_ctx . output_filename ) ) /* helper.c */ { rc = RC( rcExe, rcFile, rcPacking, rcName, rcExists ); ErrMsg( "creating ouput-file '%s' -> %R", tool_ctx . output_filename, rc ); } else { rc = perform_tool( &tool_ctx ); /* above */ } KDirectoryRelease( tool_ctx . dir ); destroy_temp_dir( tool_ctx . temp_dir ); /* temp_dir.c */ } } } } return rc; }
/*************************************************************************** Main: * create the copy-context * parse the commandline for arguments and options * react to help/usage - requests ( no dump in this case ) these functions are in vdb-copy-context.c * call copy_main() to execute the copy-operation * destroy the copy-context ***************************************************************************/ rc_t CC KMain ( int argc, char *argv [] ) { Args * args; rc_t rc = ArgsMakeAndHandle ( &args, argc, argv, 1, MyOptions, sizeof MyOptions / sizeof ( OptDef ) ); if ( rc != 0 ) { LOGERR( klogErr, rc, "ArgsMakeAndHandle() failed" ); } else { context *ctx; KLogHandlerSetStdErr(); rc = context_init( &ctx ); if ( rc != 0 ) { LOGERR( klogInt, rc, "KMain:context_init() failed" ); } else { rc = context_capture_arguments_and_options( args, ctx ); if ( rc != 0 ) { MiniUsage( args ); if ( argc < 2 ) rc = 0; } else { if ( ctx->usage_requested ) MiniUsage( args ); else rc = ref_seq_load_main( ctx ); /* <====================== */ } context_destroy( ctx ); } ArgsWhack ( args ); } return rc; }
rc_t CC KMain ( int argc, char *argv [] ) { Args * args; rc_t rc; rc = ArgsMakeAndHandle ( &args, argc, argv, 1, NULL, 0 ); if ( rc == 0 ) { rc = call_zlib(); OUTMSG (( "calling zlib : %R\n", rc )); rc = call_bz2(); OUTMSG (( "calling bz2 : %R\n", rc )); ArgsWhack ( args ); } else OUTMSG( ( "ArgsMakeAndHandle() failed %R\n", rc ) ); return rc; }
rc_t CC KMain ( int argc, char *argv [] ) { Args * args; rc_t rc = ArgsMakeAndHandle ( &args, argc, argv, 1, sra_seq_count_options, ( sizeof sra_seq_count_options / sizeof sra_seq_count_options [ 0 ] ) ); if ( rc == 0 ) { struct sra_seq_count_options options; rc = gather_options( args, &options ); if ( rc == 0 && options.valid ) { rc = report_options( &options ); if ( rc == 0 ) { rc = matching( &options ); /* here we are calling into C++ */ } } ArgsWhack ( args ); } return rc; }
rc_t CC KMain ( int argc, char *argv [] ) { Args * args; rc_t rc; rc = ArgsMakeAndHandle (&args, argc, argv, 0); if (rc == 0) { rc = run(); if (rc) LOGERR (klogErr, rc, "Exiting failure"); else STSMSG (0, ("Exiting okay\n")); } if (rc) LOGERR (klogErr, rc, "Exiting status"); else STSMSG (0, ("Existing status (%R)\n", rc)); return rc; }
rc_t CC KMain ( int argc, char *argv [] ) { rc_t rc = 0; Args * args; rc = ArgsMakeAndHandle (&args, argc, argv, 0); if (rc == 0) { uint32_t i; char temp[ 32 ]; OUTMSG( ( "Tests the printout of some float-values:\n" ) ); for ( i = 0; i < NFLOATS; ++i ) { double x = fvalues[i]; sprintf( temp, "%e", fvalues[i] ); OUTMSG(( "via sprintf: %s | via OUTMSG: %e\n", temp, x )); } } return rc; }
rc_t CC KMain ( int argc, char *argv [] ) { Args * args; rc_t rc; rc = ArgsMakeAndHandle (&args, argc, argv, 0); if (rc == 0) { STSMSG (3, ("Starting tests",__func__)); error_count = 0; rc = run(); } if (error_count) STSMSG (0, ("Failed %d tests of %d run out of 28 possible",error_count, test_count)); else STSMSG (0, ("Passed %d tests out of 28 possible\n", test_count)); if (rc) LOGERR (klogErr, rc, "Exiting with a failure status"); exit (error_count); }
rc_t CC KMain ( int argc, char *argv [] ) { Args * args; rc_t rc; rc = ArgsMakeAndHandle (&args, argc, argv, 0); if (rc == 0) { rc = run(); ArgsRelease (args); } if (rc == 0 && num_errors != 0) { rc = RC(rcKrypto, rcBuffer, rcValidating, rcEncryption, rcIncorrect); } if (rc) LOGERR (klogErr, rc, "Exiting status"); else STSMSG (0, ("Exiting okay\n")); return rc; }
rc_t CC KMain( int argc, char *argv [] ) { Args * args; rc_t rc = ArgsMakeAndHandle( &args, argc, argv, 1, options, sizeof options / sizeof options [ 0 ] ); if ( rc == 0 ) { try { NGS_Pileup::Settings settings; uint32_t pcount; rc = ArgsOptionCount ( args, OPTION_REF, &pcount ); if ( pcount > 1 ) { throw ngs :: ErrorMsg ( "multiple positions are not supported at this point" ); } if ( pcount == 1 ) { const void * value; rc = ArgsOptionValue ( args, OPTION_REF, 0, & value ); if ( rc != 0 ) { throw ngs :: ErrorMsg ( "ArgsOptionValue (" OPTION_REF ") failed" ); } settings . AddReference ( static_cast <char const*> (value) ); } rc = ArgsParamCount ( args, &pcount ); if ( rc == 0 ) { if ( pcount > 1 ) { throw ngs :: ErrorMsg ( "multiple accessions are not supported at this point" ); } settings . output = & std::cout; void const *value; rc = ArgsParamValue ( args, 0, &value ); if ( rc == 0 ) { settings . AddInput ( static_cast <char const*> (value) ); NGS_Pileup ( settings ) . Run (); } else { throw ngs :: ErrorMsg ( "ArgsParamValue failed" ); } } } catch (ngs :: ErrorMsg& ex) { std :: cerr << "Program aborted: " << ex.what() << std::endl; exit ( -1 ); } ArgsWhack( args ); } return 0; }
rc_t CC KMain (int argc, char * argv[]) { Args * args; uint32_t pcount; rc_t rc = ArgsMakeAndHandle (&args, argc, argv, 1, Options, sizeof Options / sizeof (OptDef)); if ( rc == 0 ) { rc = ArgsParamCount (args, &pcount); if ( rc == 0 ) { if ( pcount != 0 ) { rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcExcessive); MiniUsage (args); } else { const KStream *std_in; rc = KStreamMakeStdIn ( & std_in ); if ( rc == 0 ) { KStream* buffered; rc = KStreamMakeBuffered ( &buffered, std_in, 0 /*input-only*/, 0 /*use default size*/ ); if ( rc == 0 ) { GeneralLoader loader ( *buffered ); rc = ArgsOptionCount (args, OPTION_INCLUDE_PATHS, &pcount); if ( rc == 0 ) { for ( uint32_t i = 0 ; i < pcount; ++i ) { const char* value; rc = ArgsOptionValue (args, OPTION_INCLUDE_PATHS, i, &value); if ( rc != 0 ) { break; } loader . AddSchemaIncludePath ( value ); } } rc = ArgsOptionCount (args, OPTION_SCHEMAS, &pcount); if ( rc == 0 ) { for ( uint32_t i = 0 ; i < pcount; ++i ) { const char* value; rc = ArgsOptionValue (args, OPTION_SCHEMAS, i, &value); if ( rc != 0 ) { break; } loader . AddSchemaFile( value ); } } rc = ArgsOptionCount (args, OPTION_TARGET, &pcount); if ( rc == 0 && pcount == 1 ) { const char* value; rc = ArgsOptionValue (args, OPTION_TARGET, 0, &value); if ( rc == 0 ) { loader . SetTargetOverride ( value ); } } if ( rc == 0 ) { rc = loader . Run(); } KStreamRelease ( buffered ); } KStreamRelease ( std_in ); } } } } if ( rc != 0) { LOGERR ( klogErr, rc, "load failed" ); } ArgsWhack(args); return rc; }
rc_t CC KMain(int argc, char* argv[]) { rc_t rc = 0; Args* args = NULL; Params prm; memset(&prm, 0, sizeof prm); do { uint32_t pcount = 0; rc = ArgsMakeAndHandle(&args, argc, argv, 1, Options, sizeof Options / sizeof (OptDef)); if (rc) { LOGERR(klogErr, rc, "While calling ArgsMakeAndHandle"); break; } rc = ArgsParamCount(args, &pcount); if (rc) { LOGERR(klogErr, rc, "While calling ArgsParamCount"); break; } if (pcount < 1) { MiniUsage(args); DESTRUCT(Args, args); exit(1); break; } if (pcount > 1) { rc = RC(rcExe, rcArgv, rcParsing, rcParam, rcAmbiguous); LOGERR(klogErr, rc, "Too many database parameters"); break; } rc = ArgsParamValue(args, 0, &prm.dbPath); if (rc) { LOGERR(klogErr, rc, "Failure retrieving database name"); break; } rc = ArgsOptionCount (args, OPTION_ALL, &pcount); if (rc) { LOGERR(klogErr, rc, "Failure to get '" OPTION_ALL "' argument"); break; } if (pcount) { prm.paramBamHeader = prm.paramQuality = prm.paramRef = true; } rc = ArgsOptionCount (args, OPTION_BAM, &pcount); if (rc) { LOGERR(klogErr, rc, "Failure to get '" OPTION_BAM "' argument"); break; } if (pcount) { prm.paramBamHeader = true; } rc = ArgsOptionCount (args, OPTION_QUA, &pcount); if (rc) { LOGERR(klogErr, rc, "Failure to get '" OPTION_QUA "' argument"); break; } if (pcount) { prm.paramQuality = true; } rc = ArgsOptionCount (args, OPTION_REF, &pcount); if (rc) { LOGERR(klogErr, rc, "Failure to get '" OPTION_REF "' argument"); break; } if (pcount) { prm.paramRef = true; } if (!prm.paramBamHeader && !prm.paramQuality && !prm.paramRef) { prm.paramRef = true; } } while (false); if (rc == 0) { rc = align_info(&prm); } DESTRUCT(Args, args); return rc; }
/* KMain */ rc_t CC KMain ( int argc, char *argv [] ) { Args * args; rc_t rc; rc = ArgsMakeAndHandle (&args, argc, argv, 0); if (rc) LOGERR (klogInt, rc, "failed to parse arguments"); else do { uint32_t acount; rc = ArgsParamCount (args, &acount); if (rc) { LOGERR (klogInt, rc, "failed to count parameters"); break; } if (acount == 0) { rc = MiniUsage (args); break; } else { VFSManager* mgr; rc = VFSManagerMake(&mgr); if (rc) LOGERR ( klogErr, rc, "failed to create VFSManager object" ); else { VResolver * resolver; rc = VFSManagerGetResolver (mgr, &resolver); if (rc == 0) { uint32_t ix; for ( ix = 0; ix < acount; ++ ix ) { const char * pc; rc = ArgsParamValue (args, ix, &pc ); if (rc) LOGERR (klogInt, rc, "failed to retrieve parameter value"); else { const VPath * upath = NULL; rc = VFSManagerMakePath ( mgr, (VPath**)&upath, "%s", pc); if (rc == 0) { const VPath * local; const VPath * remote; rc = VResolverQuery (resolver, eProtocolHttp, upath, &local, &remote, NULL); if (rc == 0) { const String * s; if (local != NULL) rc = VPathMakeString (local, &s); else rc = VPathMakeString (remote, &s); if (rc == 0) { OUTMSG (("%S\n", s)); free ((void*)s); } VPathRelease (local); VPathRelease (remote); } else { KDirectory * cwd; rc_t orc = VFSManagerGetCWD (mgr, &cwd); if (orc == 0) { KPathType kpt = KDirectoryPathType(cwd, "%s", pc); switch (kpt &= ~kptAlias) { case kptNotFound: STSMSG(1, ("'%s': not found while " "searching the file system", pc)); break; case kptBadPath: STSMSG(1, ("'%s': bad path while " "searching the file system", pc)); break; default: STSMSG(1, ("'%s': " "found in the file system", pc)); rc = 0; break; } } if (orc == 0 && rc == 0) { if (rc != 0) { PLOGMSG(klogErr, (klogErr, "'$(name)': not found", "name=%s", pc)); } else { char resolved[PATH_MAX] = ""; rc = KDirectoryResolvePath(cwd, true, resolved, sizeof resolved, "%s", pc); if (rc == 0) { STSMSG(1, ("'%s': found in " "the current directory at '%s'", pc, resolved)); OUTMSG (("%s\n", resolved)); } else { STSMSG(1, ("'%s': cannot resolve " "in the current directory", pc)); OUTMSG (("./%s\n", pc)); } } } KDirectoryRelease(cwd); } } RELEASE(VPath, upath); } } VResolverRelease (resolver); } VFSManagerRelease(mgr); } } ArgsWhack (args); } while (0); return rc; }
rc_t CC KMain( int argc, char* argv[] ) { rc_t rc = 0; Args* args = NULL; const char* errmsg = NULL, *refseq_chunk = NULL, *min_mapq = NULL, *cluster_size = NULL; const XMLLogger* xml_logger = NULL; SParam params; memset(¶ms, 0, sizeof(params)); params.schema = "align/align.vschema"; params.argv0 = argv[0]; if( (rc = ArgsMakeAndHandle(&args, argc, argv, 2, MainArgs, MainArgsQty, XMLLogger_Args, XMLLogger_ArgsQty)) == 0 ) { uint32_t count; if( (rc = ArgsParamCount (args, &count)) != 0 || count != 0 ) { rc = rc ? rc : RC(rcExe, rcArgv, rcParsing, rcParam, rcExcessive); ArgsParamValue(args, 0, &errmsg); } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_Output].name, &count)) != 0 || count != 1 ) { rc = rc ? rc : RC(rcExe, rcArgv, rcParsing, rcParam, count ? rcExcessive : rcInsufficient); errmsg = MainArgs[eopt_Output].name; } else if( (rc = ArgsOptionValue(args, MainArgs[eopt_Output].name, 0, ¶ms.out)) != 0 ) { errmsg = MainArgs[eopt_Output].name; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_MapInput].name, &count)) != 0 || count != 1 ) { rc = rc ? rc : RC(rcExe, rcArgv, rcParsing, rcParam, count ? rcExcessive : rcInsufficient); errmsg = MainArgs[eopt_MapInput].name; } else if( (rc = ArgsOptionValue(args, MainArgs[eopt_MapInput].name, 0, ¶ms.map_path)) != 0 ) { errmsg = MainArgs[eopt_MapInput].name; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_Schema].name, &count)) != 0 || count > 1 ) { rc = rc ? rc : RC(rcExe, rcArgv, rcParsing, rcParam, count ? rcExcessive : rcInsufficient); errmsg = MainArgs[eopt_Schema].name; } else if( count > 0 && (rc = ArgsOptionValue(args, MainArgs[eopt_Schema].name, 0, ¶ms.schema)) != 0 ) { errmsg = MainArgs[eopt_Schema].name; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_AsmInput].name, &count)) != 0 || count > 1 ) { rc = rc ? rc : RC(rcExe, rcArgv, rcParsing, rcParam, rcExcessive); errmsg = MainArgs[eopt_AsmInput].name; } else if( count > 0 && (rc = ArgsOptionValue(args, MainArgs[eopt_AsmInput].name, 0, ¶ms.asm_path)) != 0 ) { errmsg = MainArgs[eopt_AsmInput].name; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_RefSeqConfig].name, &count)) != 0 || count > 1 ) { rc = rc ? rc : RC(rcExe, rcArgv, rcParsing, rcParam, rcExcessive); errmsg = MainArgs[eopt_RefSeqConfig].name; } else if( count > 0 && (rc = ArgsOptionValue(args, MainArgs[eopt_RefSeqConfig].name, 0, ¶ms.refseqcfg)) != 0 ) { errmsg = MainArgs[eopt_RefSeqConfig].name; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_RefSeqPath].name, &count)) != 0 || count > 1 ) { rc = rc ? rc : RC(rcExe, rcArgv, rcParsing, rcParam, rcExcessive); errmsg = MainArgs[eopt_RefSeqPath].name; } else if( count > 0 && (rc = ArgsOptionValue(args, MainArgs[eopt_RefSeqPath].name, 0, ¶ms.refseqpath)) != 0 ) { errmsg = MainArgs[eopt_RefSeqPath].name; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_Library].name, &count)) != 0 || count > 1 ) { rc = rc ? rc : RC(rcExe, rcArgv, rcParsing, rcParam, rcExcessive); errmsg = MainArgs[eopt_Library].name; } else if( count > 0 && (rc = ArgsOptionValue(args, MainArgs[eopt_Library].name, 0, ¶ms.library)) != 0 ) { errmsg = MainArgs[eopt_Library].name; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_RefSeqChunk].name, &count)) != 0 || count > 1 ) { rc = rc ? rc : RC(rcExe, rcArgv, rcParsing, rcParam, rcExcessive); errmsg = MainArgs[eopt_RefSeqChunk].name; } else if( count > 0 && (rc = ArgsOptionValue(args, MainArgs[eopt_RefSeqChunk].name, 0, &refseq_chunk)) != 0 ) { errmsg = MainArgs[eopt_RefSeqChunk].name; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_Force].name, ¶ms.force)) != 0 ) { errmsg = MainArgs[eopt_Force].name; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_ForceRef].name, ¶ms.force_refw)) != 0 ) { errmsg = MainArgs[eopt_ForceRef].name; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_ForceRead].name, ¶ms.force_readw)) != 0 ) { errmsg = MainArgs[eopt_ForceRead].name; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_noReadAhead].name, ¶ms.no_read_ahead)) != 0 ) { errmsg = MainArgs[eopt_noReadAhead].name; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_NoSpotGroup].name, ¶ms.no_spot_group)) != 0 ) { errmsg = MainArgs[eopt_NoSpotGroup].name; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_No2nd_ary].name, ¶ms.min_mapq)) != 0 ) { errmsg = MainArgs[eopt_No2nd_ary].name; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_QualQuantization].name, &count)) != 0 || count > 1 ) { rc = rc ? rc : RC(rcExe, rcArgv, rcParsing, rcParam, rcExcessive); errmsg = MainArgs[eopt_QualQuantization].name; } else if( count > 0 && (rc = ArgsOptionValue(args, MainArgs[eopt_QualQuantization].name, 0, ¶ms.qual_quant)) != 0 ) { errmsg = MainArgs[eopt_QualQuantization].name; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_MinMapQ].name, &count)) != 0 || count > 1 ) { rc = rc ? rc : RC(rcExe, rcArgv, rcParsing, rcParam, rcExcessive); errmsg = MainArgs[eopt_MinMapQ].name; } else if( count > 0 && (rc = ArgsOptionValue(args, MainArgs[eopt_MinMapQ].name, 0, &min_mapq)) != 0 ) { errmsg = MainArgs[eopt_MinMapQ].name; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_ClusterSize].name, &count)) != 0 || count > 1 ) { rc = rc ? rc : RC(rcExe, rcArgv, rcParsing, rcParam, rcExcessive); errmsg = MainArgs[eopt_ClusterSize].name; } else if( count > 0 && (rc = ArgsOptionValue(args, MainArgs[eopt_ClusterSize].name, 0, &cluster_size)) != 0 ) { errmsg = MainArgs[eopt_ClusterSize].name; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_SingleMate].name, ¶ms.single_mate)) != 0 ) { errmsg = MainArgs[eopt_SingleMate].name; } else { do { long val = 0; char* end = NULL; uint32_t count; if( (rc = ArgsOptionCount(args, MainArgs[eopt_RefFile].name, &count)) != 0 ) { break; } else { params.refFiles = calloc(count + 1, sizeof(*(params.refFiles))); if( params.refFiles == NULL ) { rc = RC(rcApp, rcArgv, rcReading, rcMemory, rcExhausted); break; } while(rc == 0 && count-- > 0) { rc = ArgsOptionValue(args, MainArgs[eopt_RefFile].name, count, ¶ms.refFiles[count]); } } if( refseq_chunk != NULL ) { errno = 0; val = strtol(refseq_chunk, &end, 10); if( errno != 0 || refseq_chunk == end || *end != '\0' || val < 0 || val > UINT32_MAX ) { rc = RC(rcExe, rcArgv, rcReading, rcParam, rcInvalid); break; } params.refseq_chunk = val; } if( params.min_mapq > 0 ) { params.min_mapq = ~0; } else if( min_mapq != NULL ) { errno = 0; val = strtol(min_mapq, &end, 10); if( errno != 0 || min_mapq == end || *end != '\0' || val < 0 || val > 255 ) { rc = RC(rcExe, rcArgv, rcReading, rcParam, rcInvalid); break; } params.min_mapq = val; } if ( cluster_size ) params.cluster_size = atoi( cluster_size ); else params.cluster_size = 0; rc = KDirectoryNativeDir( ¶ms.input_dir ); if ( rc != 0 ) errmsg = "current directory"; else { rc = XMLLogger_Make( &xml_logger, params.input_dir, args ); if ( rc != 0 ) errmsg = "XML logging"; else rc = Load( ¶ms ); } } while( false ); KDirectoryRelease( params.input_dir ); } } /* find accession as last part of path for internal XML logging */ refseq_chunk = params.out ? strrchr(params.out, '/') : "/???"; if( refseq_chunk ++ == NULL ) refseq_chunk = params.out; if( argc < 2 ) MiniUsage(args); else if( rc != 0 ) { if( errmsg ) { MiniUsage(args); LOGERR(klogErr, rc, errmsg); } else { PLOGERR(klogErr, (klogErr, rc, "load failed: $(reason_short)", "severity=total,status=failure,accession=%s", refseq_chunk)); } } else { PLOGMSG(klogInfo, (klogInfo, "loaded", "severity=total,status=success,accession=%s", refseq_chunk)); } ArgsWhack(args); XMLLogger_Release(xml_logger); return rc; }
rc_t KMain(int argc, char *argv[]) { rc_t rc = 0; Args* args = NULL; const char* errmsg = NULL, *table_dir = NULL; char accn[1024]; if( (rc = ArgsMakeAndHandle(&args, argc, argv, 1, MainArgs, MainArgsQty)) == 0 ) { const char* blksz = NULL; uint32_t count, dump = 0, gzip = 0; if( (rc = ArgsParamCount(args, &count)) != 0 || count != 1 ) { rc = rc ? rc : RC(rcExe, rcArgv, rcParsing, rcParam, count > 1 ? rcExcessive : rcInsufficient); errmsg = "table"; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_BlockSize].name, &count)) != 0 || count > 1 ) { rc = rc ? rc : RC(rcExe, rcArgv, rcParsing, rcParam, rcExcessive); errmsg = MainArgs[eopt_BlockSize].name; } else if( count > 0 && (rc = ArgsOptionValue(args, MainArgs[eopt_BlockSize].name, 0, (const void **)&blksz)) != 0 ) { errmsg = MainArgs[eopt_BlockSize].name; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_Accession].name, &count)) != 0 || count > 1 ) { rc = rc ? rc : RC(rcExe, rcArgv, rcParsing, rcParam, rcExcessive); errmsg = MainArgs[eopt_Accession].name; } else if( count > 0 && (rc = ArgsOptionValue(args, MainArgs[eopt_Accession].name, 0, (const void **)&g_accession)) != 0 ) { errmsg = MainArgs[eopt_Accession].name; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_DumpIndex].name, &dump)) != 0 ) { errmsg = MainArgs[eopt_DumpIndex].name; } else if( (rc = ArgsOptionCount(args, MainArgs[eopt_noGzip].name, &gzip)) != 0 ) { errmsg = MainArgs[eopt_noGzip].name; } while( rc == 0 ) { long val = 0; char* end = NULL; if( blksz != NULL ) { errno = 0; val = strtol(blksz, &end, 10); if( errno != 0 || blksz == end || *end != '\0' || val <= 0 ) { rc = RC(rcExe, rcArgv, rcReading, rcParam, rcInvalid); errmsg = MainArgs[eopt_BlockSize].name; break; } else if( val <= 128 || val > (1024 * 1024 * 1024) ) { rc = RC(rcExe, rcArgv, rcValidating, rcParam, rcEmpty); errmsg = "block size invalid"; break; } g_file_block_sz = val; } if( (rc = ArgsParamValue(args, 0, (const void **)&table_dir)) != 0 ) { errmsg = "table"; break; } if( g_accession == NULL ) { const char* p = strchr(table_dir, '/'); size_t l = 0; g_accession = accn; if( p == NULL ) { p = strchr(table_dir, '\\'); } strncpy(accn, p == NULL ? table_dir : p + 1, sizeof(accn) - 1); if( accn[0] == '\0' ) { rc = RC(rcExe, rcArgv, rcValidating, rcParam, rcEmpty); errmsg = "accession"; } l = strlen(accn); if( accn[l - 1] == '/' || accn[l - 1] == '\\') { accn[--l] = '\0'; } if( strncmp(&accn[l - 9], ".lite.sra", 9) == 0 ) { accn[l - 9] = '\0'; } else if( strncmp(&accn[l - 4], ".sra", 4) == 0 ) { accn[l - 4] = '\0'; } } g_dump = dump > 0; g_ungzip = gzip > 0; break; } } if( rc == 0 ) { SRAMgr* smgr = NULL; KDBManager* kmgr = NULL; DEBUG_MSG(5, ("table %s, accession %s\n", table_dir, g_accession)); if( (rc = SRAMgrMakeUpdate(&smgr, NULL)) == 0 ) { if( (rc = KDBManagerMakeUpdate(&kmgr, NULL)) == 0 ) { bool relock = true; if( (rc = KDBManagerUnlock(kmgr, table_dir)) != 0 ) { relock = false; rc = GetRCState(rc) == rcUnlocked ? 0 : rc; } else { PLOGMSG(klogInfo, (klogInfo, "Table $(p) locked, unlocking", PLOG_S(p), table_dir)); } if( rc == 0 ) { KTable* ktbl = NULL; if( (rc = KDBManagerOpenTableUpdate(kmgr, &ktbl, table_dir)) == 0 ) { KMetadata* meta = NULL; if( (rc = KTableOpenMetadataUpdate(ktbl, &meta)) == 0 ) { const SRATable* stbl = NULL; if( (rc = SRAMgrOpenTableRead(smgr, &stbl, table_dir)) == 0 ) { rc = MakeIndexes(stbl, ktbl, meta); SRATableRelease(stbl); } } KMetadataRelease(meta); } KTableRelease(ktbl); } if( rc == 0 && relock ) { rc = KDBManagerLock(kmgr, table_dir); } KDBManagerRelease(kmgr); } SRAMgrRelease(smgr); } } if( rc != 0 && rc != KLogLastErrorCode() ) { if( errmsg ) { Usage(args); } LOGERR(klogErr, rc, errmsg ? errmsg : "stop"); } ArgsWhack(args); return rc; }
rc_t CC KMain ( int argc, char *argv [] ) { Args * args; rc_t rc; rc = ArgsMakeAndHandle (&args, argc, argv, 1, Options, sizeof Options / sizeof (OptDef)); if (rc == 0) { uint32_t pcount; const char * pc; const char * directory; const char * archive; do { op_mode mode; uint32_t ix; BSTreeInit (&pnames); rc = ArgsParamCount (args, &pcount); if (rc) break; for (ix = 0; ix < pcount; ++ix) { rc = ArgsParamValue (args, ix, (const void **)&pc); if (rc) break; rc = pnamesInsert (pc); if (rc) { PLOGERR (klogInt, (klogInt, rc, "failure to process filter parameter [%s]", pc)); break; } } if (rc) break; rc = ArgsOptionCount (args, OPTION_ALIGN, &pcount); if (rc) break; if (pcount == 0) pc = NULL; else { rc = ArgsOptionValue (args, OPTION_ALIGN, 0, (const void **)&pc); if (rc) break; } alignment = get_alignment (pc); if (alignment == sraAlignInvalid) { rc = RC (rcExe, rcArgv, rcParsing, rcParam, rcInvalid); PLOGERR (klogFatal, (klogFatal, rc, "Parameter for alignment [$(A)] is invalid: must be a power of two bytes", PLOG_S(A), pc)); break; } rc = ArgsOptionCount (args, OPTION_LONGLIST, &pcount); if (rc) break; long_list = (pcount != 0); rc = ArgsOptionCount (args, OPTION_FORCE, &pcount); if (rc) break; force = (pcount != 0); mode = OM_NONE; rc = ArgsOptionCount (args, OPTION_DIRECTORY, &pcount); if (rc) break; if (pcount) { rc = ArgsOptionValue (args, OPTION_DIRECTORY, 0, (const void **)&directory); if (rc) break; } else directory = NULL; rc = ArgsOptionCount (args, OPTION_CREATE, &pcount); if (rc) break; if (pcount) { rc = ArgsOptionValue (args, OPTION_CREATE, 0, (const void **)&archive); if (rc) break; mode = OM_CREATE; } rc = ArgsOptionCount (args, OPTION_TEST, &pcount); if (rc) break; if (pcount) { if (mode == OM_NONE) { mode = OM_TEST; rc = ArgsOptionValue (args, OPTION_TEST, 0, (const void **)&archive); if (rc) break; } else mode = OM_ERROR; } rc = ArgsOptionCount (args, OPTION_LIST, &pcount); if (rc) break; if (pcount) { if (mode == OM_NONE) { mode = OM_TEST; rc = ArgsOptionValue (args, OPTION_LIST, 0, (const void **)&archive); if (rc) break; } else mode = OM_ERROR; } rc = ArgsOptionCount (args, OPTION_EXTRACT, &pcount); if (rc) break; if (pcount) { if (mode == OM_NONE) { mode = OM_EXTRACT; rc = ArgsOptionValue (args, OPTION_EXTRACT, 0, (const void **)&archive); if (rc) break; } else mode = OM_ERROR; } if (mode == OM_NONE) { MiniUsage(args); rc = RC(rcApp, rcArgv, rcParsing, rcParam, rcInsufficient); break; } /* ----- * Mount the native filesystem as root */ rc = KDirectoryNativeDir (&kdir); if (rc != 0) { LOGMSG (klogFatal, "Failed to open native KDirectory"); } else { switch (mode) { default: /* OM_NONE presumably */ /* assert (mode == OM_NONE); */ /* rc = RC (rcExe, rcNoTarg, rcParsing, rcParam, rcEmpty); */ /* LOGERR (klogFatal, rc, "Must provide a single operating mode and archive: Create, Test (list) or eXtract"); */ pc = NULL; break; case OM_ERROR: rc = RC (rcExe, rcNoTarg, rcParsing, rcParam, rcAmbiguous); LOGERR (klogFatal, rc, "Must provide a single operating mode and archive: Create, Test (list) or eXtract"); break; case OM_CREATE: STSMSG (2, ("Create Mode %s %s", archive, directory)); if (directory == NULL) { rc = RC (rcExe, rcNoTarg, rcParsing, rcParam, rcNull); LOGERR (klogFatal, rc, "Must provide a directory for create mode"); } else rc = run_kar_create (archive, directory); break; case OM_TEST: STSMSG (2, ("Test Mode %s", archive)); rc = run_kar_test (archive); break; case OM_EXTRACT: STSMSG (2, ("Extract Mode %s %s", archive, directory)); if (directory == NULL) { rc = RC (rcExe, rcNoTarg, rcParsing, rcParam, rcNull); LOGERR (klogFatal, rc, "Must provide a directory for extract mode"); } else rc = run_kar_extract (archive, directory); break; } KDirectoryRelease (kdir); } } while (0); ArgsWhack (args); } if (rc) LOGERR (klogWarn, rc, "Failure exiting kar"); else STSMSG (1, ("Success: Exiting kar\n")); return rc; }
rc_t CC KMain ( int argc, char *argv [] ) { Args *args; rc_t rc = ArgsMakeAndHandle ( & args, argc, argv, 0 ); if ( rc != 0 ) LogErr ( klogErr, rc, "failed to parse arguments" ); else { uint32_t paramc; rc = ArgsParamCount ( args, & paramc ); if ( rc != 0 ) LogErr ( klogInt, rc, "failed to obtain param count" ); else { if ( paramc == 0 ) { rc = RC ( rcExe, rcArgv, rcParsing, rcParam, rcInsufficient ); LogErr ( klogErr, rc, "missing target object" ); MiniUsage ( args ); } else if ( paramc > 1 ) { rc = RC ( rcExe, rcArgv, rcParsing, rcParam, rcExcessive ); LogErr ( klogErr, rc, "expected single target object" ); MiniUsage ( args ); } else { const char *target; rc = ArgsParamValue ( args, 0, & target ); if ( rc != 0 ) LogErr ( klogInt, rc, "failed to obtain param value" ); else { VDBManager *mgr; #if TOOLS_USE_SRAPATH != 0 char full [ 4096 ]; SRAPath *sra_path; rc = SRAPathMake ( & sra_path, NULL ); if ( rc == 0 ) { if ( ! SRAPathTest ( sra_path, target ) ) { rc = SRAPathFind ( sra_path, target, full, sizeof full ); if ( rc == 0 ) target = full; } SRAPathRelease ( sra_path ); } #endif rc = VDBManagerMakeUpdate ( & mgr, NULL ); if ( rc != 0 ) LogErr ( klogInt, rc, "failed to open VDB manager" ); else { rc = VDBManagerLock ( mgr, target ); if ( rc == 0 ) pLogMsg ( klogInfo, "locked '$(target)'", "target=%s", target ); else switch ( GetRCState ( rc ) ) { case rcLocked: pLogMsg ( klogInfo, "'$(target)' was already locked", "target=%s", target ); break; default: pLogErr ( klogErr, rc, "failed to lock '$(target)'", "target=%s", target ); } VDBManagerRelease ( mgr ); } } } } ArgsWhack ( args ); } return rc; }
rc_t CC KMain ( int argc, char *argv [] ) { Args * args; rc_t rc; rc = ArgsMakeAndHandle (&args, argc, argv, 1, MyOptions, sizeof MyOptions / sizeof (OptDef)); if (rc) LOGERR (klogInt, rc, "failed to parse arguments"); else { do { KDyld *dl; uint32_t num_libs; rc = ArgsParamCount (args, &num_libs); if (rc) { LOGERR ( klogInt, rc, "Failure to count parameters" ); break; } if (num_libs == 0) { rc = MiniUsage(args); break; } /* create loader */ rc = KDyldMake (&dl); if (rc) { LOGERR ( klogInt, rc, "failed to create dynamic loader" ); break; } else { do { KDlset *libs; const char * path; uint32_t ix; uint32_t num_paths; rc = ArgsOptionCount (args, OPTION_LOAD, &num_paths); if (rc) { LOGERR (klogInt, rc, "failed to count paths"); break; } for (ix = 0; ix < num_paths; ix++) { rc = ArgsOptionValue (args, OPTION_LOAD, ix, (const void **)&path); if (rc) { LOGERR (klogInt, rc, "failed to access a path option"); break; } testld_update_libpath (dl, path); } if (rc) break; /* append contents of LD_LIBRARY_PATH */ path = getenv ( "LD_LIBRARY_PATH" ); if (path) testld_update_libpath (dl, path); /* create libset */ rc = KDyldMakeSet (dl, & libs); if (rc) { LOGERR (klogInt, rc, "failed to create dl library set"); break; } else { /* test it */ for (ix = 0; ix < num_libs; ++ ix ) { rc = ArgsParamValue (args, ix, (const void **)&path); if (rc) break; testld_load_library (dl, libs, path); } KDlsetRelease ( libs ); } } while (0); KDyldRelease ( dl ); } } while (0); ArgsWhack (args); } return rc; }
rc_t CC KMain (int argc, char * argv[]) { Args * args; rc_t rc; unsigned n_aligned = 0; unsigned n_unalgnd = 0; char *aligned[256]; char *unalgnd[256]; char *name_buffer = NULL; unsigned next_name = 0; unsigned nbsz = 0; char const *value; char *dummy; const XMLLogger* xml_logger = NULL; memset(&G, 0, sizeof(G)); G.mode = mode_Archive; G.maxSeqLen = TableWriterRefSeq_MAX_SEQ_LEN; G.schemaPath = SCHEMAFILE; G.omit_aligned_reads = true; G.omit_reference_reads = true; G.minMapQual = 0; /* accept all */ G.tmpfs = "/tmp"; #if _ARCH_BITS == 32 G.cache_size = ( size_t ) 1 << 30; #else G.cache_size = ( size_t ) 10 << 30; #endif G.maxErrCount = 1000; G.minMatchCount = 10; set_pid(); rc = ArgsMakeAndHandle (&args, argc, argv, 2, Options, sizeof Options / sizeof (OptDef), XMLLogger_Args, XMLLogger_ArgsQty); while (rc == 0) { uint32_t pcount; if( (rc = XMLLogger_Make(&xml_logger, NULL, args)) != 0 ) { break; } rc = ArgsOptionCount(args, option_only_verify, &pcount); if (rc) break; G.onlyVerifyReferences = (pcount > 0); rc = ArgsOptionCount(args, option_no_verify, &pcount); if (rc) break; G.noVerifyReferences = (pcount > 0); rc = ArgsOptionCount(args, option_use_qual, &pcount); if (rc) break; G.useQUAL = (pcount > 0); rc = ArgsOptionCount(args, option_ref_config, &pcount); if (rc) break; G.limit2config = (pcount > 0); rc = ArgsOptionCount(args, OPTION_REF_FILE, &pcount); if (rc) break; G.refFiles = calloc(pcount + 1, sizeof(*(G.refFiles))); if( !G.refFiles ) { rc = RC(rcApp, rcArgv, rcAccessing, rcMemory, rcExhausted); break; } while(pcount-- > 0) { rc = ArgsOptionValue(args, OPTION_REF_FILE, pcount, &G.refFiles[pcount]); if (rc) break; } rc = ArgsOptionCount (args, OPTION_TMPFS, &pcount); if (rc) break; if (pcount == 1) { rc = ArgsOptionValue (args, OPTION_TMPFS, 0, &G.tmpfs); if (rc) break; } else if (pcount > 1) { rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcExcessive); OUTMSG (("Single parameter required\n")); MiniUsage (args); break; } rc = ArgsOptionCount (args, OPTION_INPUT, &pcount); if (rc) break; if (pcount == 1) { rc = ArgsOptionValue (args, OPTION_INPUT, 0, &G.inpath); if (rc) break; } else if (pcount > 1) { rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcExcessive); OUTMSG (("Single input parameter required\n")); MiniUsage (args); break; } rc = ArgsOptionCount (args, option_ref_filter, &pcount); if (rc) break; if (pcount == 1) { rc = ArgsOptionValue (args, option_ref_filter, 0, &G.refFilter); if (rc) break; } else if (pcount > 1) { rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcExcessive); OUTMSG (("Single parameter required\n")); MiniUsage (args); break; } rc = ArgsOptionCount (args, OPTION_CONFIG, &pcount); if (rc) break; if (pcount == 1) { rc = ArgsOptionValue (args, OPTION_CONFIG, 0, &G.refXRefPath); if (rc) break; } else if (pcount > 1) { rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcExcessive); OUTMSG (("Single input parameter required\n")); MiniUsage (args); break; } rc = ArgsOptionCount (args, OPTION_OUTPUT, &pcount); if (rc) break; if (pcount == 1) { rc = ArgsOptionValue (args, OPTION_OUTPUT, 0, &G.outpath); if (rc) break; } else if (pcount > 1) { rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcExcessive); OUTMSG (("Single output parameter required\n")); MiniUsage (args); break; } else if (!G.onlyVerifyReferences) { rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcInsufficient); OUTMSG (("Output parameter required\n")); MiniUsage (args); break; } rc = ArgsOptionCount (args, OPTION_MINMAPQ, &pcount); if (rc) break; if (pcount == 1) { rc = ArgsOptionValue (args, OPTION_MINMAPQ, 0, &value); if (rc) break; G.minMapQual = strtoul(value, &dummy, 0); } rc = ArgsOptionCount (args, OPTION_QCOMP, &pcount); if (rc) break; if (pcount == 1) { rc = ArgsOptionValue (args, OPTION_QCOMP, 0, &G.QualQuantizer); if (rc) break; } rc = ArgsOptionCount (args, option_edit_aligned_qual, &pcount); if (rc) break; if (pcount == 1) { rc = ArgsOptionValue (args, option_edit_aligned_qual, 0, &value); if (rc) break; G.alignedQualValue = strtoul(value, &dummy, 0); if (G.alignedQualValue == 0) { rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcIncorrect); OUTMSG (("edit-aligned-qual: bad value\n")); MiniUsage (args); break; } G.editAlignedQual = true; } rc = ArgsOptionCount (args, OPTION_CACHE_SIZE, &pcount); if (rc) break; if (pcount == 1) { rc = ArgsOptionValue (args, OPTION_CACHE_SIZE, 0, &value); if (rc) break; G.cache_size = strtoul(value, &dummy, 0) * 1024UL * 1024UL; if (G.cache_size == 0) { rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcIncorrect); OUTMSG (("cache-size: bad value\n")); MiniUsage (args); break; } } rc = ArgsOptionCount (args, OPTION_MAX_WARN_DUP_FLAG, &pcount); if (rc) break; if (pcount == 1) { rc = ArgsOptionValue (args, OPTION_MAX_WARN_DUP_FLAG, 0, &value); if (rc) break; G.maxWarnCount_DupConflict = strtoul(value, &dummy, 0); } rc = ArgsOptionCount (args, option_unsorted, &pcount); if (rc) break; G.expectUnsorted = pcount > 0; rc = ArgsOptionCount (args, OPTION_MAX_REC_COUNT, &pcount); if (rc) break; if (pcount == 1) { rc = ArgsOptionValue (args, OPTION_MAX_REC_COUNT, 0, &value); if (rc) break; G.maxAlignCount = strtoul(value, &dummy, 0); } rc = ArgsOptionCount (args, OPTION_MAX_ERR_COUNT, &pcount); if (rc) break; if (pcount == 1) { rc = ArgsOptionValue (args, OPTION_MAX_ERR_COUNT, 0, &value); if (rc) break; G.maxErrCount = strtoul(value, &dummy, 0); } rc = ArgsOptionCount (args, OPTION_MIN_MATCH, &pcount); if (rc) break; if (pcount == 1) { rc = ArgsOptionValue (args, OPTION_MIN_MATCH, 0, &value); if (rc) break; G.minMatchCount = strtoul(value, &dummy, 0); } rc = ArgsOptionCount (args, OPTION_ACCEPT_DUP, &pcount); if (rc) break; G.acceptBadDups = pcount > 0; rc = ArgsOptionCount (args, OPTION_ACCEPT_NOMATCH, &pcount); if (rc) break; G.acceptNoMatch = pcount > 0; rc = ArgsOptionCount (args, option_keep_mismatch_qual, &pcount); if (rc) break; G.keepMismatchQual = pcount > 0; rc = ArgsOptionCount (args, OPTION_NO_CS, &pcount); if (rc) break; G.noColorSpace = pcount > 0; rc = ArgsOptionCount (args, OPTION_NO_SECONDARY, &pcount); if (rc) break; G.noSecondary = pcount > 0; rc = ArgsOptionCount (args, OPTION_TI, &pcount); if (rc) break; G.hasTI = pcount > 0; rc = ArgsOptionCount (args, OPTION_ACCEPT_HARD_CLIP, &pcount); if (rc) break; G.acceptHardClip = pcount > 0; rc = ArgsOptionCount (args, OPTION_NOMATCH_LOG, &pcount); if (rc) break; if (pcount == 1) { KDirectory *dir; rc = ArgsOptionValue (args, OPTION_NOMATCH_LOG, 0, &value); if (rc) break; rc = KDirectoryNativeDir(&dir); if (rc) break; rc = KDirectoryCreateFile(dir, &G.noMatchLog, 0, 0664, kcmInit, value); KDirectoryRelease(dir); if (rc) break; } rc = ArgsOptionCount (args, OPTION_HEADER, &pcount); if (rc) break; if (pcount == 1) { rc = ArgsOptionValue (args, OPTION_HEADER, 0, &value); if (rc) break; rc = LoadHeader(&G.headerText, value, G.inpath); if (rc) break; } rc = ArgsParamCount (args, &pcount); if (rc) break; if (pcount == 0) { rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcInsufficient); MiniUsage (args); break; } else if (pcount > sizeof(aligned)/sizeof(aligned[0])) { rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcExcessive); (void)PLOGERR(klogErr, (klogErr, rc, "$(count) input files is too many, $(max) is the limit", "count=%u,max=%u", (unsigned)pcount, (unsigned)(sizeof(aligned)/sizeof(aligned[0])))); break; } else { unsigned need = G.inpath ? (strlen(G.inpath) + 1) * pcount : 0; unsigned i; for (i = 0; i < pcount; ++i) { rc = ArgsParamValue(args, i, &value); if (rc) break; need += strlen(value) + 1; } nbsz = need; } rc = ArgsOptionCount (args, OPTION_UNALIGNED, &pcount); if (rc) break; if (pcount > 0) { unsigned need = G.inpath ? (strlen(G.inpath) + 1) * pcount : 0; unsigned i; for (i = 0; i < pcount; ++i) { rc = ArgsOptionValue(args, OPTION_UNALIGNED, i, &value); if (rc) break; need += strlen(value) + 1; } if (rc) break; nbsz += need; } name_buffer = malloc(nbsz); if (name_buffer == NULL) { rc = RC(rcApp, rcArgv, rcAccessing, rcMemory, rcExhausted); break; } rc = ArgsOptionCount (args, OPTION_UNALIGNED, &pcount); if (rc == 0) { unsigned i; for (i = 0; i < pcount; ++i) { rc = ArgsOptionValue(args, OPTION_UNALIGNED, i, &value); if (rc) break; unalgnd[n_unalgnd++] = name_buffer + next_name; rc = PathWithBasePath(name_buffer + next_name, nbsz - next_name, value, G.inpath); if (rc) break; next_name += strlen(name_buffer + next_name) + 1; } if (rc) break; } else break; rc = ArgsParamCount (args, &pcount); if (rc == 0) { unsigned i; for (i = 0; i < pcount; ++i) { rc = ArgsParamValue(args, i, &value); if (rc) break; aligned[n_aligned++] = name_buffer + next_name; rc = PathWithBasePath(name_buffer + next_name, nbsz - next_name, value, G.inpath); if (rc) break; next_name += strlen(name_buffer + next_name) + 1; } } else break; rc = run(argv[0], n_aligned, (char const **)aligned, n_unalgnd, (char const **)unalgnd); break; } free(name_buffer); free((void *)G.headerText); free(G.refFiles); value = G.outpath ? strrchr(G.outpath, '/') : "/???"; if( value == NULL ) { value = G.outpath; } else { value++; } if (rc) { (void)PLOGERR(klogErr, (klogErr, rc, "load failed", "severity=total,status=failure,accession=%s,errors=%u", value, G.errCount)); } else { (void)PLOGMSG(klogInfo, (klogInfo, "loaded", "severity=total,status=success,accession=%s,errors=%u", value, G.errCount)); } ArgsWhack(args); XMLLogger_Release(xml_logger); return rc; }
/* ---------------------------------------------------------------------- * KMain * * Figure out what is on the command line */ rc_t KMain ( int argc, char *argv [] ) { Args * args; rc_t rc; rc = ArgsMakeAndHandle (&args, argc, argv, 1, Options, sizeof Options / sizeof (OptDef)); if (rc == 0) { /* use do {} while; for easy outs */ do { const char * pc; uint32_t pcount; rc = ArgsProgram (args, &full_path, &program_name); if (rc) { PLOGERR (klogFatal, (klogFatal, rc, "failed to set name to $'(N)'", "N=%s", program_name)); break; } rc = ArgsOptionCount (args, OPTION_FORCE, &pcount); if (rc) { LOGERR (klogFatal, rc, "failed to check force option"); break; } if (pcount) { options.force = true; options.cm = kcmParents | kcmInit; } else { options.force = true; options.cm = kcmParents | kcmCreate; } rc = ArgsOptionCount (args, OPTION_XML, &pcount); if (rc) { LOGERR (klogFatal, rc, "failed to check XML option"); break; } if (pcount) { rc = ArgsOptionValue (args, OPTION_XML, 0, (const void **)&options.xmlstr); if (rc) { LOGERR (klogFatal, rc, "failed to get XML value"); break; } } else { rc = RC (rcExe, rcArgv, rcParsing, rcParam, rcNull); LOGERR (klogFatal, rc, "missing required copycat-xml option"); MiniUsage(args); break; } rc = ArgsOptionCount (args, OPTION_DIR, &pcount); if (rc) { LOGERR (klogFatal, rc, "failed to check directory option"); break; } if (pcount) { rc = ArgsOptionValue (args, OPTION_DIR, 0, (const void **)&options.dirstr); if (rc) { LOGERR (klogFatal, rc, "failed to get directory value"); break; } } else { options.dirstr = "."; } rc = ArgsParamCount (args, &pcount); if (rc) { LOGERR (klogFatal, rc, "failed to count parameters"); break; } if (pcount == 0) { rc = RC ( rcExe, rcArgv, rcReading, rcParam, rcInsufficient ); LOGERR (klogFatal, rc, "Missing archive parameter"); MiniUsage (args); break; } { uint32_t block; block = 1; if (pcount > 2) block = pcount - 1; VectorInit (&options.pathstr, 0, block); } rc = ArgsParamValue (args, 0, (const void **)&options.arcstr); if (rc) LOGERR (klogFatal, rc, "failed to retrieve archive parameter"); else { if (pcount == 1) { rc = VectorAppend (&options.pathstr, NULL, "."); if (rc) LOGERR (klogFatal, rc, "failed to set default path parameter"); } else { uint32_t ix; for (ix = 1; ix < pcount; ++ix) { rc = ArgsParamValue (args, ix, (const void **)&pc); if (rc) { PLOGERR (klogFatal, (klogFatal, rc, "unable to extract path parameter '$(K)", "K=%u", ix)); break; } rc = VectorAppend (&options.pathstr, NULL, pc); if (rc) { PLOGERR (klogFatal, (klogFatal, rc, "failed to add path '$(P)' to list", "P=%s", pc)); break; } } } } if (rc == 0) open_mgr_then_run(); VectorWhack (&options.pathstr, NULL, NULL); } while (0); ArgsWhack (args); } return rc; }
rc_t CC KMain ( int argc, char *argv[] ) { Args * args; rc_t rc = 0; rc = ArgsMakeAndHandle (&args, argc, argv, 0 /*1, Options, sizeof Options / sizeof (&Options[1])*/); if (rc) { LOGERR (klogInt, rc, "Failed to parse parameters"); return rc; } else { do { param_block pb; uint32_t pcount; rc = ArgsParamCount (args, &pcount); if (rc) { LOGERR (klogInt, rc, "Failed to get paramater count"); break; } switch (pcount) { default: rc = MiniUsage (args); goto bailout; case 2: pb.schema_path = SCHEMASPEC; break; case 3: pb.schema_path = NULL; break; } rc = ArgsParamValue (args, 0, (const void **)&pb.file_path); if (rc) { LOGERR (klogInt,rc, "Failed to get file path"); break; } rc = ArgsParamValue (args, 1, (const void **)&pb.table_path); if (rc) { LOGERR (klogInt,rc, "Failed to get table path"); break; } if (pb.schema_path == NULL) { rc = ArgsParamValue (args, 2, (const void **)&pb.schema_path); if (rc) { LOGERR (klogInt,rc, "Failed to get schema path"); break; } } rc = open (&pb); } while (0); bailout: ArgsWhack (args); } if (rc) LOGERR (klogFatal, rc, "Failed!"); else KStsMsg("Exit success %R"); return rc; }
static rc_t argsHandler(int argc, char* argv[]) { Args* args = NULL; rc_t rc = ArgsMakeAndHandle(&args, argc, argv, 0, NULL, 0); ArgsWhack(args); return rc; }
rc_t CC KMain ( int argc, char *argv [] ) { Args *args; rc_t rc; do { uint32_t paramc; bool requireAmd64 = false; uint64_t requireRam = 0; rc = ArgsMakeAndHandle ( & args, argc, argv, 1, Options, sizeof Options / sizeof (OptDef) ); if ( rc != 0 ) { LogErr ( klogErr, rc, "failed to parse arguments" ); break; } // TODO: cehck if we need it rc = ArgsParamCount ( args, & paramc ); if ( rc != 0 ) { LogErr ( klogInt, rc, "failed to obtain param count" ); break; } { // OPTION_AMD64 rc = ArgsOptionCount( args, OPTION_AMD64, & paramc ); if ( rc ) { LOGERR( klogErr, rc, "Failure to get '" OPTION_AMD64 "' argument" ); break; } if ( paramc ) { requireAmd64 = true; } } { // OPTION_RAM rc = ArgsOptionCount ( args, OPTION_RAM, & paramc ); if ( rc ) { LOGERR ( klogErr, rc, "Failure to get '" OPTION_RAM "' argument" ); break; } if ( paramc ) { const char* dummy = NULL; rc = ArgsOptionValue(args, OPTION_RAM, 0, (const void **)&dummy); if ( rc ) { LOGERR(klogErr, rc, "Failure to get '" OPTION_RAM "' argument"); break; } rc = sscanf(dummy, "%llu", &requireRam); if ( rc != 1) { LOGMSG(klogErr, "Failure to parse '" OPTION_RAM "' argument value"); break; } } } { rc = KAppCheckEnvironment(requireAmd64, requireRam); if (rc != 0 ) printf("Invalid environment\n"); else printf("Enviroment is fine!\n"); } } while (false); ArgsWhack ( args ); return rc; }
rc_t CC KMain ( int argc, char *argv [] ) { Args * args; rc_t rc = ArgsMakeAndHandle ( &args, argc, argv, 1, QfileTestOptions, sizeof ( QfileTestOptions ) / sizeof ( OptDef ) ); if ( rc != 0 ) { OUTMSG(( "ArgsMakeAndHandle( ... ) failed: %R\n", rc )); } else { uint32_t arg_count = 0; rc = ArgsParamCount ( args, &arg_count ); if ( rc != 0 ) { OUTMSG(( "ArgsParamCount( ... ) failed: %R\n", rc )); } else { KDirectory *dir = NULL; uint64_t position = get_uint64_option( args, OPTION_POS, 0 ); uint64_t count = get_uint64_option( args, OPTION_COUNT, 0 ); uint32_t qsize = get_uint32_option( args, OPTION_QSIZE, 1024 ); uint32_t bsize = get_uint32_option( args, OPTION_BSIZE, 0 ); uint32_t csize = get_uint32_option( args, OPTION_CSIZE, 1024 ); uint64_t pos2 = get_uint64_option( args, OPTION_POS2, 0 ); OUTMSG(( "start-position : %lu\n", position )); if ( pos2 > 0 ) { OUTMSG(( "2nd position : %lu\n", pos2 )); } if ( count > 0 ) { OUTMSG(( "count : %lu\n", count )); } OUTMSG(( "queue-size : %u\n", qsize )); OUTMSG(( "block-size : %u\n", bsize )); OUTMSG(( "chunk-size : %u\n", csize )); rc = KDirectoryNativeDir( &dir ); if ( rc != 0 ) { OUTMSG(( "KDirectoryNativeDir( ... ) failed: %R\n", rc )); } else { uint32_t i; for ( i = 0; i < arg_count && rc == 0; ++i ) { const char * filename; rc = ArgsParamValue ( args, i, &filename ); if ( rc != 0 ) { OUTMSG(( "ArgsParamValue( %d ) failed: %R\n", i, rc )); } else { OUTMSG(( "file to read : '%s'\n", filename )); rc = perform_test( dir, filename, position, pos2, count, qsize, bsize, csize ); } } KDirectoryRelease( dir ); } } ArgsWhack ( args ); } return rc; }
rc_t CC KMain ( int argc, char *argv [] ) { rc_t rc = KOutHandlerSet ( write_to_FILE, stdout ); if ( rc != 0 ) { PLOGERR( klogErr, ( klogErr, rc, "KOutHandlerSet() failed in $(func)", "func=%s", __func__ ) ); } else { Args * args; rc = ArgsMakeAndHandle ( &args, argc, argv, 1, ToolOptions, sizeof ToolOptions / sizeof ToolOptions [ 0 ] ); if ( rc != 0 ) { PLOGERR( klogErr, ( klogErr, rc, "ArgsMakeAndHandle() failed in $(func)", "func=%s", __func__ ) ); } else { tool_options options; rc = init_tool_options( &options ); if ( rc == 0 ) { rc = get_tool_options( args, &options ); if ( rc == 0 ) { bool cache_paths_needed = false; switch( options.main_function ) { case tf_report : ; case tf_unlock : ; case tf_clear : cache_paths_needed = true; break; case tf_rreport : ; case tf_enable : ; case tf_disable : ; case tf_unknown : ; break; } if ( options.path_count == 0 && cache_paths_needed ) rc = get_cache_path_from_repo_mgr( &options ); if ( rc == 0 ) { if ( options.path_count == 0 && cache_paths_needed ) { rc = explain_no_cache_found (); } else rc = perform( &options, args ); } } clear_tool_options( &options ); } } { rc_t rc2 = ArgsWhack ( args ); if ( rc2 != 0 ) { PLOGERR( klogErr, ( klogErr, rc2, "ArgsWhack() failed in $(func)", "func=%s", __func__ ) ); } } } return rc; }
static rc_t ParamsConstruct(int argc, char* argv[], Params* prm) { rc_t rc = 0; Args* args = NULL; int count = 0; assert(argc && argv && prm); memset(prm, 0, sizeof *prm); args = prm->args; do { uint32_t pcount = 0; rc = ArgsMakeAndHandle(&args, argc, argv, 1, Options, sizeof Options / sizeof (OptDef)); if (rc) { LOGERR(klogErr, rc, "While calling ArgsMakeAndHandle"); break; } prm->args = args; rc = ArgsParamCount(args, &prm->argsParamCnt); if (rc) { LOGERR(klogErr, rc, "Failure to get query parameter[s]"); break; } if (prm->argsParamCnt > 0) { prm->modeShowCfg = true; ++count; } prm->xml = true; rc = ArgsOptionCount(args, OPTION_OUT, &pcount); if (rc) { LOGERR(klogErr, rc, "Failure to get '" OPTION_OUT "' argument"); break; } if (pcount) { const char* dummy = NULL; rc = ArgsOptionValue(args, OPTION_OUT, 0, &dummy); if (rc) { LOGERR(klogErr, rc, "Failure to get '" OPTION_OUT "' argument"); break; } if (!strcmp(dummy, "n")) { prm->xml = false; } else if (strcmp(dummy, "x")) { rc = RC(rcExe, rcArgv, rcParsing, rcParam, rcInvalid); LOGERR(klogErr, rc, "Bad " OPTION_OUT " value"); break; } } rc = ArgsOptionCount(args, OPTION_CFG, &pcount); if (rc) { LOGERR(klogErr, rc, "Failure to get '" OPTION_CFG "' argument"); break; } if (pcount) { if (!prm->modeShowCfg) { prm->modeShowCfg = true; ++count; } } rc = ArgsOptionCount(args, OPTION_ENV, &pcount); if (rc) { LOGERR(klogErr, rc, "Failure to get '" OPTION_ENV "' argument"); break; } if (pcount) { prm->modeShowEnv = true; ++count; } rc = ArgsOptionCount(args, OPTION_FIL, &pcount); if (rc) { LOGERR(klogErr, rc, "Failure to get '" OPTION_FIL "' argument"); break; } if (pcount) { prm->modeShowFiles = true; ++count; } rc = ArgsOptionCount(args, OPTION_IMP, &pcount); if (rc) { LOGERR(klogErr, rc, "Failure to get '" OPTION_IMP "' argument"); break; } if (pcount) { rc = ArgsOptionValue(args, OPTION_IMP, 0, &prm->ngc); if (rc) { LOGERR(klogErr, rc, "Failure to get '" OPTION_IMP "' argument"); break; } } rc = ArgsOptionCount(args, OPTION_MOD, &pcount); if (rc) { LOGERR(klogErr, rc, "Failure to get '" OPTION_MOD "' argument"); break; } if (pcount) { prm->modeShowModules = true; ++count; } #if 0 rc = ArgsOptionCount(args, OPTION_NEW, &pcount); if (rc) { LOGERR(klogErr, rc, "Failure to get '" OPTION_NEW "' argument"); break; } if (pcount) { prm->modeCreate = true; ++count; } #endif rc = ArgsOptionCount(args, OPTION_DIR, &pcount); if (rc) { LOGERR(klogErr, rc, "Failure to get '" OPTION_DIR "' argument"); break; } if (pcount) { prm->modeShowLoadPath = true; ++count; } rc = ArgsOptionCount(args, OPTION_SET, &pcount); if (rc) { LOGERR(klogErr, rc, "Failure to get '" OPTION_SET "' argument"); break; } if (pcount) { rc = ArgsOptionValue(args, OPTION_SET, 0, &prm->setValue); if (rc == 0) { const char* p = strchr(prm->setValue, '='); if (p == NULL || *(p + 1) == '\0') { rc = RC(rcExe, rcArgv, rcParsing, rcParam, rcInvalid); LOGERR(klogErr, rc, "Bad " OPTION_SET " value"); break; } prm->modeSetNode = true; prm->modeCreate = prm->modeShowCfg = prm->modeShowEnv = prm->modeShowFiles = prm->modeShowLoadPath = prm->modeShowModules = false; count = 1; } } rc = ArgsOptionCount(args, OPTION_ALL, &pcount); if (rc) { LOGERR(klogErr, rc, "Failure to get '" OPTION_ALL "' argument"); break; } if (pcount || ( !prm->modeShowCfg && ! prm->modeShowLoadPath && !prm->modeShowEnv && !prm->modeShowFiles && !prm->modeShowModules && !prm->modeCreate && !prm->modeSetNode && !prm->ngc)) /* show all by default */ { prm->modeShowCfg = prm->modeShowEnv = prm->modeShowFiles = true; #ifndef _STATIC prm->modeShowModules = true; #endif count += 2; } if (count > 1) { prm->showMultiple = true; } } while (false); return rc; }
/* KMain - EXTERN * executable entrypoint "main" is implemented by * an OS-specific wrapper that takes care of establishing * signal handlers, logging, etc. * * in turn, OS-specific "main" will invoke "KMain" as * platform independent main entrypoint. * * "argc" [ IN ] - the number of textual parameters in "argv" * should never be < 0, but has been left as a signed int * for reasons of tradition. * * "argv" [ IN ] - array of NUL terminated strings expected * to be in the shell-native character set: ASCII or UTF-8 * element 0 is expected to be executable identity or path. */ rc_t CC KMain ( int argc, char *argv [] ) { Args * args; rc_t rc; default_log_level = KLogLevelGet(); rc = ArgsMakeAndHandle (&args, argc, argv, 1, Options, sizeof Options / sizeof (OptDef)); if (rc == 0) { do { srakar_parms pb; KDirectory * pwd; const char * name; uint32_t pcount; char archive_name [256]; rc = KDirectoryNativeDir (&pwd); if (rc) break; pb.lite = false; pb.force = false; pb.dir = pwd; rc = ArgsOptionCount (args, OPTION_LITE, &pcount); if (rc) break; if (pcount == 1) { STSMSG (1, ("Using lite option")); pb.lite = true; } #if USE_FORCE rc = ArgsOptionCount (args, OPTION_FORCE, &pcount); if (rc) break; if (pcount == 1) { STSMSG (1, ("Using force option")); pb.force = true; } #endif rc = ArgsParamCount (args, &pcount); if (rc) break; if (pcount == 0) { KOutMsg ("missing source table\n"); rc = MiniUsage (args); break; } else if (pcount > 2) { KOutMsg ("Too many parameters\n"); rc = MiniUsage (args); break; } rc = ArgsParamValue (args, 0, &pb.src_path); if (rc) { KOutMsg ("failure to get source path/name\n"); break; } pb.dst_path = archive_name; name = string_rchr (pb.src_path, string_size (pb.src_path), '/'); if (name == NULL) name = pb.src_path; if (pcount == 1) { size_t size; rc = string_printf (archive_name, sizeof (archive_name), & size, "%s%s", name, pb.lite ? ".lite.sra" : ".sra"); if ( rc != 0 ) { rc = RC (rcExe, rcArgv, rcParsing, rcPath, rcInsufficient); PLOGERR (klogFatal, (klogFatal, rc, "Failure building archive name $(P)", "P=%s", archive_name)); break; } } else { rc = ArgsParamValue (args, 1, &pb.dst_path); if (rc) { LOGERR (klogInt, rc, "failure to get destination path"); break; } } if (rc == 0) { KPathType kpt; kpt = KDirectoryPathType (pwd, "%s", pb.dst_path); switch (kpt & ~kptAlias) { case kptNotFound: /* found nothing so assume its a valid new file name * not gonna tweak extensions at this point but that can be upgraded */ break; case kptFile: /* got a file name, use it - would need force... */ if (pb.force == false) { rc = RC (rcExe, rcArgv, rcParsing, rcPath, rcBusy); PLOGERR (klogFatal, (klogFatal, rc, "Output file already exists $(P)", "P=%s", archive_name)); } break; case kptDir: { size_t size; rc = string_printf (archive_name, sizeof (archive_name), & size, "%s/%s%s", pb.dst_path, name, pb.lite ? ".lite.sra" : ".sra"); if ( rc != 0 ) { rc = RC (rcExe, rcArgv, rcParsing, rcPath, rcInsufficient); PLOGERR (klogFatal, (klogFatal, rc, "Failure building archive name $(P)", "P=%s", archive_name)); break; } pb.dst_path = archive_name; break; } default: rc = RC (rcExe, rcArgv, rcParsing, rcPath, rcInvalid); break; } if (rc == 0) { STSMSG (1,("Creating archive (%s) from table (%s)\n", pb.dst_path, pb.src_path)); rc = run (&pb); STSMSG (5, ("Run exits with %d %R\n", rc, rc)); } } } while (0); } STSMSG (1, ("Exit status %u %R", rc, rc)); return rc; }