int read_args(int argc, char *argv[]){ int ret = 0; global_args.args = (char *)malloc(ARGMAXNUM * sizeof(char)); while((ret = getopt(argc, argv, opt_strings)) != -1){ if(global_args.args_num >= ARGMAXNUM){ free(global_args.args); return -1; } if(global_args.last_index == optind) {free(global_args.args); return -1;} switch(ret){ case 'd': if(read_options(&global_args.d_num, global_args.d_options, &global_args, optarg, ret) == -1) { return -1;} break; case 'i': ++global_args.i_num; if(global_args.i_num > 1){free(global_args.args); return -1;} global_args.args[global_args.args_num++] = ret; break; case 'l': ++global_args.l_num; if(global_args.l_num > 1){free(global_args.args); return -1;}global_args.args[global_args.args_num++] = ret; break; case 'r': if(read_options(&global_args.r_num, global_args.r_options, &global_args, optarg, ret) == -1) {return -1;} break; case 'o': if(read_options(&global_args.o_num, global_args.o_options, &global_args, optarg, ret) == -1) {return -1;} break; case 'x': if(read_options(&global_args.x_num, global_args.x_options, &global_args, optarg, ret) == -1) {return -1;} break; default: free(global_args.args); return -1; } global_args.last_index = optind; } if(global_args.args_num <= 1 || global_args.args_num > 3){ free(global_args.args); return -1; } if(global_args.d_num == 0){free(global_args.args); return -1;} if((global_args.args_num == 3)){ if(!(global_args.r_num & global_args.o_num)){free(global_args.args); printf("before return -1\n"); return -1;} } if(global_args.d_num > 1 || global_args.i_num > 1 || global_args.l_num > 1 || global_args.r_num > 1 || global_args.o_num > 1 || global_args.x_num > 1) {free(global_args.args); return -1;} if(global_args.r_num ^ global_args.o_num){free(global_args.args); return -1;} return 0; }
/** * Main routine */ int main(int argc, char** argv) { problem_t problem; read_options(argc, argv, &problem); clock_t start = clock(), diff; //Clocking if (problem.verbose) { for (int i = 0; i < problem.g; ++i) { printf("\nGeneration %d\n", i); print_board(&problem); advance_board(&problem, 1); } } else { #ifdef WITH_TIMING double t0 = omp_get_wtime(); advance_board(&problem, problem.g); double t1 = omp_get_wtime(); printf("Cells / sec: %e\n", problem.g * problem.nboard * problem.nboard / (t1-t0)); #else advance_board(&problem, problem.g); <<<<<<< HEAD diff = clock() - start; //get the time and print the result int msec = diff*1000/CLOCKS_PER_SEC; printf("Time taken %d seconds %d milliseconds", msec/1000, msec%1000); ======= #endif } >>>>>>> upstream/master
FC_nonp_variance_varselection::FC_nonp_variance_varselection(MASTER_OBJ * mp, unsigned & enr, GENERAL_OPTIONS * o, DISTR * lp, const ST::string & t,const ST::string & fp, DESIGN * Dp,FC_nonp * FCn,vector<ST::string> & op, vector<ST::string> & vn) : FC_nonp_variance(mp,enr,o,lp,t,fp,Dp,FCn,op,vn) { read_options(op,vn); FC_delta = FC(o,"",1,1,""); FC_delta.setbeta(1,1,1); FC_psi2 = FC(o,"",1,1,""); FC_psi2.setbeta(1,1,0.5); FC_omega = FC(o,"",1,1,""); FC_omega.setbeta(1,1,0.5); a_omega = 1; b_omega = 1; v = 5; Q = 25; }
int init_options(int no_config) { // Custom user conf file char *userconf = NULL; char *rcfile; char pwd[MAX_SETTING_LEN]; // Defualt savepath is current directory if (getcwd(pwd, MAX_SETTING_LEN)) { setting_set_value(SETTING_SAVEPATH, pwd); } // Initialize settings setting_set_value(SETTING_FILTER_METHODS, "REGISTER,INVITE,SUBSCRIBE,NOTIFY,OPTIONS,PUBLISH,MESSAGE"); // Add Call list column options set_option_value("cl.column0", "index"); set_option_value("cl.column1", "method"); set_option_value("cl.column2", "sipfrom"); set_option_value("cl.column3", "sipto"); set_option_value("cl.column4", "msgcnt"); set_option_value("cl.column5", "src"); set_option_value("cl.column6", "dst"); set_option_value("cl.column7", "state"); // Done if config file should not be read if(no_config) { return 0; } // Read options from configuration files read_options("/etc/sngreprc"); read_options("/usr/local/etc/sngreprc"); // Get user configuration if ((rcfile = getenv("SNGREPRC"))) { read_options(rcfile); } else if ((rcfile = getenv("HOME"))) { if ((userconf = sng_malloc(strlen(rcfile) + RCFILE_EXTRA_LEN))) { sprintf(userconf, "%s/.sngreprc", rcfile); read_options(userconf); sng_free(userconf); } } return 0; }
SolverUnconstrained<Data,Problem>::SolverUnconstrained( Data const& __data ) : M_prob( __data ), M_solver_stats ( this, true ), M_theta( M_prob.lowerBounds(), M_prob.upperBounds() ) { read_options(); }
SolverUnconstrained<Data,Problem>::SolverUnconstrained( value_type x_definitions[_E_n][3] ) : M_prob( x_definitions ), M_solver_stats ( this, true ), M_theta( _E_n ) { read_options(); }
/* * main() * */ int main(int argc, char **argv) { ocfs2_filesys *fs = NULL; errcode_t ret = 0; int i; initialize_ocfs_error_table(); #define INSTALL_SIGNAL(sig) \ do { \ if (signal(sig, handle_signal) == SIG_ERR) { \ fprintf(stderr, "Could not set " #sig "\n");\ goto bail; \ } \ } while (0) INSTALL_SIGNAL(SIGTERM); INSTALL_SIGNAL(SIGINT); memset(corrupt, 0, sizeof(corrupt)); ret = read_options(argc, argv); if (ret < 0) goto bail; print_version(); ret = ocfs2_open(device, OCFS2_FLAG_RW, 0, 0, &fs); if (ret) { com_err(progname, ret, "while opening \"%s\"", device); goto bail; } for (i = 0; i < NUM_FSCK_TYPE; ++i) { if (corrupt[i]) { if (!prompt_codes[i].pc_func) { fprintf(stderr, "Unimplemented corrupt code " "= %s\n", prompt_codes[i].pc_codestr); continue; } fprintf(stdout, "%s: Corrupting %s with code %s (%d)\n", progname, device, prompt_codes[i].pc_codestr, prompt_codes[i].pc_codenum); prompt_codes[i].pc_func(fs, prompt_codes[i].pc_codenum, slotnum); } } bail: if (fs) { ret = ocfs2_close(fs); if (ret) com_err(progname, ret, "while closing \"%s\"", device); } return ret; } /* main */
int main (int argc, char **argv) { ocfs2_filesys *fs = NULL; errcode_t ret = 1; initialize_ocfs_error_table(); #define INSTALL_SIGNAL(sig) \ do { \ if (signal(sig, handle_signal) == SIG_ERR) { \ printf("Could not set " #sig "\n"); \ goto bail; \ } \ } while (0) INSTALL_SIGNAL(SIGTERM); INSTALL_SIGNAL(SIGINT); memset(&options, 0, sizeof(options)); if (read_options(argc, argv)) { usage(progname); goto bail; } if (!device || !options.ops) goto bail; ret = ocfs2_open(device, OCFS2_FLAG_RW, 0, 0, &fs); if (ret) { com_err(progname, ret, "while opening \"%s\"", device); goto bail; } srand((unsigned long)fs); switch (options.ops) { case CREATE_LOCAL_ALLOC: ret = create_local_alloc(fs, options.slot); break; case CREATE_ORPHAN_FILE: ret = create_orphan_file(fs, options.slot); break; case CREATE_TRUNCATE_LOG: ret = create_truncate_log(fs, options.slot); break; } bail: if (fs) ocfs2_close(fs); return ret; }
int main(int argc, char *argv[]) { read_options(argc, argv); allocate(); write_pattern(); start_threads(); return 0; }
int main(int argc, char * argv[]) { VideoCapture capture; // Read options read_options(argc, argv,capture); Mat frame; Mat first; if (argc==1) { capture.open(0); } // Init camera if (!capture.isOpened()) { cout<<"capture device failed to open!"<<endl; return -1; } //display video frame rate float rate=capture.get(CV_CAP_PROP_FPS); cout<<"rate="<<rate<<endl; // cout<<"totalframenumber="<<capture.get(CV_CAP_PROP_FRAME_COUNT)<<endl; //Register mouse callback to draw the bounding box cvNamedWindow("Tracker", CV_WINDOW_AUTOSIZE); cvSetMouseCallback("Tracker", mouseHandler, NULL ); //save img path string imgFormat=".\\imgs\\img%05d.png"; char image_name[256]; if (fromfile) { capture.set(CV_CAP_PROP_POS_FRAMES,0*rate); capture >> frame; frameCount++; frame.copyTo(first); //show fame num stringstream buf; buf << frameCount; string num = buf.str(); putText(frame, num, Point(15, 30), FONT_HERSHEY_SIMPLEX, 1, Scalar(100, 0, 255), 3); //show imshow("Tracker", frame); //save sprintf(image_name, imgFormat.c_str(), frameCount); imwrite(image_name,frame); } else {
DESIGN_mrf::DESIGN_mrf(datamatrix & dm,datamatrix & iv, GENERAL_OPTIONS * o,DISTR * dp,FC_linear * fcl, const MAP::map & m,vector<ST::string> & op, vector<ST::string> & vn) : DESIGN(o,dp,fcl) { if (errors==false) { read_options(op,vn); discrete = true; ma = m; type = Mrf; nrpar = ma.get_nrregions(); consecutive=true; Zout = datamatrix(nrpar,1,1); index_Zout = statmatrix<int>(Zout.rows(),1); index_Zout.indexinit(); } if (errors==false) init_data(dm,iv); if (errors==false) { compute_penalty(); XWX = envmatdouble(0,nrpar); XWres = datamatrix(nrpar,1); Wsum = datamatrix(nrpar,1,1); compute_precision(1.0); compute_basisNull(); identity=true; } /* ofstream out("c:\\bayesx\\trunk\\testh\\results\\dm.raw"); dm.prettyPrint(out); ofstream out2("c:\\bayesx\\trunk\\testh\\results\\iv.raw"); iv.prettyPrint(out2); */ }
/*----------------------------------------------------------------------------*/ int main(int argc, char* argv[]) { STUFFS things; /* print tool info */ printf("\n%s - 8085 Cross Assembler (version-%s)\n",PROGNAME,PROGVERS); printf(" => by [email protected]\n\n"); /* initialize main data structure */ initialize(&things); /* false do-while loop - for error exits */ do { /* get parameters */ if(read_options(&things,argc,argv)<0) break; /* first pass - build label db */ things.pass = EXEC_PASS_1; if(process_asmfile(&things)>0) break; /* second pass - arrange code */ things.pass = EXEC_PASS_2; if(process_asmfile(&things)>0) break; /* write HEX file */ if(things.opt_flag&OPT_GENERATE_HEX) write_ihex(&things); /* write vmf file */ if(things.opt_flag&OPT_GENERATE_VMF) write_vlog(&things); } while(0); /* reset error if showed usage */ if(things.errc==ERROR_SHOW_USAGE) things.errc = 0; /* clean-up main data structure */ cleanup(&things); /* print end indicator */ printf("\n%s - Done! (%d)\n\n", PROGNAME, things.errc); return things.errc; }
int main(int argc, char** argv) { //the options struct holds all run-time options. options opt; opt.overwrite = false ; opt.gaussBool = false ; //Initialize --overwrite flag to false. Probably should handle //this in read_options. opt.polyFit = false ; vector<double> data ; double avg, std ; vector <vector<double> > hist ; read_options(argc, argv, opt) ; //Print run-time parameters cout << "inFile : " << opt.inFile << endl ; cout << "outFile: " << opt.outFile << endl ; cout << "numBins: " << opt.numBins << endl ; cout << "overwrite : " ; if (opt.overwrite) { cout << "True" << endl ; } else { cout << "False" << endl; } if ( opt.gaussBool ) { cout << "Gaussian fit file : " << opt.gaussFile << endl; } if ( opt.polyFit ) { cout << "Polynomial fit file : " << opt.polyfitFile << endl; cout << "Number of terms : " << opt.numTerms << endl ; } //Begin program data = read_data(opt.inFile) ; cout << endl; avg = average(data) ; cout << "average = " << avg << endl; std = stdDev(data,avg) ; cout << "std = " << std << endl ; hist = histogram(data, opt.numBins) ; print(hist,opt.outFile); if (opt.gaussBool) print_gauss(hist, opt.gaussFile, std, avg) ; if (opt.polyFit) fit_polynomial(hist,avg, opt.numTerms, opt.polyfitFile) ; return 0; }
FC_hrandom_variance_vec::FC_hrandom_variance_vec(MASTER_OBJ * mp,unsigned & enr, GENERAL_OPTIONS * o,DISTR * lp, DISTR * lpRE, const ST::string & t,const ST::string & fp, DESIGN * Dp,FC_nonp * FCn,vector<ST::string> & op, vector<ST::string> & vn) : FC_nonp_variance_vec(mp,enr,o,lp,t,fp,Dp,FCn,op,vn) { read_options(op,vn); likepRE = lpRE; b_invgamma = masterp->level1_likep[equationnr]->trmult*b_invgamma_orig; // hyperLambda=rand_gamma(a_invgamma,b_invgamma); hyperLambda=0.1; }
int main(int argc, char ** argv) { struct swift_context *c = NULL; struct client_options opts; swift_error e; if (!read_options(&opts, argc, argv)) { exit(EXIT_FAILURE); } if (!validate_options(&opts)) { exit(EXIT_FAILURE); } if (opts.filename) { opts.datahandle = setupio(&opts); } else { if (opts.action == ACTION_OBJ_WRITE) { opts.datahandle = stdin; } else { opts.datahandle = stdout; } } if (!opts.datahandle) { exit(EXIT_FAILURE); } swift_init(); e = swift_context_create(&c, opts.url, opts.username, opts.password); if (e) { fprintf(stderr, "Error: %s, line %d\n", swift_errormsg(e), __LINE__); exit(EXIT_FAILURE); } e = execute_action(&opts, c); if (e) { fprintf(stderr, "Error: %s, line %d\n", swift_errormsg(e), __LINE__); exit(EXIT_FAILURE); } swift_context_delete(&c); fclose(opts.datahandle); return 0; }
//============================================================================== bool CC_Base::execute(int argc, char *argv[]) { po::options_description desc; init_options(desc); try { po::variables_map vm; po::store(po::parse_command_line(argc, argv, desc), vm); po::notify(vm); if (vm.count("log")) init_log(argc, argv, option_log_name_); if (!read_options(desc, vm)) return false; if (init_programmer() && init_unit()) { log_info("main, start task processing"); process_tasks(); log_info("main, finish task processing"); programmer_.unit_close(); return true; } } catch (std::runtime_error& e) // usb, file error { std::cout << " Error occured"; if (strlen(e.what())) { std::cout << ": " << e.what(); log_info("%s", e.what()); } std::cout << "\n"; } catch (po::error& e) //command line error { std::cout << " Bad command line options"; if (strlen(e.what())) std::cout << " (" << e.what() << ")"; std::cout << "\n Try --help for more information\n"; } return false; }
int main(int argc, char** argv) { int grid_size_x; int grid_size_y; int max_iter; float xmin; float xmax; float ymin; float ymax; int **image; int rank; //initialise a fn pointer in_set_fn_t fp; MPI_Comm comm; comm = MPI_COMM_WORLD; MPI_Init(&argc, & argv); MPI_Comm_rank(comm, &rank); read_options(argc, argv, &grid_size_x, &grid_size_y, &max_iter, &xmin, &xmax, &ymin, &ymax); if(0 == rank) { initialise_image(&image, grid_size_x, grid_size_y); } //set it to either julia or mandelbrot calculation fp = &point_in_julia; compute_set(fp, image, xmin, xmax, ymin, ymax, grid_size_x, grid_size_y, max_iter, comm); if(0 == rank) { write_ppm("output.ppm", image, grid_size_x, grid_size_y, max_iter); free(image); } MPI_Finalize(); return 0; }
int main (int argc, char **argv) { botcfg.state = STATE_INIT; //piHiPri (45); if (setup () != 0) { fprintf (stderr, "Error setting up\n"); return 1; } if (read_options (argc, argv) != 0) { fprintf (stderr, "Error reading options\n"); return 1; } if (botcfg.state == STATE_INIT) { //User didn't chose either record or replay, falling back to passthrough botcfg.state = STATE_RUNNING; } if (joystick_setup () != 0) { fprintf (stderr, "Error setting up joysticks\n"); return 1; } //drop_privs (); if (check_pid ()) { fprintf (stderr, "Are we already running?\n"); return 1; } main_loop (); clear_all_buttons (); fprintf (stdout, "Exiting...\n"); remove_pid (); return 0 ; }
int get_arguments(options_t *options, int ac, char **av) { char **rest; u_int cnt; options->port = STARCRAFT_PORT; rest = read_options(options, ac, av, sov_arguments); if (!rest) return 0; if (!options->pcap_filter) { options->pcap_filter = malloc(SNAP_LEN); snprintf(options->pcap_filter, SNAP_LEN, PCAP_FILTER_FORMAT, options->port); } cnt = count_args(rest); if (cnt < 2) { fprintf(stderr, "Error: not enough arguments." EOL); print_use(); return 0; } options->capture_device_name = *rest++; options->hosts = rest; options->host_count = cnt - 1; if (options->inject_device_name) { if (options->bind_udp_port) { fprintf(stderr, "Invalid arguments: cannot bind UDP and use injection" EOL); return 0; } #ifdef WIN32 if (!options->inject_ethernet_source || !options->inject_ethernet_destination) { fprintf(stderr, "Invalid arguments: source and destination MAC addresses" EOL "are required when using injection under windows." EOL); return 0; } #endif } return 1; }
//int main(int argc, char *argv[], char *env[]) void main(void) { int i, j; mvtype movemade; mousex=100; mousey=100; iconmenu=0; set_default_options(); options=doptions; read_options(); initialise(startbrd); initial_displays(current); no_more_openings=FALSE; quit=game_over=0; g_path.move[0].f=0; randomize(); FLAGnewstart=1; while(!quit) { while(game.movenum<maxmoves && !quit) { whites=0; blacks=0; if (FLAGnewstart) { starttime=time(NULL); FLAGnewstart=0; } newtime=0; if (!game_over && ((current.mvr=='w' && options.whiteplayer==PROGRAM) || (current.mvr=='b' && options.blackplayer==PROGRAM))) movemade=get_computer_move(current); else movemade=get_player_move(current, game_over); if (kbhit()) { if (getch()==27) { options.whiteplayer=USER; options.blackplayer=USER; } } if (current.mvr=='w') (whites=time(NULL)-starttime); else (blacks=time(NULL)-starttime); if (movemade.t!=0) if (movemade.t<100) makemv(movemade); else {menu_option(movemade.t); game_over=0;} regular_displays(current, movemade); if (!game_over) game_over=over(); assert(game.lastmove<maxmoves); } options.whiteplayer=USER; options.blackplayer=USER; } }
int main(int argc, char** argv) { int grid_size_x; int grid_size_y; int max_iter; float xmin; float xmax; float ymin; float ymax; int **image; int rank; MPI_Comm comm; comm = MPI_COMM_WORLD; MPI_Init(&argc, & argv); MPI_Comm_rank(comm, &rank); read_options(argc, argv, &grid_size_x, &grid_size_y, &max_iter, &xmin, &xmax, &ymin, &ymax); if(0 == rank) { initialise_image(&image, grid_size_x, grid_size_y); } compute_mandelbrot_set(image, xmin, xmax, ymin, ymax, grid_size_x, grid_size_y, max_iter, comm); if(0 == rank) { write_ppm("output.ppm", image, grid_size_x, grid_size_y, max_iter); free(image); } MPI_Finalize(); return 0; }
FC_nonp_variance::FC_nonp_variance(MASTER_OBJ * mp, unsigned & enr, GENERAL_OPTIONS * o, DISTR * lp, const ST::string & t,const ST::string & fp, DESIGN * Dp,FC_nonp * FCn,vector<ST::string> & op, vector<ST::string> & vn) : FC(o,t,1,2,fp) { FCnonpp = FCn; likep = lp; designp = Dp; masterp = mp; equationnr = enr, lambdaconst = false; read_options(op,vn); datamatrix betanew(1,2); betanew(0,0) = likep->get_scale()/lambdastart; betanew(0,1) = lambdastart; setbeta(betanew); FCnonpp->tau2 = beta(0,0); FCnonpp->lambda = beta(0,1); }
int main(int argc, char** argv) { int grid_size_x; int grid_size_y; int max_iter; float xmin; float xmax; float ymin; float ymax; int **image; read_options(argc, argv, &grid_size_x, &grid_size_y, &max_iter, &xmin, &xmax, &ymin, &ymax); initialise_image(&image, grid_size_x, grid_size_y); compute_mandelbrot_set(image, xmin, xmax, ymin, ymax, grid_size_x, grid_size_y, max_iter); write_ppm("output.ppm", image, grid_size_x, grid_size_y, max_iter); free(image); return 0; }
int main(int argc, char *argv[]) { int n, fd, i; char *p; ne_test *testp; if ( read_options(argc, argv) == -1){ Usage(argv[0]); exit(-1); } if ( pget_option.outfile ){ if ((fd=open(pget_option.outfile, O_CREAT | O_TRUNC | O_RDWR, 0660)) < 0){ perror("open() :"); return -1; } close(STDOUT_FILENO); dup2(fd, STDOUT_FILENO); } test_argc = argc; test_argv = argv; if (tests[0].fn == NULL) { printf("-> no tests found in `%s'\n", test_suite); return -1; } if (ne_sock_init()) { COL("43;01"); printf("WARNING:"); NOCOL; printf(" Socket library initalization failed.\n"); } printf("\n"); printf("\n"); i = 0; p = Result_Header[i]; while ( p != NULL ){ printf("%s\n", p); i++; p = Result_Header[i]; } testp = &tests[0]; if ( !strcmp(pget_option.methods, "WebFolder") ) testp = &tests2[0]; for ( n=0; !aborted && testp[n].fn != NULL; n++) { int result; test_name = testp[n].name; have_context = 0; test_num = n; warned = 0; fflush(stdout); /* run the test. */ result = testp[n].fn(); if (testp[n].flags & T_EXPECT_FAIL) { if (result == OK) { t_context("test passed but expected failure"); result = FAIL; } else if (result == FAIL) result = OK; } /* align the result column if we've had warnings. */ if (warned) { printf(" %s ", dots); } } /* discount skipped tests */ if (skipped) { printf("-> %d %s.\n", skipped, skipped==1?"test was skipped":"tests were skipped"); n -= skipped; if (passes + fails != n) { printf("-> ARGH! Number of test results does not match " "number of tests.\n" "-> ARGH! Test Results are INRELIABLE.\n"); } } ne_sock_exit(); return fails; }
int main(int argc, char **argv) { errcode_t ret = 0; struct mount_options mo; ocfs2_filesys *fs = NULL; struct o2cb_cluster_desc cluster; struct o2cb_region_desc desc; int clustered = 1; int group_join = 0; struct stat statbuf; const char *spec; char *opts_string = NULL; initialize_ocfs_error_table(); initialize_o2dl_error_table(); initialize_o2cb_error_table(); setbuf(stdout, NULL); setbuf(stderr, NULL); if (signal(SIGTERM, handle_signal) == SIG_ERR) { fprintf(stderr, "Could not set SIGTERM\n"); exit(1); } if (signal(SIGINT, handle_signal) == SIG_ERR) { fprintf(stderr, "Could not set SIGINT\n"); exit(1); } memset(&mo, 0, sizeof(mo)); read_options (argc, argv, &mo); ret = process_options(&mo); if (ret) goto bail; ret = ocfs2_open(mo.dev, OCFS2_FLAG_RO, 0, 0, &fs); //O_EXCL? if (ret) { com_err(progname, ret, "while opening device %s", mo.dev); goto bail; } clustered = (0 == ocfs2_mount_local(fs)); if (ocfs2_is_hard_readonly(fs) && (clustered || !(mo.flags & MS_RDONLY))) { ret = OCFS2_ET_IO; com_err(progname, ret, "while mounting read-only device in %s mode", (clustered ? "clustered" : "read-write")); goto bail; } if (verbose) printf("device=%s\n", mo.dev); ret = o2cb_setup_stack((char *)OCFS2_RAW_SB(fs->fs_super)->s_cluster_info.ci_stack); if (ret) { com_err(progname, ret, "while setting up stack\n"); goto bail; } if (clustered) { ret = o2cb_init(); if (ret) { com_err(progname, ret, "while trying initialize cluster"); goto bail; } ret = ocfs2_fill_cluster_desc(fs, &cluster); if (ret) { com_err(progname, ret, "while trying to determine cluster information"); goto bail; } ret = ocfs2_fill_heartbeat_desc(fs, &desc); if (ret) { com_err(progname, ret, "while trying to determine heartbeat information"); goto bail; } desc.r_persist = 1; desc.r_service = OCFS2_FS_NAME; } ret = add_mount_options(fs, &cluster, &mo.xtra_opts); if (ret) { com_err(progname, ret, "while adding mount options"); goto bail; } /* validate mount dir */ if (lstat(mo.dir, &statbuf)) { com_err(progname, 0, "mount directory %s does not exist", mo.dir); goto bail; } else if (stat(mo.dir, &statbuf)) { com_err(progname, 0, "mount directory %s is a broken symbolic " "link", mo.dir); goto bail; } else if (!S_ISDIR(statbuf.st_mode)) { com_err(progname, 0, "mount directory %s is not a directory", mo.dir); goto bail; } block_signals (SIG_BLOCK); if (clustered && !(mo.flags & MS_REMOUNT)) { ret = o2cb_begin_group_join(&cluster, &desc); if (ret) { block_signals (SIG_UNBLOCK); com_err(progname, ret, "while trying to join the group"); goto bail; } group_join = 1; } spec = canonicalize(mo.dev); ret = mount(spec, mo.dir, OCFS2_FS_NAME, mo.flags & ~MS_NOSYS, mo.xtra_opts); if (ret) { ret = errno; if (group_join) { /* We ignore the return code because the mount * failure is the important error. * complete_group_join() will handle cleaning up */ o2cb_complete_group_join(&cluster, &desc, errno); } block_signals (SIG_UNBLOCK); if (ret == -EROFS) com_err(progname, OCFS2_ET_RO_FILESYS, "while mounting %s " "on %s, please try fixing this by fsck.ocfs2 and then " "retry mounting", mo.dev, mo.dir); else com_err(progname, OCFS2_ET_INTERNAL_FAILURE, "while mounting %s on %s. Check 'dmesg' for more " "information on this error %d.", mo.dev, mo.dir, (int)ret); goto bail; } if (group_join) { ret = o2cb_complete_group_join(&cluster, &desc, 0); if (ret) { com_err(progname, ret, "while completing group join (WARNING)"); /* * XXX: GFS2 allows the mount to continue, so we * will do the same. I don't know how clean that * is, but I don't have a better solution. */ ret = 0; } } change_local_hb_io_priority(fs, mo.dev); opts_string = fix_opts_string(((mo.flags & ~MS_NOMTAB) | (clustered ? MS_NETDEV : 0)), mo.xtra_opts, NULL); update_mtab_entry(mo.dev, mo.dir, OCFS2_FS_NAME, opts_string, mo.flags, 0, 0); block_signals (SIG_UNBLOCK); bail: if (fs) ocfs2_close(fs); if (mo.dev) free(mo.dev); if (mo.dir) free(mo.dir); if (mo.opts) free(mo.opts); if (mo.xtra_opts) free(mo.xtra_opts); if (mo.type) free(mo.type); if (opts_string) free(opts_string); return ret ? 1 : 0; }
int main(int argc, char* argv[]){ int i,j; // (0) leer parametros options opt; if (argc == 1) {print_help(argv[0]); return 0;} if(read_options(argc, argv, &opt)) {printf("ERROR reading parameters\n"); return 1;} int len1 = strlen(opt.file1); int len2 = strlen(opt.file2); if( strcmp(&(opt.file1[len1-4]),".bmp") || strcmp(&(opt.file2[len2-4]),".bmp") ) { printf("ERROR: nombre del archivo\n"); return -1;} // (0.1) siempre armo el summary opt.summary = (int*)malloc(sizeof(int)*256); for(i=0;i<256;i++) opt.summary[i]=0; // (1) leer imagenes BMP* bmp1 = bmp_read(opt.file1); BMP* bmp2 = bmp_read(opt.file2); if( bmp1==0 || bmp1==0 ) { printf("ERROR: no se puede abrir el archivo\n"); return -1;} // (2) check tipo de archivo if( ((BMPIH*)(bmp1->ih))->biSize != ((BMPIH*)(bmp1->ih))->biSize ) { printf("ERROR: tipo de archivo diferente\n"); return -1;} // (3) check tamaño del archivo int w1 = ((BMPIH*)(bmp1->ih))->biWidth; int h1 = ((BMPIH*)(bmp1->ih))->biHeight; int c1 = ((BMPIH*)(bmp1->ih))->biBitCount; int w2 = ((BMPIH*)(bmp2->ih))->biWidth; int h2 = ((BMPIH*)(bmp2->ih))->biHeight; int c2 = ((BMPIH*)(bmp2->ih))->biBitCount; if( w1!=w2 || h1!=h2 || c1!=c2 ) { printf("ERROR: tamaño de archivo diferente\n"); return -1;} //printf("%i=%i %i=%i %i=%i\n",w1,w2,h1,h2,c1,c2); if(w1%4!=0) { printf("ERROR: padding no soportado\n"); return -1;} // TODO: soportar padding! // (3) check el bit count TODO: only 24 o 32 if( c1!=24 && c1!=32 ) { printf("ERROR: (%i) bitcount distinto de 24 o 32\n", c1); return -1;} // (4) crear imagenes de diferencias BMP *bmpDiffR, *bmpDiffG, *bmpDiffB, *bmpDiffA; bmpDiffR = bmp_copy(bmp1,0); bmpDiffG = bmp_copy(bmp1,0); bmpDiffB = bmp_copy(bmp1,0); if(c1 == 32) bmpDiffA = bmp_copy(bmp1,0); // (5) extraer data uint8_t *data1,*data2,*dataR,*dataG,*dataB,*dataA; data1 = bmp_get_data(bmp1); data2 = bmp_get_data(bmp2); dataR = bmp_get_data(bmpDiffR); dataG = bmp_get_data(bmpDiffG); dataB = bmp_get_data(bmpDiffB); if(c1 == 32) dataA = bmp_get_data(bmpDiffA); // (6) calcular diferencias if(c1 == 32) for(j=0;j<h1;j++) { for(i=0;i<w1;i++) { int pos = (j*w1+i)*4; uint8_t R1 = data1[pos+3]; uint8_t G1 = data1[pos+2]; uint8_t B1 = data1[pos+1]; uint8_t A1 = data1[pos+0]; uint8_t R2 = data2[pos+3]; uint8_t G2 = data2[pos+2]; uint8_t B2 = data2[pos+1]; uint8_t A2 = data2[pos+0]; dataR[pos+3] = cmp(R1,R2,i,j,"R",&opt); dataR[pos+2] = dataR[pos+3]; dataR[pos+1] = dataR[pos+3]; dataR[pos+0] = 255; dataG[pos+3] = cmp(G1,G2,i,j,"G",&opt); dataG[pos+2] = dataG[pos+3]; dataG[pos+1] = dataG[pos+3]; dataG[pos+0] = 255; dataB[pos+3] = cmp(B1,B2,i,j,"B",&opt); dataB[pos+2] = dataB[pos+3]; dataB[pos+1] = dataB[pos+3]; dataB[pos+0] = 255; dataA[pos+3] = cmp(A1,A2,i,j,"A",&opt); dataA[pos+2] = dataA[pos+3]; dataA[pos+1] = dataA[pos+3]; dataA[pos+0] = 255; } } if(c1 == 24) for(j=0;j<h1;j++) { for(i=0;i<w1;i++) { int pos = (j*w1+i)*3; uint8_t R1 = data1[pos+2]; uint8_t G1 = data1[pos+1]; uint8_t B1 = data1[pos+0]; uint8_t R2 = data2[pos+2]; uint8_t G2 = data2[pos+1]; uint8_t B2 = data2[pos+0]; dataR[pos+2] = cmp(R1,R2,i,j,"R",&opt); dataR[pos+1] = dataR[pos+2]; dataR[pos+0] = dataR[pos+2]; dataG[pos+2] = cmp(G1,G2,i,j,"G",&opt); dataG[pos+1] = dataG[pos+2]; dataG[pos+0] = dataG[pos+2]; dataB[pos+2] = cmp(B1,B2,i,j,"B",&opt); dataB[pos+1] = dataB[pos+2]; dataB[pos+0] = dataB[pos+2]; } } // (7) mostrar summary if(opt.summaryop) { for(i=1;i<256;i++) if(opt.summary[i]!=0) printf("%i\t%i\n",i,opt.summary[i]); } // (8) guardar resultados if(opt.image) { char* strX = "diffX.bmp"; char* fileSto = malloc(strlen(opt.file1)+5+1); strcpy(fileSto,opt.file1); strcpy(fileSto+len1-4,strX); fileSto[len1]='R'; bmp_save(fileSto,bmpDiffR); fileSto[len1]='G'; bmp_save(fileSto,bmpDiffG); fileSto[len1]='B'; bmp_save(fileSto,bmpDiffB); fileSto[len1]='A'; if(c1 == 32) bmp_save(fileSto,bmpDiffA); // (8.1) borrar las imagenes bmp_delete(bmp1); bmp_delete(bmp2); bmp_delete(bmpDiffR); bmp_delete(bmpDiffG); bmp_delete(bmpDiffB); if(c1 == 32) bmp_delete(bmpDiffA); } // (9) retorno error si encontre una diferencia for(i=opt.epsilon;i<256;i++) if(opt.summary[i]>0) return -1; return 0; }
int main(int argc, char * const argv[]) { char *buf; char *flag_str, *scale_str; size_t buflen, errcnt, i, skipped, tested; int r; int includeNegScale; int includeExabyteTests; int verbose; buflen = 4; includeNegScale = 0; includeExabyteTests = 0; verbose = 0; read_options(argc, argv, &buflen, &includeNegScale, &includeExabyteTests, &verbose); buf = malloc(buflen); errcnt = 0; tested = 0; skipped = 0; if (buflen != 4) printf("Warning: buffer size %zu != 4, expect some results to differ.\n", buflen); printf("1..%zu\n", nitems(test_args)); for (i = 0; i < nitems(test_args); i++) { /* KLUDGE */ if (test_args[i].num == INT64_MAX && buflen == 4) { /* Start final tests which require buffer of 6 */ free(buf); buflen = 6; buf = malloc(buflen); if (verbose) printf("Buffer length increased to %zu\n", buflen); } if (test_args[i].scale < 0 && ! includeNegScale) { skipped++; testskipped(i + 1); continue; } if (test_args[i].num >= halfExabyte && ! includeExabyteTests) { skipped++; testskipped(i + 1); continue; } r = humanize_number(buf, buflen, test_args[i].num, "", test_args[i].scale, test_args[i].flags); flag_str = str_flags(test_args[i].flags, "[no flags]"); scale_str = str_scale(test_args[i].scale); if (r != test_args[i].retval) { if (verbose) printf("wrong return value on index %zu, " "buflen: %zu, got: %d + \"%s\", " "expected %d + \"%s\"; num = %jd, " "scale = %s, flags= %s.\n", i, buflen, r, buf, test_args[i].retval, test_args[i].res, (intmax_t)test_args[i].num, scale_str, flag_str); else printf("not ok %zu # return %d != %d\n", i + 1, r, test_args[i].retval); errcnt++; } else if (strcmp(buf, test_args[i].res) != 0) { if (verbose) printf("result mismatch on index %zu, got: " "\"%s\", expected \"%s\"; num = %jd, " "scale = %s, flags= %s.\n", i, buf, test_args[i].res, (intmax_t)test_args[i].num, scale_str, flag_str); else printf("not ok %zu # buf \"%s\" != \"%s\"\n", i + 1, buf, test_args[i].res); errcnt++; } else { if (verbose) printf("successful result on index %zu, " "returned %d, got: \"%s\"; num = %jd, " "scale = %s, flags= %s.\n", i, r, buf, (intmax_t)test_args[i].num, scale_str, flag_str); else printf("ok %zu\n", i + 1); } tested++; } if (verbose) printf("total errors: %zu/%zu tests, %zu skipped\n", errcnt, tested, skipped); if (errcnt) return 1; return 0; }
/** Instantiates an Environment and attaches an Interpreter to interact with the command line. */ int main( int argc, char *argv[] ) { int status = EXIT_SUCCESS; Environment *env; Interpreter *itp; Parser *p; static char source_file[0x100]; *source_file = '\0'; #if USE_NCURSES initscr(); #endif read_options( argc, argv, source_file ); if ( !( env = environment__new() ) ) status = EXIT_FAILURE; else { if ( ( itp = interpreter__new( env, quiet_flag, version_flag ) ) ) { p = parser__new( itp ); if ( *source_file ) { #if DEBUG__MAIN PRINT( "Loading namespace from file...\n" ); #endif interpreter__deserialize( itp, source_file ); } if ( !quiet_flag ) { print_version(); print_copying(); REFRESH; } /* parser__feed( p, "here;" ); parser__feed( p, "here;" ); if ( interpreter__parse( itp ) ) ERROR( "main: parse failed" ); parser__feed( p, "_size;" ); if ( interpreter__parse( itp ) ) ERROR( "main: parse failed" ); parser__feed( p, ";here;" ); */ if ( parser__parse( p ) ) ERROR( "main: parse failed" ); interpreter__delete( itp ); parser__free( p ); } else status = EXIT_FAILURE; environment__delete( env ); } #if USE_NCURSES endwin(); #endif #if DEBUG__ALLOC debug__memcheck(); #endif /* See: http://www.jetcafe.org/~jim/c-style.html#Expressions */ exit( status ); }
int main(int argc, char* argv[]) { read_options(argc, argv); //loading image imgc = cvLoadImage(input_file,-1); if (imgc->nChannels > 1) { color = 1; img = cvLoadImage(input_file,CV_LOAD_IMAGE_GRAYSCALE); } else { img = imgc; } if(!img) { printf("Could not load image file: %s\n",input_file); return 1; } else { if (verbose) printf("Loaded file: %s\n",input_file); if (verbose) printf("dimensions %dx%dpx, channels: %d\n",img->width,img->height,imgc->nChannels); } XS=img->width; YS=img->height; // different settings for small or large images if (YS > 512) { RY=RY_big; MO=MO_big; YO1=YO1_big; YO2=YO2_big; } else { RY=RY_small; MO=MO_small; YO1=YO1_small; YO2=YO2_small; } // generate image buffer according to image size IM = (uchar *) malloc (XS*YS * sizeof(uchar)); IMV = (uchar *) malloc (XS*YS * sizeof(uchar)); IM1 = (uchar *) malloc (XS*YS * sizeof(uchar)); if (color) { IMB = (uchar *) malloc (XS*YS * sizeof(uchar)); IMG = (uchar *) malloc (XS*YS * sizeof(uchar)); IMR = (uchar *) malloc (XS*YS * sizeof(uchar)); IM1B = (uchar *) malloc (XS*YS * sizeof(uchar)); IM1G = (uchar *) malloc (XS*YS * sizeof(uchar)); IM1R = (uchar *) malloc (XS*YS * sizeof(uchar)); } int x,y; //convert opencv image to array (in a really stupid way) for(x=0;x<XS;x++) { for(y=0;y<YS;y++) { IM[x+y*XS] = ((uchar *)(img->imageData + y*img->widthStep))[x]; if (color) { IMB[x+y*XS] = ((uchar *)(imgc->imageData + y*imgc->widthStep))[x*imgc->nChannels]; IMG[x+y*XS] = ((uchar *)(imgc->imageData + y*imgc->widthStep))[x*imgc->nChannels+1]; IMR[x+y*XS] = ((uchar *)(imgc->imageData + y*imgc->widthStep))[x*imgc->nChannels+2]; } } } //---------- important algo begins here //vertical gradient if (verbose) printf("calculate vertical gradient..\n"); for (x=0; x<XS; x++) { for (y=0; y<YS; y++) { if (y<2||y+1>=YS) IMV[x+y*XS]=128; else IMV[x+y*XS]=int(IM[x+(y-2)*XS])+int(IM[x+(y-1)*XS])-int(IM[x+(y-1)*XS])-int(IM[x+(y-1)*XS])+128; } } //calculating ydeltas if (verbose) printf("calculate x&ydeltas...\n"); maxn ms; int no, x2, mo, y1, y2; for (x=0; x<XS; x++) { for (no=0; no<NO; no++) if (in(x2=x+XO[no],XS)) { minn md;//minimalizator for (mo=0; mo<MO; mo++) { int sumsq=0; for (y=RY; y+RY<YS; y++) { y1=y+YO1[mo]; y2=y+YO2[mo]; int deltasq=square(int(IMV[x+y1*XS])-int(IMV[x2+y2*XS])); // if (deltasq>=square(8)) sumsq+=deltasq; } md.add(YO2[mo]-YO1[mo],sumsq); // GD.point(0, x, sumsq/XS/10, COLOR12[mo],1); } // GD.point(0, x, md.minv()/XS/10, COLOR12[md.mini()],1); dta[x][no]=md.mini();//best fit between verticals ssq[x][no]=md.minv();//distance ms.add(md.minv()); } } memset(P, 0, sizeof P); const double F1=1.;//force to zero const double F2=4000.;//ofset force // const double F3=400.;//smoothing force int t; //applying ofsets if (verbose) printf("apply offsets...\n"); for (t=0; t<400; t++) { memset(Q, 0, sizeof Q); memset(W, 0, sizeof W); for (x=0; x<XS; x++) { W[x]+=F1; for (no=0; no<NO; no++) if (in(x2=x+XO[no],XS)) { int d=dta[x][no]; int s=ssq[x][no]; // if (s>100000) continue; double f=F2*.5/NO*corrfn(s,0,100000); W[x]+=f; Q[x]+=f*(P[x2]-d); W[x2]+=f; Q[x2]+=f*(P[x]+d); } #if 0//smoothing > later if (x>0) { W[x]+=F3; Q[x]+=F3*P[x-1]; } if (x+1<XS) { W[x]+=F3; Q[x]+=F3*P[x+1]; } #endif } for (x=0; x<XS; x++) { P[x]=Q[x]/W[x]; } } //smoothing if (verbose) printf("smoothing\n"); const double F4=1.;//force to intermediate curve const double F5=1.;//smoothing force memcpy(R, P, sizeof R); for (t=0; t<100; t++) { memset(Q, 0, sizeof Q); memset(W, 0, sizeof W); for (x=0; x<XS; x++) { Q[x]+=F4*R[x]; W[x]+=F4; if (x>0) { W[x]+=F5; Q[x]+=F5*P[x-1]; } if (x+1<XS) { W[x]+=F5; Q[x]+=F5*P[x+1]; } } for (x=0; x<XS; x++) { P[x]=Q[x]/W[x]; } } /* //drawing out the red line for (x=0; x<XS; x++) { GD.point(0, fix(x), fix(135.+P[x]), 0xFF, 1); } */ //result image if (verbose) printf("calculate result images...\n"); for (x=0; x<XS; x++) { for (y=0; y<YS; y++) { int y1=y+int(P[x]+.5); if (color) { IM1B[x+y*XS] = bg_c; IM1G[x+y*XS] = bg_c; IM1R[x+y*XS] = bg_c; } else { IM1[x+y*XS]= bg_c; } if (in(y1,YS)) { //IM1[x+y*XS]=IM[x+y1*XS]; if (color) { IM1B[x+y*XS]=valfr1(IMB, XS, 16*x, int(16.*(y+P[x])), 4); IM1G[x+y*XS]=valfr1(IMG, XS, 16*x, int(16.*(y+P[x])), 4); IM1R[x+y*XS]=valfr1(IMR, XS, 16*x, int(16.*(y+P[x])), 4); } else { IM1[x+y*XS]=valfr1(IM, XS, 16*x, int(16.*(y+P[x])), 4); } //((uchar *)(out->imageData + y*img->widthStep))[x] = IM[x+y1*XS]; } } } //---------- important algo ends here // now convert back to opencv image (very stupid!) if (color) out = cvCreateImage(cvSize(XS,YS),IPL_DEPTH_8U,3); else out = cvCreateImage(cvSize(XS,YS),IPL_DEPTH_8U,1); for(x=0;x<XS;x++) { for(y=0;y<YS;y++) { if (color) { ((uchar *)(out->imageData + y*imgc->widthStep))[x*imgc->nChannels] = IM1B[x+y*XS]; ((uchar *)(out->imageData + y*imgc->widthStep))[x*imgc->nChannels+1] = IM1G[x+y*XS]; ((uchar *)(out->imageData + y*imgc->widthStep))[x*imgc->nChannels+2] = IM1R[x+y*XS]; } else { ((uchar *)(out->imageData + y*imgc->widthStep))[x] = IM1[x+y*XS]; } } } //save file if (verbose) printf("saving file %s\n",output_file); if(!cvSaveImage(output_file, out)) { printf("Could not save: file\n"); return 1; } return 0; }
/** * RHash program entry point. * * @param argc number of program arguments including the program path * @param argv program arguments * @return the program exit code, zero on success and 1 on error */ int main(int argc, char *argv[]) { find_file_options search_opt; timedelta_t timer; int sfv; i18n_initialize(); /* initialize locale and translation */ memset(&rhash_data, 0, sizeof(rhash_data)); rhash_data.out = stdout; /* set initial output streams */ rhash_data.log = stderr; /* can be altered by options later */ rhash_data.search_opt = &search_opt; init_hash_info_table(); read_options(argc, argv); /* load config and parse command line options */ prev_sigint_handler = signal(SIGINT, ctrl_c_handler); /* install SIGINT handler */ rhash_library_init(); /* in benchmark mode just run benchmark and exit */ if(opt.mode & MODE_BENCHMARK) { unsigned flags = (opt.flags & OPT_BENCH_RAW ? RHASH_BENCHMARK_CPB | RHASH_BENCHMARK_RAW : RHASH_BENCHMARK_CPB); if((opt.flags & OPT_BENCH_RAW) == 0) { fprintf(rhash_data.out, _("%s v%s benchmarking...\n"), PROGRAM_NAME, VERSION); } rhash_run_benchmark(opt.sum_flags, flags, rhash_data.out); rsh_exit(0); } if(opt.n_files == 0) { if(argc > 1) { log_warning(_("no files/directories were specified at command line\n")); } /* print short usage help */ log_msg(_("Usage: %s [OPTION...] <FILE>...\n\n" "Run `%s --help' for more help.\n"), CMD_FILENAME, CMD_FILENAME); rsh_exit(0); } /* setup printf formating string */ rhash_data.printf_str = opt.printf_str; if(opt.template_file) { if(!load_printf_template()) rsh_exit(2); } else if(!rhash_data.printf_str && !(opt.mode & (MODE_CHECK | MODE_CHECK_EMBEDDED))) { /* initialize printf output format according to '--<hashname>' options */ init_printf_format( (rhash_data.template_text = rsh_str_new()) ); rhash_data.printf_str = rhash_data.template_text->str; if(opt.flags & OPT_VERBOSE) { char* str = rsh_strdup(rhash_data.printf_str); log_msg(_("Format string is: %s\n"), str_trim(str)); free(str); } } if(rhash_data.printf_str) { rhash_data.print_list = parse_print_string(rhash_data.printf_str, &opt.sum_flags); } memset(&search_opt, 0, sizeof(search_opt)); search_opt.max_depth = (opt.flags & OPT_RECURSIVE ? opt.find_max_depth : 0); search_opt.options = FIND_SKIP_DIRS; search_opt.call_back = find_file_callback; if((sfv = (opt.fmt == FMT_SFV && !opt.mode))) { print_sfv_banner(rhash_data.out); } /* pre-process files */ if(sfv || opt.bt_batch_file) { /* note: errors are not reported on pre-processing */ search_opt.call_back_data = (void*)1; process_files((const char**)opt.files, opt.n_files, &search_opt); fflush(rhash_data.out); } /* measure total processing time */ rhash_timer_start(&timer); rhash_data.processed = 0; /* process files */ search_opt.options |= FIND_LOG_ERRORS; search_opt.call_back_data = (void*)0; process_files((const char**)opt.files, opt.n_files, &search_opt); if((opt.mode & MODE_CHECK_EMBEDDED) && rhash_data.processed > 1) { print_check_stats(); } if(!rhash_data.interrupted) { if(opt.bt_batch_file && rhash_data.rctx) { rhash_final(rhash_data.rctx, 0); save_torrent_to(opt.bt_batch_file, rhash_data.rctx); } if((opt.flags & OPT_SPEED) && !(opt.mode & (MODE_CHECK | MODE_UPDATE)) && rhash_data.processed > 1) { double time = rhash_timer_stop(&timer); print_time_stats(time, rhash_data.total_size, 1); } } else { /* check if interruption was not reported yet */ if(rhash_data.interrupted == 1) report_interrupted(); } options_destroy(&opt); rhash_destroy(&rhash_data); /* return non-zero error code if error occurred */ return (rhash_data.error_flag ? 1 : search_opt.errors_count ? 2 : rhash_data.interrupted ? 3 : 0); }