int main(int argc, char *argv[]) { // First check for special commands if (argc >= 2) { if (argv[1] == std::string("--help")) { printHelpMessage(std::cout, true); exit(EXIT_SUCCESS); } } // Enter interactive mode if less than one argument is provided // (the first argument is the name of the command) if (argc <= 1) { interactiveMode(); } else { // Join all arguments, ignoring spaces // EDIT: Ignore the first argument. Is value is 'bin/eval-test' std::string input = ""; for (int i = 1; i < argc; i++) { input += argv[i]; } commandLineMode(input); } }
void processArgs(int numInputArgs, char *strings[]){ if(numInputArgs < 2){ printUsage(strings[0]); } int curLength = 0, i = 0, j = 0; // TODO - check for unknown arguments for(i = 0; i < numInputArgs; i++){ if(strings[i][0] == '-'){ curLength = strlen(strings[i]); for(j = 0; j < sizeof(simpleArgs) / sizeof(char); j++){ if(findInString(simpleArgs[j], strings[i], strlen(strings[i])) > 0){ if(simpleArgs[j] == 'h'){ printHelpMessage(strings[0]); } mapper.setSimpleArg(simpleArgs[j], true); } else if(!mapper.getSimpleArg(simpleArgs[j])){ // don't unset mapper.setSimpleArg(simpleArgs[j], false); } } for(j = 0; j < sizeof(compoundArgs) / sizeof(char); j++){ // disallow compound args in clusters if(findInString(compoundArgs[j], strings[i], strlen(strings[i])) != -1){ if(curLength > 2 || i+1 == numInputArgs){ printUsage(strings[0]); } else { mapper.setCompoundArg(compoundArgs[j], strings[i+1]); } } } } } }
int main(int argc, char *argv[]){ if(argc <= 1){ printHelpMessage(); return 0; } if(!strcmp(argv[1], "add") && argc == 4){ addNewSource(argv[2], argv[3]); } return 0; }
int main(int argc, char **argv) { if (argc < 2) { printHelpMessage(); return -1; } MP4Container_t *container = new_mp4_container(argv[1]); AVCCAtom_t *avc = get_video_info(container); if (avc == NULL) { printf("FAILED: Didn't find the avcC atom\n"); return -1; } printf("\n avcC atom @ %d - length: %d", avc->position, avc->length); print_buffer_data(avc->bytes, avc->size); printf("\n"); for (size_t i = 0; i < avc->number_of_sps_nalus; i++) { SPS_t *sps = avc->sps_array[i]; printf(" SPS #%ld - size: %d", i + 1, sps->size); print_buffer_data(sps->bytes, sps->size); printf("\n"); } for (size_t i = 0; i < avc->number_of_pps_nalus; i++) { PPS_t *pps = avc->pps_array[i]; printf(" PPS #%ld - size %d", i + 1, pps->size); print_buffer_data(pps->bytes, pps->size); printf("\n"); } printf(" version: %d\n", avc->version); printf(" profile: %d\n", avc->profile); printf(" compatibility: %d\n", avc->compatibility); printf(" level: %d\n", avc->level); printf(" reserved: %d\n ", avc->reserved); print_byte(avc->reserved); printf("\n"); printf(" nalu_length_minus_one: %d\n", avc->nalu_length_minus_one); printf(" reserved: "); print_byte(avc->reserved_after_length_minus_one); printf("\n"); printf(" number_of_sps_nalus: %d\n", avc->number_of_sps_nalus); printf(" number_of_pps_nalus: %d\n", avc->number_of_pps_nalus); close_mp4_container(container); }
void cloptparser::CLOptParser::parse() { // Nothing to parse, return without doing anything if(0 >= argc) return; int mandatoryOptionsCount = 0; int shortNameOptionsCount = 0; int longNameOptionsCount = 0; bool parsingError = false; std::string errorMsg; for(int i=1; i<argc && !parsingError; i++) { if(boost::starts_with(argv[i], "--")) { // Full name options std::string opt = std::string(argv[i]); std::string optName = std::string(argv[i]).substr(2, opt.find("=") - 2); std::string optValue = std::string(argv[i]).substr(opt.find("=") + 1); BOOST_LOG_TRIVIAL(debug) << "Long Name Attribute: " << optName << " Got Value: " << optValue; try { setValueByName(optName, optValue); longNameOptionsCount++; } catch(cloptparser::OptionNotFoundException ex) { errorMsg = ex.what(); BOOST_LOG_TRIVIAL(error) << errorMsg; parsingError = true; } } else if(boost::starts_with(argv[i], "-")) { // Short name options std::string opt = std::string(argv[i]); std::string optName = std::string(argv[i]).substr(1); std::string optValue = std::string(argv[++i]); BOOST_LOG_TRIVIAL(debug) << "Short Name Attribute: " << optName << " Got Value: " << optValue; try { setValueByName(optName, optValue); shortNameOptionsCount++; // Decrease the iteration index since the current value // is another option if(!currentOptionNeedsRValue(optName)) i--; } catch(cloptparser::OptionNotFoundException ex) { errorMsg = ex.what(); BOOST_LOG_TRIVIAL(error) << errorMsg; parsingError = true; } } else { if(mandatoryOptionsCount <= mandatoryOptions.size() - 1) { mandatoryOptions[mandatoryOptionsCount]->setValue(argv[i]); BOOST_LOG_TRIVIAL(debug) << "Mandatory Attribute: " << mandatoryOptions[mandatoryOptionsCount]->LongName() << " Got Value: " << argv[i]; } mandatoryOptionsCount++; } } if(mandatoryOptionsCount != mandatoryOptions.size() && !parsingError) { parsingError = true; errorMsg = "Invalid number of mandatory values supplied"; } if(parsingError) { std::cerr << "Error: " << errorMsg << std::endl; printHelpMessage(); return; } }
int APIENTRY WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { int argc = __argc; char **argv = __argv; #else int main(int argc, char *argv[]) { #endif int seed = time(NULL); bool verifyexit = false; bool check_mods = false; std::string dump; dump_mode dmode = dump_mode::TSV; std::vector<std::string> opts; std::string world; /** if set try to load first save in this world on startup */ // Set default file paths #ifdef PREFIX #define Q(STR) #STR #define QUOTE(STR) Q(STR) PATH_INFO::init_base_path(std::string(QUOTE(PREFIX))); #else PATH_INFO::init_base_path(""); #endif #if (defined USE_HOME_DIR || defined USE_XDG_DIR) PATH_INFO::init_user_dir(); #else PATH_INFO::init_user_dir("./"); #endif PATH_INFO::set_standard_filenames(); MAP_SHARING::setDefaults(); { const char *section_default = nullptr; const char *section_map_sharing = "Map sharing"; const char *section_user_directory = "User directories"; const std::array<arg_handler, 12> first_pass_arguments = {{ { "--seed", "<string of letters and or numbers>", "Sets the random number generator's seed value", section_default, [&seed](int num_args, const char **params) -> int { if (num_args < 1) return -1; const unsigned char *hash_input = (const unsigned char *) params[0]; seed = djb2_hash(hash_input); return 1; } }, { "--jsonverify", nullptr, "Checks the cdda json files", section_default, [&verifyexit](int, const char **) -> int { verifyexit = true; return 0; } }, { "--check-mods", "[mods...]", "Checks the json files belonging to cdda mods", section_default, [&check_mods,&opts]( int n, const char *params[] ) -> int { check_mods = true; test_mode = true; for( int i = 0; i < n; ++i ) { opts.emplace_back( params[ i ] ); } return 0; } }, { "--dump-stats", "<what> [mode = TSV] [opts...]", "Dumps item stats", section_default, [&dump,&dmode,&opts](int n, const char *params[]) -> int { if( n < 1 ) { return -1; } test_mode = true; dump = params[ 0 ]; for( int i = 2; i < n; ++i ) { opts.emplace_back( params[ i ] ); } if( n >= 2 ) { if( !strcmp( params[ 1 ], "TSV" ) ) { dmode = dump_mode::TSV; return 0; } else if( !strcmp( params[ 1 ], "HTML" ) ) { dmode = dump_mode::HTML; return 0; } else { return -1; } } return 0; } }, { "--world", "<name>", "Load world", section_default, [&world](int n, const char *params[]) -> int { if( n < 1 ) { return -1; } world = params[0]; return 1; } }, { "--basepath", "<path>", "Base path for all game data subdirectories", section_default, [](int num_args, const char **params) { if (num_args < 1) return -1; PATH_INFO::init_base_path(params[0]); PATH_INFO::set_standard_filenames(); return 1; } }, { "--shared", nullptr, "Activates the map-sharing mode", section_map_sharing, [](int, const char **) -> int { MAP_SHARING::setSharing(true); MAP_SHARING::setCompetitive(true); MAP_SHARING::setWorldmenu(false); return 0; } }, { "--username", "<name>", "Instructs map-sharing code to use this name for your character.", section_map_sharing, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; MAP_SHARING::setUsername(params[0]); return 1; } }, { "--addadmin", "<username>", "Instructs map-sharing code to use this name for your character and give you " "access to the cheat functions.", section_map_sharing, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; MAP_SHARING::addAdmin(params[0]); return 1; } }, { "--adddebugger", "<username>", "Informs map-sharing code that you're running inside a debugger", section_map_sharing, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; MAP_SHARING::addDebugger(params[0]); return 1; } }, { "--competitive", nullptr, "Instructs map-sharing code to disable access to the in-game cheat functions", section_map_sharing, [](int, const char **) -> int { MAP_SHARING::setCompetitive(true); return 0; } }, { "--userdir", "<path>", "Base path for user-overrides to files from the ./data directory and named below", section_user_directory, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; PATH_INFO::init_user_dir(params[0]); PATH_INFO::set_standard_filenames(); return 1; } } }}; // The following arguments are dependent on one or more of the previous flags and are run // in a second pass. const std::array<arg_handler, 9> second_pass_arguments = {{ { "--worldmenu", nullptr, "Enables the world menu in the map-sharing code", section_map_sharing, [](int, const char **) -> int { MAP_SHARING::setWorldmenu(true); return true; } }, { "--datadir", "<directory name>", "Sub directory from which game data is loaded", nullptr, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; PATH_INFO::update_pathname("datadir", params[0]); PATH_INFO::update_datadir(); return 1; } }, { "--savedir", "<directory name>", "Subdirectory for game saves", section_user_directory, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; PATH_INFO::update_pathname("savedir", params[0]); return 1; } }, { "--configdir", "<directory name>", "Subdirectory for game configuration", section_user_directory, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; PATH_INFO::update_pathname("config_dir", params[0]); PATH_INFO::update_config_dir(); return 1; } }, { "--memorialdir", "<directory name>", "Subdirectory for memorials", section_user_directory, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; PATH_INFO::update_pathname("memorialdir", params[0]); return 1; } }, { "--optionfile", "<filename>", "Name of the options file within the configdir", section_user_directory, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; PATH_INFO::update_pathname("options", params[0]); return 1; } }, { "--keymapfile", "<filename>", "Name of the keymap file within the configdir", section_user_directory, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; PATH_INFO::update_pathname("keymap", params[0]); return 1; } }, { "--autopickupfile", "<filename>", "Name of the autopickup options file within the configdir", nullptr, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; PATH_INFO::update_pathname("autopickup", params[0]); return 1; } }, { "--motdfile", "<filename>", "Name of the message of the day file within the motd directory", nullptr, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; PATH_INFO::update_pathname("motd", params[0]); return 1; } }, }}; // Process CLI arguments. const size_t num_first_pass_arguments = sizeof(first_pass_arguments) / sizeof(first_pass_arguments[0]); const size_t num_second_pass_arguments = sizeof(second_pass_arguments) / sizeof(second_pass_arguments[0]); int saved_argc = --argc; // skip program name const char **saved_argv = (const char **)++argv; while (argc) { if(!strcmp(argv[0], "--help")) { printHelpMessage(first_pass_arguments.data(), num_first_pass_arguments, second_pass_arguments.data(), num_second_pass_arguments); return 0; } else { bool arg_handled = false; for (size_t i = 0; i < num_first_pass_arguments; ++i) { auto &arg_handler = first_pass_arguments[i]; if (!strcmp(argv[0], arg_handler.flag)) { argc--; argv++; int args_consumed = arg_handler.handler(argc, (const char **)argv); if (args_consumed < 0) { printf("Failed parsing parameter '%s'\n", *(argv - 1)); exit(1); } argc -= args_consumed; argv += args_consumed; arg_handled = true; break; } } // Skip other options. if (!arg_handled) { --argc; ++argv; } } } while (saved_argc) { bool arg_handled = false; for (size_t i = 0; i < num_second_pass_arguments; ++i) { auto &arg_handler = second_pass_arguments[i]; if (!strcmp(saved_argv[0], arg_handler.flag)) { --saved_argc; ++saved_argv; int args_consumed = arg_handler.handler(saved_argc, saved_argv); if (args_consumed < 0) { printf("Failed parsing parameter '%s'\n", *(argv - 1)); exit(1); } saved_argc -= args_consumed; saved_argv += args_consumed; arg_handled = true; break; } } // Ingore unknown options. if (!arg_handled) { --saved_argc; ++saved_argv; } } } if (!assure_dir_exist(FILENAMES["user_dir"].c_str())) { printf("Can't open or create %s. Check permissions.\n", FILENAMES["user_dir"].c_str()); exit(1); } setupDebug(); /** * OS X does not populate locale env vars correctly (they usually default to * "C") so don't bother trying to set the locale based on them. */ #if (!defined MACOSX) if (setlocale(LC_ALL, "") == NULL) { DebugLog(D_WARNING, D_MAIN) << "Error while setlocale(LC_ALL, '')."; } else { #endif try { std::locale::global( std::locale( "" ) ); } catch( const std::exception& ) { // if user default locale retrieval isn't implemented by system try{ // default to basic C locale std::locale::global( std::locale::classic() ); } catch( const std::exception &err ) { debugmsg( "%s", err.what() ); exit_handler(-999); } } #if (!defined MACOSX) } #endif get_options().init(); get_options().load(); set_language(); // in test mode don't initialize curses to avoid escape sequences being inserted into output stream if( !test_mode ) { try { catacurses::init_interface(); } catch( const std::exception &err ) { // can't use any curses function as it has not been initialized std::cerr << "Error while initializing the interface: " << err.what() << std::endl; DebugLog( D_ERROR, DC_ALL ) << "Error while initializing the interface: " << err.what() << "\n"; return 1; } } srand(seed); g = new game; // First load and initialize everything that does not // depend on the mods. try { g->load_static_data(); if (verifyexit) { exit_handler(0); } if( !dump.empty() ) { init_colors(); exit( g->dump_stats( dump, dmode, opts ) ? 0 : 1 ); } if( check_mods ) { init_colors(); loading_ui ui( false ); exit( g->check_mod_data( opts, ui ) && !test_dirty ? 0 : 1 ); } } catch( const std::exception &err ) { debugmsg( "%s", err.what() ); exit_handler(-999); } // Now we do the actual game. g->init_ui(); curs_set(0); // Invisible cursor here, because MAPBUFFER.load() is crash-prone #if (!(defined _WIN32 || defined WINDOWS)) struct sigaction sigIntHandler; sigIntHandler.sa_handler = exit_handler; sigemptyset(&sigIntHandler.sa_mask); sigIntHandler.sa_flags = 0; sigaction(SIGINT, &sigIntHandler, NULL); #endif #ifdef LOCALIZE std::string lang = ""; #if (defined _WIN32 || defined WINDOWS) lang = getLangFromLCID( GetUserDefaultLCID() ); #else const char *v = setlocale( LC_ALL, NULL ); if( v != NULL ) { lang = v; if( lang == "C" ) { lang = "en"; } } #endif if( get_option<std::string>( "USE_LANG" ).empty() && ( lang.empty() || !isValidLanguage( lang ) ) ) { select_language(); set_language(); } #endif while( true ) { if( !world.empty() ) { if( !g->load( world ) ) { break; } world.clear(); // ensure quit returns to opening screen } else { main_menu menu; if( !menu.opening_screen() ) { break; } } while( !g->do_turn() ); }; exit_handler(-999); return 0; }
int interactiveMode() { const std::string INPUT_LINE = "Enter a calculation: "; const std::string INPUT_LINE_END = ""; const std::string OUTPUT_LINE = "\033[1;93m > "; const std::string OUTPUT_LINE_END = "\033[0m"; // Used for debugging when displaying the error message const int INPUT_LINE_LENGTH = 21; try { // Detect when the user presses CTRL+C on their keyboard signal(SIGINT, sigint); std::cout << INPUT_LINE; std::string input = ""; while (getline(std::cin, input)) { std::cout << INPUT_LINE_END; // Detect special commands if (input == "") { // No text entered // Act the same way as Bash, and just show another empty line } else if ( input == "help" ) { printHelpMessage(std::cout, true); // It looks better with an additional blank line after the message. std::cout << std::endl; } else if ( input == "exit" || input == "quit") { exit(EXIT_SUCCESS); } else { // No special command entered. Parse the text that was entered as usual. int result = parseString<int>(input); std::cout << OUTPUT_LINE << result << OUTPUT_LINE_END << std::endl; } // And all over again std::cout << INPUT_LINE; } } catch (ParseError& e) { e.print(std::cerr, true, INPUT_LINE_LENGTH); exit (e.getID()); } catch (MathError& e) { e.print(std::cerr, true, INPUT_LINE_LENGTH); exit (e.getID()); } catch (Error& e) { e.print(std::cerr, true); exit (e.getID()); } catch (...) { unknownError(); exit(EXIT_FAILURE); } // Technically, this line should never execute unless we change the way // the above while loop works. exit(EXIT_SUCCESS); }
int APIENTRY WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { int argc = __argc; char **argv = __argv; #else int main(int argc, char *argv[]) { #endif int seed = time(NULL); bool verifyexit = false; bool check_all_mods = false; // Set default file paths #ifdef PREFIX #define Q(STR) #STR #define QUOTE(STR) Q(STR) PATH_INFO::init_base_path(std::string(QUOTE(PREFIX))); #else PATH_INFO::init_base_path(""); #endif #if (defined USE_HOME_DIR || defined USE_XDG_DIR) PATH_INFO::init_user_dir(); #else PATH_INFO::init_user_dir("./"); #endif PATH_INFO::set_standard_filenames(); MAP_SHARING::setDefaults(); { const char *section_default = nullptr; const char *section_map_sharing = "Map sharing"; const char *section_user_directory = "User directories"; const arg_handler first_pass_arguments[] = { { "--seed", "<string of letters and or numbers>", "Sets the random number generator's seed value", section_default, [&seed](int num_args, const char **params) -> int { if (num_args < 1) return -1; const unsigned char *hash_input = (const unsigned char *) params[0]; seed = djb2_hash(hash_input); return 1; } }, { "--jsonverify", nullptr, "Checks the cdda json files", section_default, [&verifyexit](int, const char **) -> int { verifyexit = true; return 0; } }, { "--check-mods", nullptr, "Checks the json files belonging to cdda mods", section_default, [&check_all_mods](int, const char **) -> int { check_all_mods = true; return 0; } }, { "--basepath", "<path>", "Base path for all game data subdirectories", section_default, [](int num_args, const char **params) { if (num_args < 1) return -1; PATH_INFO::init_base_path(params[0]); PATH_INFO::set_standard_filenames(); return 1; } }, { "--shared", nullptr, "Activates the map-sharing mode", section_map_sharing, [](int, const char **) -> int { MAP_SHARING::setSharing(true); MAP_SHARING::setCompetitive(true); MAP_SHARING::setWorldmenu(false); return 0; } }, { "--username", "<name>", "Instructs map-sharing code to use this name for your character.", section_map_sharing, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; MAP_SHARING::setUsername(params[0]); return 1; } }, { "--addadmin", "<username>", "Instructs map-sharing code to use this name for your character and give you " "access to the cheat functions.", section_map_sharing, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; MAP_SHARING::addAdmin(params[0]); return 1; } }, { "--adddebugger", "<username>", "Informs map-sharing code that you're running inside a debugger", section_map_sharing, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; MAP_SHARING::addDebugger(params[0]); return 1; } }, { "--competitive", nullptr, "Instructs map-sharing code to disable access to the in-game cheat functions", section_map_sharing, [](int, const char **) -> int { MAP_SHARING::setCompetitive(true); return 0; } }, { "--userdir", "<path>", "Base path for user-overrides to files from the ./data directory and named below", section_user_directory, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; PATH_INFO::init_user_dir(params[0]); PATH_INFO::set_standard_filenames(); return 1; } } }; // The following arguments are dependent on one or more of the previous flags and are run // in a second pass. const arg_handler second_pass_arguments[] = { { "--worldmenu", nullptr, "Enables the world menu in the map-sharing code", section_map_sharing, [](int, const char **) -> int { MAP_SHARING::setWorldmenu(true); return true; } }, { "--datadir", "<directory name>", "Sub directory from which game data is loaded", nullptr, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; PATH_INFO::update_pathname("datadir", params[0]); PATH_INFO::update_datadir(); return 1; } }, { "--savedir", "<directory name>", "Subdirectory for game saves", section_user_directory, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; PATH_INFO::update_pathname("savedir", params[0]); return 1; } }, { "--configdir", "<directory name>", "Subdirectory for game configuration", section_user_directory, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; PATH_INFO::update_pathname("config_dir", params[0]); PATH_INFO::update_config_dir(); return 1; } }, { "--memorialdir", "<directory name>", "Subdirectory for memorials", section_user_directory, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; PATH_INFO::update_pathname("memorialdir", params[0]); return 1; } }, { "--optionfile", "<filename>", "Name of the options file within the configdir", section_user_directory, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; PATH_INFO::update_pathname("options", params[0]); return 1; } }, { "--keymapfile", "<filename>", "Name of the keymap file within the configdir", section_user_directory, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; PATH_INFO::update_pathname("keymap", params[0]); return 1; } }, { "--autopickupfile", "<filename>", "Name of the autopickup options file within the configdir", nullptr, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; PATH_INFO::update_pathname("autopickup", params[0]); return 1; } }, { "--motdfile", "<filename>", "Name of the message of the day file within the motd directory", nullptr, [](int num_args, const char **params) -> int { if (num_args < 1) return -1; PATH_INFO::update_pathname("motd", params[0]); return 1; } }, }; // Process CLI arguments. const size_t num_first_pass_arguments = sizeof(first_pass_arguments) / sizeof(first_pass_arguments[0]); const size_t num_second_pass_arguments = sizeof(second_pass_arguments) / sizeof(second_pass_arguments[0]); int saved_argc = --argc; // skip program name const char **saved_argv = (const char **)++argv; while (argc) { if(!strcmp(argv[0], "--help")) { printHelpMessage(first_pass_arguments, num_first_pass_arguments, second_pass_arguments, num_second_pass_arguments); return 0; } else { bool arg_handled = false; for (size_t i = 0; i < num_first_pass_arguments; ++i) { auto &arg_handler = first_pass_arguments[i]; if (!strcmp(argv[0], arg_handler.flag)) { argc--; argv++; int args_consumed = arg_handler.handler(argc, (const char **)argv); if (args_consumed < 0) { printf("Failed parsing parameter '%s'\n", *(argv - 1)); exit(1); } argc -= args_consumed; argv += args_consumed; arg_handled = true; break; } } // Skip other options. if (!arg_handled) { --argc; ++argv; } } } while (saved_argc) { bool arg_handled = false; for (size_t i = 0; i < num_second_pass_arguments; ++i) { auto &arg_handler = second_pass_arguments[i]; if (!strcmp(saved_argv[0], arg_handler.flag)) { --saved_argc; ++saved_argv; int args_consumed = arg_handler.handler(saved_argc, saved_argv); if (args_consumed < 0) { printf("Failed parsing parameter '%s'\n", *(argv - 1)); exit(1); } saved_argc -= args_consumed; saved_argv += args_consumed; arg_handled = true; break; } } // Ingore unknown options. if (!arg_handled) { --saved_argc; ++saved_argv; } } } if (!assure_dir_exist(FILENAMES["user_dir"].c_str())) { printf("Can't open or create %s. Check permissions.\n", FILENAMES["user_dir"].c_str()); exit(1); } setupDebug(); if (setlocale(LC_ALL, "") == NULL) { DebugLog(D_WARNING, D_MAIN) << "Error while setlocale(LC_ALL, '')."; } // Options strings loaded with system locale get_options().init(); get_options().load(); set_language(true); if (initscr() == NULL) { // Initialize ncurses DebugLog( D_ERROR, DC_ALL ) << "initscr failed!"; return 1; } init_interface(); noecho(); // Don't echo keypresses cbreak(); // C-style breaks (e.g. ^C to SIGINT) keypad(stdscr, true); // Numpad is numbers #if !(defined TILES || defined _WIN32 || defined WINDOWS) // For tiles or windows, this is handled already in initscr(). init_colors(); #endif // curs_set(0); // Invisible cursor set_escdelay(10); // Make escape actually responsive std::srand(seed); g = new game; // First load and initialize everything that does not // depend on the mods. try { g->load_static_data(); if (verifyexit) { if(g->game_error()) { exit_handler(-999); } exit_handler(0); } if (check_all_mods) { // Here we load all the mods and check their // consistency (both is done in check_all_mod_data). g->init_ui(); popup_nowait("checking all mods"); g->check_all_mod_data(); if(g->game_error()) { exit_handler(-999); } // At this stage, the mods (and core game data) // are find and we could start playing, but this // is only for verifying that stage, so we exit. exit_handler(0); } } catch( const std::exception &err ) { debugmsg( "%s", err.what() ); exit_handler(-999); } // Now we do the actual game. g->init_ui(); if(g->game_error()) { exit_handler(-999); } curs_set(0); // Invisible cursor here, because MAPBUFFER.load() is crash-prone #if (!(defined _WIN32 || defined WINDOWS)) struct sigaction sigIntHandler; sigIntHandler.sa_handler = exit_handler; sigemptyset(&sigIntHandler.sa_mask); sigIntHandler.sa_flags = 0; sigaction(SIGINT, &sigIntHandler, NULL); #endif bool quit_game = false; do { if(!g->opening_screen()) { quit_game = true; } while (!quit_game && !g->do_turn()) ; if (g->game_quit() || g->game_error()) { quit_game = true; } } while (!quit_game); exit_handler(-999); return 0; }
void keyboardCallback( unsigned char key, int x, int y ){ switch( key ){ case 27: // The 'esc' key case 'q': #ifdef FREEGLUT glutLeaveMainLoop( ); #else exit( 0 ); #endif break; case 'a': // move the left teapot (B) along it's positive y-axis // Please implement this feature. teapotTranslation_B[0] -= translationDelta; break; case 'd': // move the left teapot (B) along it's negative y-axis // Please implement this feature. teapotTranslation_B[0] += translationDelta; break; case 'w': // move the left teapot (B) along it's positive x-axis // Please implement this feature. teapotTranslation_B[1] += translationDelta; break; case 's': // move the left teapot (B) along it's negative x-axis // Please implement this feature. teapotTranslation_B[1] -= translationDelta; break; case 'v': // positively scale the right teapot (A) // Please implement this feature. teapotScale_A[0] += 0.05; teapotScale_A[1] += 0.05; teapotScale_A[2] += 0.05; break; case 'b': // negatively scale the right teapot (A) // Please implement this feature. teapotScale_A[0] -= 0.05; teapotScale_A[1] -= 0.05; teapotScale_A[2] -= 0.05; break; case 'o': isPerspective = !isPerspective; updateProjection( glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT) ); printf("Using perspective projection? %s\n", (isPerspective ? "Yes" : "No")); break; case 'p': useGLPerspective = !useGLPerspective; updateProjection( glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT) ); printf("Using OpenGL's perspective functions? %s\n", (useGLPerspective ? "Yes" : "No")); break; case '+': rotationDelta += 1.0; printf( "Rotation delta set to %g\n", rotationDelta ); break; case '-': rotationDelta -= 1.0; printf( "Rotation delta set to %g\n", rotationDelta ); break; case 'g': useGLLookAt = !useGLLookAt; printf("Using OpenGL's gluLookAt? %s\n", (useGLLookAt ? "Yes" : "No")); break; case 'h': printHelpMessage( ); break; case 'r': initEyePosition( ); initUpVector( ); initDeltas( ); initToggles( ); initTeapotTransforms( ); printf("Eye position, up vector and rotation delta reset.\n"); break; case 'e': camZ = camZ + 0.2; break; case 'c': camZ = camZ - 0.2; break; default: fprintf( stderr, "You pushed '%c' (%d).\n", key, key ); break; } glutPostRedisplay( ); }
App::App(int &argc, char **argv) : QApplication(argc, argv) , _invocation(argv[0]) , _gui(false) , _interactive(false) { // Enforce singleton property if (_instance) { throw std::runtime_error("Only one instance of App allowed."); } // Remember if we are done bool done = false; // Set the singleton instance to this _instance = this; // Set the application properties setApplicationName(APPLICATION_NAME); setApplicationVersion(APPLICATION_VERSION_STRING); setOrganizationName(APPLICATION_VENDOR_NAME); setOrganizationDomain(APPLICATION_VENDOR_URL); // Configure the logging mechanism log4cxx::LoggerPtr rootlogger = log4cxx::Logger::getRootLogger(); rootlogger->addAppender(new log4cxx::ConsoleAppender(new log4cxx::PatternLayout("[%-5p] %m%n"))); // Parse the commandline int idx = 1; while (idx < argc) { QString arg(argv[idx]); if (matches_option(arg, "help", 0) || matches_option(arg, "h") || matches_option(arg, "?", 0)) { printHelpMessage(); std::exit(0); } else if (matches_option(arg, "version", 0)) { printVersionMessage(); std::exit(0); } else if (matches_option(arg, "version-triplet")) { printVersionTripletMessage(); std::exit(0); } else if (matches_option(arg, "prefset")) { // Verify that there is another argument if ((idx + 1) >= argc) { LOG4CXX_FATAL(_logger, "Option \"" << arg << "\" requires a parameter."); std::exit(1); } // Increment the index idx++; // Get the next parameter std::string param(argv[idx]); // Determine if there is an equals sign // If there is, set the preference; // Otherwise, remove the preference size_t eqidx = param.find('='); if (eqidx != std::string::npos) { std::string key = param.substr(0, eqidx); std::string val = param.substr(eqidx + 1); setPreference(key, val); } else { unsetPreference(param); } done = true; } else if (matches_option(arg, "prefdel")) { // Verify that there is another argument if ((idx + 1) >= argc) { LOG4CXX_FATAL(_logger, "Option \"" << arg << "\" requires a parameter."); std::exit(1); } // Increment the index idx++; // Get the next parameter std::string param(argv[idx]); // Remove the preference unsetPreference(param); done = true; } else if (matches_option(arg, "preflist")) { printAllPreferences(); done = true; } else if (matches_option(arg, "prefget")) { // Verify that there is another argument if ((idx + 1) >= argc) { LOG4CXX_FATAL(_logger, "Option \"" << arg << "\" requires a parameter."); std::exit(1); } // Increment the index idx++; // Get the next parameter std::string param(argv[idx]); // Print the preference printPreference(param); done = true; } else if (matches_option(arg, "loglevel")) { // Verify that there is another argument if ((idx + 1) >= argc) { LOG4CXX_FATAL(_logger, "Option \"" << arg << "\" requires a parameter."); std::exit(1); } // Increment the index idx++; // Get the next parameter std::string param(argv[idx]); // Determine if there is an equals sign and act accordingly size_t eqidx = param.find('='); if (eqidx != std::string::npos) { std::string logger = param.substr(0, eqidx); std::string level = param.substr(eqidx + 1); setLogLevel(logger, level); } else { setLogLevel("", param); } } else if (matches_option(arg, "appid") || matches_option(arg, "application-identifier")) { printApplicationIdentifier(); std::exit(0); } else if (matches_option(arg, "gui")) { if (_interactive) { LOG4CXX_FATAL(_logger, "Cannot specify both \"--gui\" and \"--interactive\" simultaneously."); std::exit(1); } if (_gui) { LOG4CXX_WARN(_logger, "Option \"" << arg << "\" already specified. Ignoring."); } _gui = true; } else if (matches_option(arg, "interactive")) { if (_gui) { LOG4CXX_FATAL(_logger, "Cannot specify both \"--gui\" and \"--interactive\" simultaneously."); std::exit(1); } if (_interactive) { LOG4CXX_WARN(_logger, "Option \"" << arg << "\" already specified. Ignoring."); } _interactive = true; } else { LOG4CXX_WARN(_logger, "Unrecognized option: \"" << arg << "\". Ignoring"); } idx++; } initGUI(); }
int main(int argc, char *argv[]) { QApplication a(argc, argv); a.setApplicationName("Svg Creater"); a.setApplicationVersion("0.0.1"); QStringList args = a.arguments(); QRegExp rxArgHelp("--help"); QRegExp rxArgH("-h"); QRegExp rxArgVersion("--version"); QRegExp rxArgV("-v"); bool isHelp(false), isVer(false); QStringList filePaths; for(int i(1); i < args.size(); ++i) { if (rxArgHelp.indexIn(args.at(i)) != -1 || rxArgH.indexIn(args.at(i)) != -1) { isHelp = true; } else if (rxArgVersion.indexIn(args.at(i)) != -1 || rxArgV.indexIn(args.at(i)) != -1) { isVer = true; } else { if(QFile::exists(args.at(i))) { filePaths.append(args.at(i)); } } } if(isHelp) { printHelpMessage(); return 0; } else if(isVer) { printVersion(); return 0; } QTranslator appTranslator; QString translationsPath("/usr/share/easypaint/translations/"); QString appLanguage = DataSingleton::Instance()->getAppLanguage(); if(appLanguage == "system") { appTranslator.load(translationsPath + "easypaint_" + QLocale::system().name()); } else { appTranslator.load(translationsPath + appLanguage); } a.installTranslator(&appTranslator); MainWindow w(filePaths); w.show(); return a.exec(); }
int doTheRealWork(int argc, char **argv) { MinVR::VRDataIndex *index = new MinVR::VRDataIndex; // These will be extracted from argv. int nth = 0; // Extracting... switch(argc) { case 1: printHelpMessage(); return EXIT_SUCCESS; case 2: if (argv[1][0] == '-') { printHelpMessage(); return EXIT_SUCCESS; } throw std::runtime_error("Need a data name. (Try --usage.)"); break; case 3: // Don't really need to do anything here except avoid throwing error. break; case 4: // If there is a fourth arg, hope it's an integer. sscanf(argv[3], "%d", &nth); break; default: throw std::runtime_error("Too many arguments"); break; } index->processXMLFile(argv[1], std::string("/")); MinVR::VRCORETYPE_ID tp = index->getType(argv[2]); // std::cout << "datumName:" << datumName << " N:" << nth << " tp:" << tp << std::endl; // Now print out the values, according to the data type. switch(tp) { case MinVR::VRCORETYPE_INT: std::cout << (MinVR::VRInt)index->getValue(argv[2]); break; case MinVR::VRCORETYPE_FLOAT: std::cout << (MinVR::VRFloat)index->getValue(argv[2]); break; case MinVR::VRCORETYPE_STRING: std::cout << (MinVR::VRString)index->getValue(argv[2]); break; case MinVR::VRCORETYPE_INTARRAY: { MinVR::VRIntArray ia = index->getValue(argv[2]); if (nth >= (int)ia.size()) throw std::runtime_error("N too large for array"); std::cout << ia[nth]; break; } case MinVR::VRCORETYPE_FLOATARRAY: { MinVR::VRFloatArray ia = index->getValue(argv[2]); if (nth >= (int)ia.size()) throw std::runtime_error("N too large for array"); std::cout << ia[nth]; break; } case MinVR::VRCORETYPE_STRINGARRAY: { MinVR::VRStringArray ia = index->getValue(argv[2]); if (nth >= (int)ia.size()) throw std::runtime_error("N too large for array"); std::cout << ia[nth]; break; } case MinVR::VRCORETYPE_CONTAINER: std::cout << index->serialize(argv[2]); break; default: throw std::runtime_error("Not supported for that type."); return EXIT_FAILURE; } return EXIT_SUCCESS; }