BOOL CBranch_patcherDlg::OnInitDialog() { CDialog::OnInitDialog(); SetIcon(m_hIcon, TRUE); // Set big icon SetIcon(m_hIcon, FALSE); // Set small icon // Extra initialization here RECT cltRect; GetClientRect( &cltRect ), m_Display = new CRichEditCtrl(); m_Display->Create( WS_CHILD|WS_VISIBLE|WS_BORDER|WS_HSCROLL|WS_VSCROLL|ES_AUTOHSCROLL|ES_AUTOVSCROLL|ES_MULTILINE, CRect( 20, 180, cltRect.right-20, cltRect.bottom-20 ), this, 1 ); // Initialize directories loadConfiguration(); processCommandLine(); displayTokens(); EnteringTokens = false; m_SrcDirLabel = "Source Dir"; m_TargetDirLabel = "Target Dir"; UpdateData( false ); ((CButton*)GetDlgItem( IDC_DoPatch ))->EnableWindow( FALSE ); return TRUE; // return TRUE unless you set the focus to a control }
int main(int argc, char **argv) { int retval( EXIT_FAILURE ); Environment.add( "WIPFC" ); if( Environment.value( "WIPFC" ).empty() ) { printBanner(); std::cout << "The 'WIPFC' environment variable needs to be set. "; std::cout << "It should contain the name of the directory containing .nls and entity.txt" << std::endl; return retval; } Environment.add( "IPFCARTWORK" ); Environment.add( "IPFCIMBED" ); Environment.add( "TMP" ); Compiler c; try { processCommandLine(argc, argv, c); if( c.banner() ) { printBanner(); } retval = c.compile(); } catch( FatalError& e ) { c.printError( e.code ); } catch( FatalIOError& e ) { c.printError( e.code, e.fname ); } return retval; }
int main(int argc, char** argv) { pthread_t * children; // dynamic array of child threads unsigned long id = 0; // loop control variable unsigned long numThreads = 0; // desired # of threads unsigned long sumSquares = 0; unsigned long childsSquare = 0; // get desired # of threads numThreads = processCommandLine(argc, argv); // allocate array of handles children = malloc( numThreads * sizeof(pthread_t) ); // FORK: for (id = 1; id < numThreads; id++) { pthread_create( &(children[id-1]), // our handle for the child NULL, // attributes of the child child, // the function it should run (void*) id ); // args to that function } printf("The parent (main) thread computed %lu.\n", sumSquares); for (id = 1; id < numThreads; id++) { // JOIN: pthread_join( children[id-1], (void**) &childsSquare ); sumSquares += childsSquare; } printf("\nThe sum of the squares from 1 to %lu is %lu.\n\n", numThreads-1, sumSquares); free(children); // deallocate array return 0; }
int main(int argc, char* argv[]){ float vNumber=0.3; CommandLineArgs myArgs{}; if(!processCommandLine(argc, argv, myArgs)){ std::cout<<"ERROR processing command line"<<"\n"; return 1; } if (myArgs.wantHelp){ printHelp(); return 0; } if (myArgs.wantVers){ printVersion(vNumber); return 0; } //std::cout<<"Command line inputted \n iValue = "<<(myArgs.iValue=="")<<"\n"; // The readStream functions handle the input of strings. It calls the transformChar function to ensure that all alphabet characters are capitalised and any other characters are ignored. std::string bigString{""}; if (myArgs.iValue == ""){ bigString= read(std::cin); } else{ std::ifstream in_file {myArgs.iValue}; if (in_file.good()){ bigString=read(in_file); } else { std::cout<<"Input file not OK to read \n"; return 1; } } //std::cout<<"Cipher choice = "<<myArgs.cipherChoice<<"\n"; std::string result; auto myCipher = CipherFactory(myArgs.cipherChoice, myArgs.kValue); if (myArgs.encOrDec) result = myCipher->encrypt(bigString); else if (myArgs.encOrDec == false) result = myCipher->decrypt(bigString); else std::cout<<"ERROR: Not sure whether to encrypt or decrypt \n"; // And now to out put the results if (myArgs.oValue==""){ std::cout<<"Result is here: "<<result<<"\n"; outPut(std::cout, result); } else { std::ofstream out_file{myArgs.oValue}; if (out_file.good()){ outPut (out_file, result); } else { return 1; } } }
int main(int argc, char* argv[]) { processCommandLine(argc, argv); //setParameters(); load(input, pps); fvision::exitIf(pps.size() == 0, string("can not get point correspondences from the input file: ") + infilepath + " !"); fvision::exitIf(pps.size() < 8, "at least 8 points should be input!"); FundamentalMatrixCalculatorFactory::Configuration config; if (homographyBased) config.method = FundamentalMatrixCalculatorFactory::Configuration::HOMOGRAPHY_BASED; config.ransacDistanceThreshold = threshold; if (verbose) { cout<<"configuration: "<<endl<<config<<endl; } pfmc = FundamentalMatrixCalculatorFactory().create(config); CvMatWrapper fw = pfmc->compute(pps); const CvMat* F = fw.getMat(); outputHelper.setDir(outputDir); outputHelper.setExtension("txt"); if (verbose) { cout<<"F: "<<endl<<F<<endl; } if (f_filename != NULL) { outputHelper.save(f_filename, fw); } evaluateF(F, pps); return 0; }
void IntlParametersBlock::processParametersBlock(ProcessString* processString, ClumpletWriter& pb) { for (pb.rewind(); !pb.isEof(); pb.moveNext()) { UCHAR tag = pb.getClumpTag(); string s; switch (checkTag(tag)) { case TAG_SKIP: break; case TAG_STRING: pb.getString(s); processString(s); pb.deleteClumplet(); pb.insertString(tag, s); break; case TAG_COMMAND_LINE: pb.getString(s); processCommandLine(processString, s); pb.deleteClumplet(); pb.insertString(tag, s); break; } } }
int main(int argc, char** argv){ processCommandLine(argc, argv); // sturm test of Wilk -- slow (about 3-4 min)! testSturm(legendre4); SS = * new Sturm<NT> (legendre4); Interval v = SS.isolateRoot(3); std::cout << "3rd Root = " << v.first << ", " << v.second << std::endl; v = SS.isolateRoot(1); std::cout << "1rd Root = " << v.first << ", " << v.second << std::endl; v = SS.isolateRoot(5); std::cout << "5rd Root = " << v.first << ", " << v.second << std::endl; v = SS.firstRootBelow(0); std::cout << "1st below 0 = " << v.first << ", " << v.second << std::endl; v = SS.firstRootBelow(100); std::cout << "1st below 100 = "<< v.first << ", " << v.second << std::endl; v = SS.firstRootAbove(0); std::cout << "1st above 0 = " << v.first << ", " << v.second << std::endl; v = SS.firstRootAbove(-100); std::cout << "1st above -100 = "<<v.first << ", " << v.second << std::endl; testSturm(wilk); return 0; }// main
/* main () ** ** Scan the command line arguments, then enter into the command loop. */ int main (int argc, char ** argv) { checkHostCompatibility (); checkArithmetic (); processCommandLine (argc, argv); /* If the "write" option (-w) was given, write a file to the DISK. */ if (commandOptionW) { writeCommand (); } else if (commandOptionI) { initializeCommand (); } else if (commandOptionL) { listCommand (); } else if (commandOptionC) { createCommand (); } else if (commandOptionR) { removeCommand (); } else if (commandOptionA) { addCommand (); } else if (commandOptionE) { extractCommand (); } else { fatalError ("No commands given; Use -h for help display"); return -1; } return 0; }
int main(int argc, char** argv) { pthread_t * children; // dynamic array of child threads unsigned long id = 0; // loop control variable unsigned long numThreads = 0; // desired # of threads // get desired # of threads numThreads = processCommandLine(argc, argv); // allocate array of handles children = malloc( numThreads * sizeof(pthread_t) ); // FORK: for (id = 1; id < numThreads; ++id) { pthread_create( &(children[id-1]), // our handle for the child NULL, // attributes of the child child, // the function it should run (void*) id ); // args to that function } do1000Transactions(0); for (id = 1; id < numThreads; ++id) { // JOIN: pthread_join( children[id-1], NULL ); } printf("\nThe final balance of the account using %lu threads is $%.2f.\n\n", numThreads, bankAccountBalance); free(children); // deallocate array cleanup(); // deallocate mutex return 0; }
int main(int argc, char** argv) { pthread_t * children; // dynamic array of child threads unsigned long id = 0; // loop control variable unsigned long numThreads = 0; // desired # of threads // get desired # of threads numThreads = processCommandLine(argc, argv); // allocate array of handles children = malloc( numThreads * sizeof(pthread_t) ); // FORK: for (id = 1; id < numThreads; id++) { pthread_create( &(children[id-1]), // our handle for the child NULL, // attributes of the child childGreetings, // the function it should run (void*) id ); // args to that function } printf("Greetings from the parent, thread #0.\n"); for (id = 1; id < numThreads; id++) { // JOIN: pthread_join( children[id-1], NULL ); } free(children); // deallocate array return 0; }
void IntlParametersBlock::processParametersBlock(ProcessString* processString, ClumpletWriter& pb) { const char* tagName = NULL; try { for (pb.rewind(); !pb.isEof(); ) { UCHAR tag = pb.getClumpTag(); string s; tagName = NULL; switch (checkTag(tag, &tagName)) { case TAG_SKIP: pb.moveNext(); break; case TAG_STRING: pb.getString(s); processString(s); pb.deleteClumplet(); pb.insertString(tag, s); break; case TAG_COMMAND_LINE: pb.getString(s); processCommandLine(processString, s); pb.deleteClumplet(); pb.insertString(tag, s); break; } } } catch (const Firebird::status_exception& st) { LocalStatus ls; CheckStatusWrapper l(&ls); st.stuffException(&l); if ((l.getState() & IStatus::STATE_ERRORS) && (l.getErrors()[1] == isc_bad_conn_str) && tagName) { Arg::Gds newErrors(isc_intl_char); newErrors << tagName; const ISC_STATUS* errors = l.getErrors(); newErrors << Arg::StatusVector(errors + 2); // skip isc_bad_conn_str l.setErrors(newErrors.value()); status_exception::raise(&l); } // other case leave exception as is throw; } }
/******** * main() ********/ int main( int argc, char *argv[] ) { struct packet p; char *device; int sd; char buffer[2000]; int bytes_read = 0; /* comprobamos que el usuario es root */ if( getuid() ) { printf( "You must be root to run this program\n" ); exit(1); } /* procesamos la línea de comandos */ processCommandLine( argc, argv, &device ); /* inicializamos el gestor de conexiones */ cntInitConnections(); /* inicializamos el sniffer */ sd = initSniffer( device ); /* inicializamos la interfaz de usuario */ if( uiInit() == -1 ) { printf( "Error inicializando la interfaz de usuario\n" ); exit(1); } /* bucle principal */ for(;;) { /* actualizamos interfaz de usuario */ if( uiUpdate() == FALSE ) break; /* si ha llegado un paquete, lo procesamos en la interfaz de usuario, por ahora */ if( bytes_read > 0 ) uiProcessPacket( &p ); /* refrescamos la interfaz de usuario */ uiRefresh(); /* leemos un paquete si hay */ bytes_read = readPacket( sd, buffer, 2000, &p ); } /* salimos de la aplicación */ uiEnd(); endSniffer( device, sd ); }
int main(int argc, char** argv) { exitFunction = myExit; NUM_BRANCHES = 1; // BAD if(argc < 2) { printUsage(std::cout); exitFunction(-1, false); } auto files = std::vector<std::string>{}; double burnin = 0; auto id = std::string{}; std::tie(id,files,burnin) = processCommandLine(argc, argv); for(auto f : files) std::cout << "file: " << f << std::endl; for(auto file : files) { if(not std::ifstream(file)) { std::cerr << "Error: could not open file >" << file << "<" << std::endl; exitFunction(-1, false); } } assert(files.size() > 0); auto&& bipEx = BipartitionExtractor(files, false, true); nat numTree = bipEx.getNumTreesInFile( files.at(0) ); // std::cout << "have "<< numTree << std::endl; nat absBurnin = nat(double(numTree) * burnin); bipEx.extractBips<true>(absBurnin); bipEx.printBipartitions(id); bipEx.printBipartitionStatistics(id); bipEx.printFileNames(id); bipEx.printBranchLengths(id); return 0; }
int main(int argc, char *argv[]) { CommandLineInfo info; processCommandLine(argc,argv,info); std::string in{""}; char in_char{'x'}; if(info.input_file_name == "") { while(std::cin >> in_char) // Builds output from input { in += transformChar(in_char); } } else {
int main(int argcc, char * argvc[]) { UNUSED(argcc); UNUSED(argvc); CHAR * argv[] = { "d2d.exe", //"test.apk", "-o", "output.dex", }; int argc = sizeof(argv)/sizeof(argv[0]); #else int main(int argc, char const* argv[]) { #endif int locerrno = 0; //0 indicates no error. long filelen; if (!processCommandLine(argc, argv)) { locerrno = -1; goto FIN; } if (g_tfile != NULL && g_dump_dex_file_path) { fprintf(g_tfile, "\n==---- %s ----==\n", g_dex_file_path); } if (d2dEntry(g_source_file_handler, g_output_file_handler, &filelen, false, g_dex_file_path) != 0) { locerrno = errno; LOGE("error: perform dexpro failed.\n"); } FIN: if (g_source_file_handler >= 0) { close(g_source_file_handler); } if (g_output_file_handler >= 0) { close(g_output_file_handler); } xoc::finidump(); return locerrno; //success. }
int main( int argc, char** argv ) { QApplication app( argc, argv ); Config* config = new Config( &app ); // If we can't process the command-line or set up the database // there's no point continuing if ( !processCommandLine() || !setupDatabase() ) return 0; QDeclarativeView view; view.connect( view.engine(), SIGNAL(quit()), SLOT(close()) ); view.setResizeMode( QDeclarativeView::SizeRootObjectToView ); // Register custom types for access to certail enums from QML qmlRegisterType< SoundEngine >( "net.randalflagg.llamaui", 1, 0, "SoundEngine" ); qmlRegisterType< KeyboardMap >( "net.randalflagg.llamaui", 1, 0, "KeyboardMap" ); qmlRegisterType< SystemProcess >( "net.randalflagg.llamaui", 1, 0, "SystemProcess" ); QDeclarativeContext* rootContext = view.rootContext(); // Initalise the keyboard key/action mapper if ( !initKeyboardMap( rootContext ) ) return 0; rootContext->setContextProperty( "config", config ); initSoundEngine( rootContext ); initGameMenu( rootContext ); initEmulatorMenu( rootContext ); initSystemMenu( rootContext ); initGameLauncher( rootContext ); // Create the interface QDir dir( Config::instance()->value( "paths", "qmlDir" ).toString() ); view.setSource( QUrl::fromLocalFile( dir.absoluteFilePath( "main.qml" ) ) ); view.showFullScreen(); // Hide the mouse cursor app.setOverrideCursor( QCursor( Qt::BlankCursor ) ); return app.exec(); }
int main(int argc, char** argv) { // Final sum unsigned long long finalSum; // Timing values clock_t startTime, stopTime; // Start the timer startTime = clock(); // Get the maximum N unsigned long long maximum = processCommandLine(argc, argv); finalSum = sum_range(0, maximum); // Start from 0 and go to the maximum (from command line) stopTime = clock(); printf("Final sum with 1 processor in %f seconds is: %llu\n", \ (double)(stopTime - startTime) / CLOCKS_PER_SEC, finalSum); return 0; }
/* main() ** ** Read and print .o file. */ int main (int argc, char ** argv) { int i, lineNumber; int magic; int sawEntryLabel; processCommandLine (argc, argv); printf ("===== HEADER INFO =====\n\n"); magic = readInteger (); if (magic == 0x424C5A6F) { printf ("magic number = BLZo (This is a '.o' file.)\n"); } else if (magic == 0x424C5A78) { printf ("magic number = BLZx (This is an 'a.out' file.)\n"); } else { fatalError ("Magic number is not 'BLZo' or 'BLZx'"); } if (magic == 0x424C5A78) { /* if we have an a.out file... */ textSize = readInteger (); dataSize = readInteger (); bssSize = readInteger (); printf (".text size = %08x (%d)\n", textSize, textSize); printf (".data size = %08x (%d)\n", dataSize, dataSize); printf (".bss size = %08x (%d)\n", bssSize, bssSize); textAddr = readInteger (); dataAddr = readInteger (); bssAddr = readInteger (); printf (".text load addr = %08x (%d)\n", textAddr, textAddr); printf (".data load addr = %08x (%d)\n", dataAddr, dataAddr); printf (".bss load addr = %08x (%d)\n", bssAddr, bssAddr); magic = readInteger (); if (magic != 0x2a2a2a2a) { fatalError ("Invalid file format - missing \"****\" separator"); } printf ("\n===== TEXT SEGMENT =====\n\n"); count = textSize; printSegment (textAddr); magic = readInteger (); if (magic != 0x2a2a2a2a) { fatalError ("Invalid file format - missing \"****\" separator"); } printf ("\n===== DATA SEGMENT =====\n\n"); count = dataSize; printSegment (dataAddr); magic = readInteger (); if (magic != 0x2a2a2a2a) { fatalError ("Invalid file format - missing \"****\" separator"); } printf ("\n===== LABEL INFORMATION =====\n\n"); printf ("Value (in decimal) Label\n"); printf ("==================== ==================\n"); while (1) { len = readInteger (); if (len <= 0) break; value = readInteger (); printf ("%08x%12d ", value, value); for (; len>0; len--) { i = readByte (); printf ("%c", i); } printf ("\n"); } magic = readInteger (); if (magic != 0x2a2a2a2a) { fatalError ("Invalid file format - missing \"****\" separator"); } } else { /* if we have an .o file... */ sawEntryLabel = readInteger (); if (sawEntryLabel == 1) { printf (".text contains _entry = TRUE\n"); } else if (sawEntryLabel == 0) { printf (".text contains _entry = FALSE\n"); } else { fatalError ("sawEntryLabel has invalid value"); } textSize = readInteger (); dataSize = readInteger (); bssSize = readInteger (); printf (".text size = %08x (%d)\n", textSize, textSize); printf (".data size = %08x (%d)\n", dataSize, dataSize); printf (".bss size = %08x (%d)\n", bssSize, bssSize); printf ("\n===== TEXT SEGMENT =====\n\n"); count = textSize; printSegment (0); magic = readInteger (); if (magic != 0x2a2a2a2a) { fatalError ("Invalid file format - missing \"****\" separator"); } printf ("\n===== DATA SEGMENT =====\n\n"); count = dataSize; printSegment (0); magic = readInteger (); if (magic != 0x2a2a2a2a) { fatalError ("Invalid file format - missing \"****\" separator"); } printf ("\n===== SYMBOL TABLE =====\n\n"); printf ("Number Value Relative to Symbol\n"); printf ("====== ======== =========== ======\n"); while (1) { symbolNum = readInteger (); if (symbolNum == 0) break; value = readInteger (); relativeTo = readInteger (); len = readInteger (); printf ("%d\t%08x\t%d\t", symbolNum, value, relativeTo); for (; len>0; len--) { i = readByte (); printf ("%c", i); } printf ("\n"); } magic = readInteger (); if (magic != 0x2a2a2a2a) { fatalError ("Invalid file format - missing \"****\" separator"); } printf ("\n===== RELOCATION INFO =====\n\n"); printf ("Type Locatn-to-modify New-val Rel-to Src-Line\n"); printf ("======= ================ ======== ====== ========\n"); while (1) { i = readInteger (); if (i == 0) { break; } else if (i == 1) { printf ("8-bit\t"); } else if (i == 2) { printf ("16-bit\t"); } else if (i == 3) { printf ("24-bit\t"); } else if (i == 4) { printf ("32-bit\t"); } else if (i == 5) { printf ("set-hi\t"); } else if (i == 6) { printf ("set-lo\t"); } else if (i == 7) { printf ("ldaddr\t"); } else { fatalError ("Invalid relocation record code"); } value = readInteger (); printf ("%08x ", value); i = readInteger (); if (i == 1) { printf (".text\t"); } else if (i == 2) { printf (".data\t"); } else { printf ("*****\t"); } value = readInteger (); printf (" %08x ", value); value = readInteger (); printf ("%4d ", value); lineNumber = readInteger (); printf ("%6d \n", lineNumber); } magic = readInteger (); if (magic != 0x2a2a2a2a) { fatalError ("Invalid file format - missing \"****\" separator"); } printf ("\n===== ADDRESS LABELS =====\n\n"); printf ("Segment Offset Label\n"); printf ("======= ======== =====\n"); while (1) { i = readInteger (); if (i == 0) break; if (i == 1) printf (".text\t"); if (i == 2) printf (".data\t"); if (i == 3) printf (".bss\t"); value = readInteger (); len = readInteger (); printf ("%08x ", value); for (; len>0; len--) { i = readByte (); printf ("%c", i); } printf ("\n"); } magic = readInteger (); if (magic != 0x2a2a2a2a) { fatalError ("Invalid file format - missing \"****\" separator"); } } return 0; }
// ----------------------------------------------------------------------------- // Application initialisation // ----------------------------------------------------------------------------- bool App::init(vector<std::string>& args, double ui_scale) { // Get the id of the current thread (should be the main one) main_thread_id = std::this_thread::get_id(); // Set locale to C so that the tokenizer will work properly // even in locales where the decimal separator is a comma. setlocale(LC_ALL, "C"); // Init application directories if (!initDirectories()) return false; // Init log Log::init(); // Process the command line arguments auto paths_to_open = processCommandLine(args); // Init keybinds KeyBind::initBinds(); // Load configuration file Log::info("Loading configuration"); readConfigFile(); // Check that SLADE.pk3 can be found Log::info("Loading resources"); archive_manager.init(); if (!archive_manager.resArchiveOK()) { wxMessageBox( "Unable to find slade.pk3, make sure it exists in the same directory as the " "SLADE executable", "Error", wxICON_ERROR); return false; } // Init SActions SAction::initWxId(26000); SAction::initActions(); // Init lua Lua::init(); // Init UI UI::init(ui_scale); // Show splash screen UI::showSplash("Starting up..."); // Init palettes if (!palette_manager.init()) { Log::error("Failed to initialise palettes"); return false; } // Init SImage formats SIFormat::initFormats(); // Init brushes SBrush::initBrushes(); // Load program icons Log::info("Loading icons"); Icons::loadIcons(); // Load program fonts Drawing::initFonts(); // Load entry types Log::info("Loading entry types"); EntryDataFormat::initBuiltinFormats(); EntryType::loadEntryTypes(); // Load text languages Log::info("Loading text languages"); TextLanguage::loadLanguages(); // Init text stylesets Log::info("Loading text style sets"); StyleSet::loadResourceStyles(); StyleSet::loadCustomStyles(); // Init colour configuration Log::info("Loading colour configuration"); ColourConfiguration::init(); // Init nodebuilders NodeBuilders::init(); // Init game executables Executables::init(); // Init main editor MainEditor::init(); // Init base resource Log::info("Loading base resource"); archive_manager.initBaseResource(); Log::info("Base resource loaded"); // Init game configuration Log::info("Loading game configurations"); Game::init(); // Init script manager ScriptManager::init(); // Show the main window MainEditor::windowWx()->Show(true); wxGetApp().SetTopWindow(MainEditor::windowWx()); UI::showSplash("Starting up...", false, MainEditor::windowWx()); // Open any archives from the command line for (auto& path : paths_to_open) archive_manager.openArchive(path); // Hide splash screen UI::hideSplash(); init_ok = true; Log::info("SLADE Initialisation OK"); // Show Setup Wizard if needed if (!setup_wizard_run) { SetupWizardDialog dlg(MainEditor::windowWx()); dlg.ShowModal(); setup_wizard_run = true; MainEditor::windowWx()->Update(); MainEditor::windowWx()->Refresh(); } return true; }
int main(int argc, char **argv) { exitFunction = myExit; NUM_BRANCHES = 1; // BAD if(argc < 2 ) { printUsage(std::cout); exitFunction(-1, false); } bool isMre = false; auto threshold = double{0.}; std::string id= {}; double burnin = 0; auto files = std::vector<std::string>{}; std::tie(id, files, burnin, threshold, isMre) = processCommandLine(argc, argv); for(auto &file : files) { if(not std::ifstream(file)) { std::cerr << "Error: could not open file >" << file << "<" << std::endl; exitFunction(-1, false); } } assert(threshold > 1); threshold /= 100.; auto&& ct = ConsensusTree(files, burnin, threshold,isMre); auto header = ct.getTreeHeader(); auto result = ct.getConsensusTreeString(false); auto type = ct.getType(); auto&& ss = std::stringstream{}; ss << PROGRAM_NAME << "_" << type << "Nexus." << id; auto &&ss2 = std::ostringstream{}; ss2 << PROGRAM_NAME << "_" << type << "Newick." << id ; if(std::ifstream(ss.str())) { std::cerr << std::endl << "File " << ss.str() << " already exists (probably \n" << "left over from a previous run). Please choose a new run-id or remove\n" << "previous output files." << std::endl; exitFunction(-1, false); } auto &&outfile = std::ofstream(ss.str()); outfile << header << result << std::endl; outfile << "end;" << std::endl; auto &&outfile2 = std::ofstream{ss2.str()}; outfile2 << ct.getConsensusTreeString(true) << std::endl; std::cout << "Printed consensus tree in nexus format to " << ss.str() << std::endl; std::cout << "Printed consensus tree in newick format to " << ss2.str() << std::endl; return 0; }
int main ( int argc, const char* argv[] ) { /* local function variables */ FILE* fp = NULL; long len = 0; char* file_buff = NULL; int status = EXIT_SUCCESS; FILE* fp_out = NULL; unsigned int i = 0; /* ------------------------- */ if(argc == 1) { printHeader(); printUsage(argv[0]); return status; } /* process commandline arguments */ processCommandLine(argc, argv); if((fp = fopen(binary_file, "rb")) == NULL) { printf("öaa"); printHeader(); printUnableToReadBinary(); status = EXIT_FAILURE; goto bail; } fseek(fp, 0, SEEK_END); len = ftell(fp); fseek(fp, 0, SEEK_SET); /* allocate memory for binary file */ if((file_buff = (char *)malloc((size_t)len)) == NULL) { printHeader(); printUnableToAllocateMemory(); status = EXIT_FAILURE; goto bail_1; } /* read binary */ if(fread(file_buff, 1, len, fp) != len) { printHeader(); printUnableToReadBinary(); status = EXIT_FAILURE; goto bail_2; } printf("\n"); printf(" [OK] - %s - binary successfully read.\n", binary_file); /* create/open output file */ fp_out = fopen(header_file, "w+b"); if(fp_out == NULL) { printHeader(); printUnableToCreateHeaderFile(); status = EXIT_FAILURE; goto bail_2; } printf(" [OK] - %s - header file ready for processing.\n", header_file); fprintf(fp_out, "#ifndef BLOBHEADER_H\n"); fprintf(fp_out, " #define BLOBHEADER_H\n"); fprintf(fp_out, "\n"); fprintf(fp_out, "static const char %s[] = \n", blob_name); fprintf(fp_out, "{\n"); /* process all bytes */ for(i = 1; i < len + 1; i++) { if((i - 1) % 8 == 0) { fprintf(fp_out, " "); } fprintf(fp_out, "(char)0x%02x", file_buff[i - 1] & 0xFF); if(i < len) { fprintf(fp_out, ", "); } else { fprintf(fp_out, "\n"); } if(i % 8 == 0) { fprintf(fp_out, "\n"); } } fprintf(fp_out, "};\n"); fprintf(fp_out, "\n"); fprintf(fp_out, "#endif"); fprintf(fp_out, "\n"); fclose(fp_out); printf(" [OK] - successfully finished!\n"); printf("\n"); /* everything went fine */ bail_2: free(file_buff); bail_1: fclose(fp); bail: fflush(stdout); return EXIT_SUCCESS; }
int main(int in_argc, const char* in_argv[]) { MPMGlobalState::initGlobalState(); if (processCommandLine(in_argc, in_argv) == false) { cout << "MPMerger v" << sg_pProgramVersion << '\n' << " MultiPalette Merger\n" << " @ Dynamix 1998, Original author Dave Moore\n\n"; usage(); return EXIT_FAILURE; } MPMGlobalState* pGlobalState = MPMGlobalState::getGlobalState(); // Set up the options for this run... // MPMOptions instOptions; // Options for this run MPMFileList procFileList; // List of files to process if (instOptions.attachResponseFile(pGlobalState->getResponseFileName()) == false) { cerr << "Unable to open response file: " << pGlobalState->getResponseFileName() << '\n' << " - ABORTING - \n"; return EXIT_FAILURE; } if (instOptions.validateOptions() == false) { cerr << "Invalid options detected, exiting...\n\n"; exit(1); } instOptions.processResponseFile(procFileList); AssertFatal(procFileList.getNumFiles() <= MAX_MULTI_PALETTES, "Too many palettes, exiting..."); // Whether we are choosing colors or rendering, we need the unquantized palettes, // so load them into memory... // for (int i = 0; i < procFileList.getNumFiles(); i++) { MPMFileEntry& rFileEntry = procFileList.getFile(i); AssertFatal(rFileEntry.pRawPalette == NULL, "Huh?"); AssertFatal(rFileEntry.pFileName != NULL, "Huh?"); rFileEntry.pRawPalette = GFXPalette::load(rFileEntry.pFileName); if (rFileEntry.pRawPalette == NULL) { cerr << "main(): Unable to load file: " << rFileEntry.pFileName << '\n'; exit(1); } } // We will need an authoritative final palette either way as well... // GFXPalette* pFinalMasterPalette = new GFXPalette; memset(pFinalMasterPalette->palette[0].color, 0, sizeof(PALETTEENTRY) * 256); if (instOptions.hasBasePalette() == true) { const char* pPaletteName = instOptions.getBasePalName(); AssertFatal(pPaletteName != NULL, "No base palette name? Here?"); Bool palLoadSuccess = pFinalMasterPalette->read(pPaletteName); if (palLoadSuccess == false) { cerr << "Unable to load base palette: " << pPaletteName << ". Exiting...\n"; exit(1); } } // We are always choosing colors for the master palette, so create a Popularity Table, // and register our colors... // MPMPopularityTable popTable(instOptions); popTable.prepFixedColors(instOptions, pFinalMasterPalette); bool haveSomeRealColors = false; for (int i = 0; i < procFileList.getNumFiles(); i++) { MPMFileEntry& rFileEntry = procFileList.getFile(i); AssertFatal(rFileEntry.pRawPalette != NULL, "Huh?"); if (rFileEntry.pRawPalette->palette[0].paletteType == GFXPalette::ColorQuantPaletteType) { printf("."); popTable.registerRGBColors(rFileEntry.pRawPalette, rFileEntry.fileWeight); haveSomeRealColors = true; } else printf("*"); } // If we have NO files, we're just copying from the base palette to the new palette... if (procFileList.getNumFiles() == 0) { } else { AssertFatal(haveSomeRealColors == true, "Must have a least _one_ non-alpha palette..."); // Quantize out the master palette.. popTable.quantizeColors(instOptions, pFinalMasterPalette); } // Insert the mandatory entries into the master palette. These are: // palette[0].type = HazeShadePaletteType // palette[0].index = DWORD(-1) // color[0]: (0, 0, 0) // color[255]: (1, 1, 1) // color[254]: instOptions.hazeColor // hazeColor: 254 // correct bitvector entries. renderStart-Last + 0, 254, 254 // PALETTEENTRY hazeColor; PALETTEENTRY black, white; black.peRed = black.peGreen = black.peBlue = black.peFlags = 0; white.peRed = white.peGreen = white.peBlue = 255; white.peFlags = 0; hazeColor.peRed = UInt8((instOptions.getHazeColor().red * 255.0f) + 0.5f); hazeColor.peGreen = UInt8((instOptions.getHazeColor().green * 255.0f) + 0.5f); hazeColor.peBlue = UInt8((instOptions.getHazeColor().blue * 255.0f) + 0.5f); hazeColor.peFlags = 0; pFinalMasterPalette->palette[0].color[0] = black; pFinalMasterPalette->palette[0].color[255] = white; pFinalMasterPalette->palette[0].color[254] = hazeColor; pFinalMasterPalette->palette[0].paletteIndex = DWORD(-1); pFinalMasterPalette->palette[0].paletteType = GFXPalette::ShadeHazePaletteType; pFinalMasterPalette->hazeColor = 254; UInt32 renderFirst, renderLast; instOptions.getMasterRenderRange(renderFirst, renderLast); pFinalMasterPalette->allowedColorMatches.zero(); for (UInt32 i = renderFirst; i <= renderLast; i++) pFinalMasterPalette->allowedColorMatches.set(i); pFinalMasterPalette->allowedColorMatches.set(0); // pFinalMasterPalette->allowedColorMatches.set(255); pFinalMasterPalette->allowedColorMatches.set(254); // Insert the shadow palette... // pFinalMasterPalette->palette[1].paletteIndex = -2; pFinalMasterPalette->palette[1].paletteType = GFXPalette::TranslucentPaletteType; for (int i = 0; i < 256; i++) { pFinalMasterPalette->palette[1].color[i].peRed = 0; pFinalMasterPalette->palette[1].color[i].peGreen = 0; pFinalMasterPalette->palette[1].color[i].peBlue = 0; pFinalMasterPalette->palette[1].color[i].peFlags = i; } pFinalMasterPalette->numPalettes++; // Ok, now we need to map the multipalettes into the master palette... // MPMMerger mpmMerger(instOptions); for (int i = 0; i < procFileList.getNumFiles(); i++) { MPMFileEntry& rFileEntry = procFileList.getFile(i); mpmMerger.insertPalette(pFinalMasterPalette, rFileEntry.pRawPalette); } // And create the remap tables if necessary... // mpmMerger.createRemapTables(pFinalMasterPalette); // And we are DONE! Write out the master palette to the specified name... // // First make sure that in no palettes any color other than 0 is fully black // for (int i = 0; i < pFinalMasterPalette->numPalettes; i++) { GFXPalette::MultiPalette& rMPalette = pFinalMasterPalette->palette[i]; for (int j = 1; j < 256; j++) { PALETTEENTRY& rPEntry = rMPalette.color[j]; if (rPEntry.peRed == 0 && rPEntry.peGreen == 0 && rPEntry.peBlue == 0) rPEntry.peBlue = 1; } } AssertFatal(instOptions.getOutputPalName() != NULL, "Error, no output name!"); pFinalMasterPalette->write(instOptions.getOutputPalName()); //-------------------------------------- Clean-up delete pFinalMasterPalette; MPMGlobalState::shutdownGlobalState(); return EXIT_SUCCESS; }
int _tmain(int argc, _TCHAR* argv[]) { FILE* f; KTX_error_code ret; KTX_texture_info tinfo; KTX_image_info* infiles; struct commandOptions options; unsigned int imageSize; int exitCode = 0, face, i; unsigned int levelWidth, levelHeight; FileResult readResult; boolean useStdin = false; unsigned char* kvData = NULL; unsigned int kvDataLen = 0; processCommandLine(argc, argv, options); infiles = new KTX_image_info[options.numInputFiles]; if (options.cubemap) tinfo.numberOfFaces = 6; else tinfo.numberOfFaces = 1; // TO DO: handle array textures tinfo.numberOfArrayElements = 0; // TO DO: handle 3D textures. Concatenate the files here or in WriteKTXF? if (!options.lower_left_maps_to_s0t0) { // Non-standard orientation. Add metadata. KTX_hash_table ht = ktxHashTable_Create(); char orientation[10]; assert(strlen(KTX_ORIENTATION2_FMT) < sizeof(orientation)); _snprintf(orientation, sizeof(orientation), KTX_ORIENTATION2_FMT, 'r', 'd'); ktxHashTable_AddKVPair(ht, KTX_ORIENTATION_KEY, strlen(orientation) + 1, orientation); if (KTX_SUCCESS != ktxHashTable_Serialize(ht, &kvDataLen, &kvData)) { fprintf(stderr, "%s: Out of memory\n", options.appName); exit(2); } ktxHashTable_Destroy(ht); } for (i = 0; i < options.numInputFiles; i++) { _TCHAR* infile; if (options.useStdin) { infile = 0; f = stdin; if (WIN32) { /* Set "stdin" to have binary mode */ (void)_setmode( _fileno( stdin ), _O_BINARY ); } } else { infile = argv[options.firstInfileIndex + i]; f = fopen(infile,"rb"); } if (f) { unsigned int w, h, components, componentSize; unsigned char* srcImg; readResult = readNPBM(f, w, h, components, componentSize, imageSize, srcImg); if (SUCCESS == readResult) { /* Sanity check. */ assert(w * h * componentSize * components == imageSize); #if IMAGE_DEBUG dumpImage(infile, w, h, components, componentSize, options.luminance, srcImg); #endif if (h > 1 && options.lower_left_maps_to_s0t0) yflip(srcImg, imageSize, w, h, components*componentSize); infiles[i].size = imageSize; infiles[i].data = srcImg; if (i == 0) { if (componentSize == 1) { tinfo.glType = GL_UNSIGNED_BYTE; tinfo.glTypeSize = 1; } else { tinfo.glType = GL_UNSIGNED_SHORT; tinfo.glTypeSize = 2; } switch (components) { case 1: if (options.luminance) { tinfo.glFormat = tinfo.glBaseInternalFormat = GL_LUMINANCE; if (options.sized) tinfo.glInternalFormat = componentSize == 1 ? GL_LUMINANCE8 : GL_LUMINANCE16; else tinfo.glInternalFormat = GL_LUMINANCE; } else if (options.alpha) { tinfo.glFormat = tinfo.glBaseInternalFormat = GL_ALPHA; if (options.sized) tinfo.glInternalFormat = componentSize == 1 ? GL_ALPHA8 : GL_ALPHA16; else tinfo.glInternalFormat = GL_ALPHA; } else { tinfo.glFormat = tinfo.glBaseInternalFormat = GL_RED; if (options.sized) tinfo.glInternalFormat = componentSize == 1 ? GL_R8 : GL_R16; else tinfo.glInternalFormat = GL_RED; } break; case 2: if (options.luminance) { tinfo.glFormat = tinfo.glBaseInternalFormat = GL_LUMINANCE_ALPHA; if (options.sized) tinfo.glInternalFormat = componentSize == 1 ? GL_LUMINANCE8_ALPHA8 : GL_LUMINANCE16_ALPHA16; else tinfo.glInternalFormat = GL_LUMINANCE_ALPHA; } else { tinfo.glFormat = tinfo.glBaseInternalFormat = GL_RG; if (options.sized) tinfo.glInternalFormat = componentSize == 1 ? GL_RG8 : GL_RG16; else tinfo.glInternalFormat = GL_RG; } break; case 3: tinfo.glFormat = tinfo.glBaseInternalFormat = GL_RGB; if (options.sized) tinfo.glInternalFormat = componentSize == 1 ? GL_RGB8 : GL_RGB16; else tinfo.glInternalFormat = GL_RGB; break; case 4: tinfo.glFormat = tinfo.glBaseInternalFormat = GL_RGBA; if (options.sized) tinfo.glInternalFormat = componentSize == 1 ? GL_RGBA8 : GL_RGBA16; else tinfo.glInternalFormat = GL_RGBA; break; break; default: /* If we get here there's a bug in readPAM */ assert(0); } tinfo.pixelWidth = levelWidth = w; tinfo.pixelHeight = levelHeight = h; tinfo.pixelDepth = 0; if (h == 1 && kvData != NULL) { /* 1D. Don't need orientation metadata */ delete(kvData); kvData = NULL; kvDataLen = 0; } face = tinfo.numberOfFaces; if (options.automipmap) tinfo.numberOfMipmapLevels = 0; else if (options.mipmap) { // Calculate number of miplevels GLuint max_dim = w > h ? w : h; GLint levels = log2(max_dim) + 1; // Check we have enough. if (levels * face > options.numInputFiles) { fprintf(stderr, "%s: not enough input files for %d mipmap levels and faces\n", options.appName, levels); exitCode = 1; goto cleanup2; } tinfo.numberOfMipmapLevels = levels; } else tinfo.numberOfMipmapLevels = 1; } else { if (options.mipmap) { if (face == 0) { levelWidth >>= 1; levelHeight >>= 1; if (w != levelWidth || h != levelHeight) { fprintf(stderr, "%s: \"%s\" has incorrect width or height for current mipmap level\n", options.appName, infile); exitCode = 1; goto cleanup2; } face = options.cubemap ? 6 : 1; } } } face--; if (options.cubemap && w != h && w != levelWidth) { fprintf(stderr, "%s: \"%s,\" intended for a cubemap face, is not square or has incorrect\n" "size for current mipmap level\n", options.appName, infile); exitCode = 1; goto cleanup2; } } else {
int main(int argc, const char* argv[]) { PNGlobalState::initGlobalState(); if (processCommandLine(argc, argv) == false) { cout << "PicaNew v" << sg_pProgramVersion << '\n' << " Based on Pica by Joel Franklin which was\n" << " Based on DynaColor by Rhett Anderson\n" << " Glorious Thanks and Praise to the PNG and ZLib Folks...\n" << " @ Dynamix 1998, Original author Dave Moore\n\n"; usage(); return EXIT_FAILURE; } PNGlobalState* pGlobalState = PNGlobalState::getGlobalState(); PNOptions instOptions; // Options for this run PNFileList procFileList; // List of files to process if (instOptions.attachResponseFile(pGlobalState->getResponseFileName()) == false) { cerr << "Unable to open response file: " << pGlobalState->getResponseFileName() << '\n' << " - ABORTING - \n"; return EXIT_FAILURE; } if (instOptions.validateOptions() == false) { cerr << "Invalid options detected, exiting...\n\n"; exit(1); } instOptions.processResponseFile(procFileList); // Whether we are choosing colors or rendering, we need the unquantized images, // so load them into memory... // PNUQImageFactory& rUQFactory = PNUQImageFactory::getInstance(); for (int i = 0; i < procFileList.getNumFiles(); i++) { PNFileEntry& rFileEntry = procFileList.getFile(i); AssertFatal(rFileEntry.pUQImage == NULL, "Huh?"); AssertFatal(rFileEntry.pFileName != NULL, "Huh?"); rFileEntry.pUQImage = rUQFactory.createUQImage(rFileEntry.pFileName); if (rFileEntry.pUQImage == NULL) { cerr << "main(): Unable to load file: " << rFileEntry.pFileName << '\n'; exit(1); } } // We will need an authoritative final palette either way as well... // GFXPalette* pAuthPalette = new GFXPalette; memset(pAuthPalette->palette[0].color, 0, sizeof(PALETTEENTRY) * 256); if (instOptions.hasBasePalette() == true) { const char* pPaletteName = instOptions.getBasePalName(); AssertFatal(pPaletteName != NULL, "No base palette name? Here?"); if (strstr(pPaletteName, ".tap") == NULL && strstr(pPaletteName, ".TAP") == NULL) { Bool palLoadSuccess = pAuthPalette->read(pPaletteName); if (palLoadSuccess == false) { cerr << "Unable to load base palette: " << pPaletteName << ". Exiting...\n"; exit(1); } } else { FILE *fp; if((fp = fopen(pPaletteName, "rb")) == NULL) { cerr << "ERROR - Cannot read Palette from : " << pPaletteName << "\n"; exit(0); } for (int i = 0; i < 256; i++) { int red, green, blue, alpha; fscanf(fp, "%d %d %d %d", &red, &green, &blue, &alpha); pAuthPalette->palette[0].color[i].peRed = UInt8(red); pAuthPalette->palette[0].color[i].peGreen = UInt8(green); pAuthPalette->palette[0].color[i].peBlue = UInt8(blue); pAuthPalette->palette[0].color[i].peFlags = UInt8(alpha); } fclose(fp); } } // Always, always, always, the first color must be all 0 // memset(&(pAuthPalette->palette[0].color[0]), 0, sizeof(PALETTEENTRY)); // If we are choosing colors, set up the popularity table, and go to it... // if (instOptions.areChoosingColors() == true && procFileList.getNumFiles() != 0) { PNPopularityTable popularityTable(instOptions); // Files must register their colors with the popularity table.. // PseudoTrace& tracer = PseudoTrace::getTracerObject(); tracer.pushVerbosityLevel(1); tracer << "Scanning: "; for (int i = 0; i < procFileList.getNumFiles(); i++) { PNFileEntry& rFileEntry = procFileList.getFile(i); AssertFatal(rFileEntry.pUQImage != NULL, "Huh?"); rFileEntry.pUQImage->registerColors(popularityTable, rFileEntry.fileWeight); tracer << '.'; tracer.flush(); } tracer << " done\n"; tracer.popVerbosityLevel(); // Set up any fixed colors that may be required... // popularityTable.prepFixedColors(instOptions, pAuthPalette); // And quantize away! // popularityTable.quantizeColors(instOptions, pAuthPalette); } // If we are rendering the bitmaps, set up a color matching ditherer, and // render away! // if (instOptions.areRenderingBitmaps() == true && procFileList.getNumFiles() != 0) { PNQuantizedRenderer pnRenderer(instOptions, pAuthPalette); PseudoTrace& tracer = PseudoTrace::getTracerObject(); tracer.pushVerbosityLevel(1); tracer << "Rendering: "; for (int i = 0; i < procFileList.getNumFiles(); i++) { PNFileEntry& rFileEntry = procFileList.getFile(i); AssertFatal(rFileEntry.pUQImage != NULL, "Huh?"); pnRenderer.renderUQImage(rFileEntry.pUQImage); if (instOptions.getExtrudingMipLevels() == false) tracer << '.'; else tracer << '*'; tracer.flush(); } tracer << " done\n"; tracer.popVerbosityLevel(); // Store off the computed weights into the Palette... // const UInt32* pChosenFreqs = pnRenderer.getChosenFreqs(); if (pAuthPalette->hasQuantizationInfo() == false) pAuthPalette->initQuantizationInfo(); for (int i = 0; i < 256; i++) pAuthPalette->m_pColorWeights[i] += float(pChosenFreqs[i]); UInt32 renderStart, renderEnd; instOptions.getRenderRange(renderStart, renderEnd); pAuthPalette->m_usedRangeStart = renderStart; pAuthPalette->m_usedRangeEnd = renderEnd; } // Write out the palette, and we're finished! // if (instOptions.getStripQuantizationInfo() == true) pAuthPalette->stripQuantizationInfo(); if (instOptions.areChoosingColors() == true) { // First copy in the unique paletteKey, which we stuff into index 0 // pAuthPalette->palette[0].paletteIndex = instOptions.getPaletteKey(); // Now, technically, we're lying a bit about which type of palette this is, // but the mpMerger tool will fix this up for us... // if (instOptions.getColorSpace() == PNOptions::ColorSpaceAlpha) { pAuthPalette->palette[0].paletteType = GFXPalette::AlphaQuantPaletteType; } else if (instOptions.getColorSpace() == PNOptions::ColorSpaceAdditive) { pAuthPalette->palette[0].paletteType = GFXPalette::AdditiveQuantPaletteType; } else if (instOptions.getColorSpace() == PNOptions::ColorSpaceSubtractive) { pAuthPalette->palette[0].paletteType = GFXPalette::SubtractiveQuantPaletteType; } else { pAuthPalette->palette[0].paletteType = GFXPalette::ColorQuantPaletteType; } if (instOptions.isStandAlonePalette() == true) { pAuthPalette->palette[0].paletteType = GFXPalette::NoRemapPaletteType; } for (int i = 1; i < 256; i++) { PALETTEENTRY& rPEntry = pAuthPalette->palette[0].color[i]; if (rPEntry.peRed == 0 && rPEntry.peGreen == 0 && rPEntry.peBlue == 0) rPEntry.peBlue = 1; } // Write out our auth palette to the specified output name... // const char* pPaletteName = instOptions.getOutputPalName(); pAuthPalette->write(pPaletteName); } else if (instOptions.areRenderingBitmaps() == true) { // Just write the palette back out to the base palette... // AssertFatal(instOptions.hasBasePalette() == true, "If we aren't choosing colors, we must have a base palette..."); pAuthPalette->write(instOptions.getBasePalName()); } else { // Write out our auth palette to the specified output name... // pAuthPalette->palette[0].paletteIndex = instOptions.getPaletteKey(); const char* pPaletteName = instOptions.getOutputPalName(); if (pPaletteName != NULL) pAuthPalette->write(pPaletteName); } // Cleanup delete pAuthPalette; instOptions.unattachResponseFile(); PNGlobalState::shutdownGlobalState(); return EXIT_SUCCESS; }
/** * XdmfExodusConverter is a command line utility for converting * between Xdmf and Exodus files. If given an Xdmf file, the tool * converts the file to Exodus and if given a path to an Exodus file, * the tool converts the file to Xdmf. * * Usage: * XdmfExodusConverter <path-of-file-to-convert> * (Optional: <path-to-output-file>) * */ int main(int argc, char* argv[]) { std::string inputFileName = ""; std::string outputFileName = ""; processCommandLine(inputFileName, outputFileName, argc, argv); FILE * refFile = fopen(inputFileName.c_str(), "r"); if (refFile) { // Success fclose(refFile); } else { std::cout << "Cannot open file: " << argv[1] << std::endl; return 1; } std::string meshName; if(outputFileName.compare("") == 0) { meshName = inputFileName; } else { meshName = outputFileName; } if(meshName.find_last_of("/\\") != std::string::npos) { meshName = meshName.substr(meshName.find_last_of("/\\") + 1, meshName.length()); } if (meshName.rfind(".") != std::string::npos) { meshName = meshName.substr(0, meshName.rfind(".")); } int CPU_word_size = sizeof(double); int IO_word_size = 0; // Get from file float version; const int exodusHandle = ex_open(argv[1], EX_READ, &CPU_word_size, &IO_word_size, &version); if(exodusHandle < 0) { // Xdmf to Exodus shared_ptr<XdmfReader> reader = XdmfReader::New(); shared_ptr<XdmfDomain> domain = shared_dynamic_cast<XdmfDomain>(reader->read(inputFileName)); std::stringstream exodusFileName; exodusFileName << meshName << ".exo"; shared_ptr<XdmfExodusWriter> writer = XdmfExodusWriter::New(); if(domain->getNumberUnstructuredGrids() == 1) { const shared_ptr<XdmfUnstructuredGrid> grid = domain->getUnstructuredGrid(0); writer->write(exodusFileName.str(), grid); std::cout << "Wrote: " << exodusFileName.str() << std::endl; } else if(domain->getNumberGridCollections() == 1) { const shared_ptr<XdmfGridCollection> grid = domain->getGridCollection(0); writer->write(exodusFileName.str(), grid); std::cout << "Wrote: " << exodusFileName.str() << std::endl; } else { XdmfError::message(XdmfError::FATAL, "Cannot find grid in Xdmf file to convert to " "exodus."); } } else { // Exodus to Xdmf std::stringstream heavyFileName; heavyFileName << meshName << ".h5"; shared_ptr<XdmfHDF5Writer> heavyDataWriter = XdmfHDF5Writer::New(heavyFileName.str()); heavyDataWriter->setReleaseData(true); shared_ptr<XdmfExodusReader> exodusReader = XdmfExodusReader::New(); shared_ptr<XdmfUnstructuredGrid> readGrid = exodusReader->read(inputFileName, heavyDataWriter); shared_ptr<XdmfDomain> newDomain = XdmfDomain::New(); newDomain->insert(readGrid); std::stringstream xmlFileName; xmlFileName << meshName << ".xmf"; shared_ptr<XdmfWriter> writer = XdmfWriter::New(xmlFileName.str(), heavyDataWriter); newDomain->accept(writer); std::cout << "Wrote: " << xmlFileName.str() << std::endl; } }
int main(int argc, char* argv[]) { //testCipher(); CommandLineArguments args{false, false, false, "", "", "", ""}; int retCode = processCommandLine(argc, argv, args); if(retCode != 0) { return retCode; } // Use standard input by default std::ifstream inputStream{}; if(!args.inputFilename.empty()) { // Try to use the input file inputStream.open(args.inputFilename); if(!inputStream.good()) { std::cout << "Error: Could not open " << args.inputFilename << std::endl; return 1; } } std::ofstream outputStream{}; if(!args.outputFilename.empty()) { // Try to use the output file outputStream.open(args.outputFilename); if(!outputStream.good()) { std::cout << "Error: Could not open " << args.outputFilename << std::endl; return 1; } } std::string text = processInput( args.inputFilename.empty() ? std::cin : inputStream); std::string input{}; for(char c : text) { input.append(transformChar(c)); } std::unique_ptr<Cipher> cipher; if(args.cipher == "caesar") { cipher = cipherFactory(CipherTypes::CAESAR); } else if(args.cipher == "playfair") { cipher = cipherFactory(CipherTypes::PLAYFAIR); } else if(args.cipher == "vigenere") { cipher = cipherFactory(CipherTypes::VIGENERE); } (*cipher).setKey(args.key); if(args.encrypt) { std::string ciphertext = (*cipher).encode(input); processOutput( args.outputFilename.empty() ? std::cout : outputStream, ciphertext); } else { std::string plaintext = (*cipher).decode(input); processOutput( args.outputFilename.empty() ? std::cout : outputStream, plaintext); } return 0; }
int main(int argc, char **argv) { QApplication app(argc, argv); App::initializeDependencies(); auto aboutData = App::getAboutData(); QCommandLineParser parser; KAboutData::setApplicationData(aboutData); parser.addVersionOption(); parser.addHelpOption(); aboutData.setupCommandLine(&parser); parser.process(app); aboutData.processCommandLine(&parser); KSharedConfig::Ptr config = KSharedConfig::openConfig(QStringLiteral("zanshin-migratorrc")); KConfigGroup group = config->group("Migrations"); if (!group.readEntry("Migrated021Projects", false)) { std::cerr << "Migrating data from zanshin 0.2, please wait..." << std::endl; QProcess proc; proc.start(QStringLiteral("zanshin-migrator")); proc.waitForFinished(-1); if (proc.exitStatus() == QProcess::CrashExit) { std::cerr << "Migrator crashed!" << std::endl; } else if (proc.exitCode() == 0) { std::cerr << "Migration done" << std::endl; } else { std::cerr << "Migration error, code" << proc.exitCode() << std::endl; } } auto widget = new QWidget; auto components = new Widgets::ApplicationComponents(widget); components->setModel(Presentation::ApplicationModel::Ptr::create()); auto layout = new QVBoxLayout; layout->setContentsMargins(0, 0, 0, 0); layout->addWidget(components->pageView()); widget->setLayout(layout); auto sourcesDock = new QDockWidget(QObject::tr("Sources")); sourcesDock->setObjectName(QStringLiteral("sourcesDock")); sourcesDock->setWidget(components->availableSourcesView()); auto pagesDock = new QDockWidget(QObject::tr("Pages")); pagesDock->setObjectName(QStringLiteral("pagesDock")); pagesDock->setWidget(components->availablePagesView()); auto editorDock = new QDockWidget(QObject::tr("Editor")); editorDock->setObjectName(QStringLiteral("editorDock")); editorDock->setWidget(components->editorView()); auto window = new KXmlGuiWindow; window->setCentralWidget(widget); window->addDockWidget(Qt::RightDockWidgetArea, editorDock); window->addDockWidget(Qt::LeftDockWidgetArea, pagesDock); window->addDockWidget(Qt::LeftDockWidgetArea, sourcesDock); auto actions = components->globalActions(); actions.insert(QStringLiteral("dock_sources"), sourcesDock->toggleViewAction()); actions.insert(QStringLiteral("dock_pages"), pagesDock->toggleViewAction()); actions.insert(QStringLiteral("dock_editor"), editorDock->toggleViewAction()); auto ac = window->actionCollection(); ac->addAction(KStandardAction::Quit, window, SLOT(close())); for (auto it = actions.constBegin(); it != actions.constEnd(); ++it) { auto shortcut = it.value()->shortcut(); if (!shortcut.isEmpty()) { ac->setDefaultShortcut(it.value(), shortcut); } ac->addAction(it.key(), it.value()); } window->setupGUI(QSize(1024, 600), KXmlGuiWindow::ToolBar | KXmlGuiWindow::Keys | KXmlGuiWindow::Save | KXmlGuiWindow::Create); window->show(); return app.exec(); }