Example #1
0
int
main(int argc, char *argv[])
{
    struct hooks_t hooks;
    struct files_t files;
    //int c;

    /* TODO: Parse command line arguments */
    parse_commandline(argc, argv);
    
    /* TODO: Initialize hooks and files lists */
    TAILQ_INIT(&hooks);
    TAILQ_INIT(&files);
        
    /* TODO: Load hooks */
    set_hooks(&hooks);
    
     // TODO: Continuously check directory and timestamps
    //while(true){
        char *timestamp = timestamp_string();
        check_directory(directory, &hooks, &files, recursive,(time_t) timestamp);
        sleep(1);
    //}
    
    return (EXIT_SUCCESS);
}
Example #2
0
File: divvy.c Project: eduffy/divvy
int main(int argc, char *argv[])
{
   double         clock;
   struct buffer  buf;
   char          *pattern = NULL;
   char          *infile  = NULL;
   char          *outdir = strdup(".");

   parse_commandline(argc, argv, &pattern, &infile, &outdir);
   if(infile == NULL)
      return EXIT_FAILURE;

   MPI_Init(&argc, &argv);

   tic(&clock);

   load_file(infile, &buf);
   toc(&clock, "Read input:");

   transfer_partials(pattern, &buf);
   toc(&clock, "Transfer:");

   write_chunks(infile, outdir, &buf);
   toc(&clock, "Write chunks:");

   MPI_Finalize();
   free(buf.data);
   free(pattern);
   free(infile);
   return EXIT_SUCCESS;
}
Example #3
0
    /* configuration-dependent initialization */
int main_configure(char *arg1, char *arg2) {
    if(parse_commandline(arg1, arg2))
        return 1;
    str_canary_init(); /* needs prng initialization from parse_commandline */
#if !defined(USE_WIN32) && !defined(__vms)
    /* syslog_open() must be called before change_root()
     * to be able to access /dev/log socket */
    syslog_open();
#endif /* !defined(USE_WIN32) && !defined(__vms) */
    if(bind_ports())
        return 1;

#ifdef HAVE_CHROOT
    /* change_root() must be called before drop_privileges()
     * since chroot() needs root privileges */
    if(change_root())
        return 1;
#endif /* HAVE_CHROOT */

#if !defined(USE_WIN32) && !defined(__vms) && !defined(USE_OS2)
    if(drop_privileges(1))
        return 1;
#endif /* standard Unix */

    /* log_open() must be be called after drop_privileges()
     * or logfile rotation won't be possible */
    /* log_open() must be be called before daemonize()
     * since daemonize() invalidates stderr */
    log_open();
    return 0;
}
Example #4
0
int PASCAL WinMain(HINSTANCE hInst,HINSTANCE hPrev,LPSTR szCmdLine,int sw)
{
	char		szModuleName[260];
	GetModuleFileName(hInst,szModuleName,sizeof(szModuleName));
	parse_commandline(szModuleName,szCmdLine,&argc,argv,MAX_ARGV);
	return main(argc,argv);
}
Example #5
0
/*---------------------------------------------------------------*/
int main(int argc, char *argv[]) {
  int nargs;

  nargs = handle_version_option (argc, argv, vcid, "$Name: stable5 $");
  if (nargs && argc - nargs == 1) exit (0);
  argc -= nargs;
  cmdline = argv2cmdline(argc,argv);
  uname(&uts);
  getcwd(cwd,2000);

  Progname = argv[0] ;
  argc --;
  argv++;
  ErrorInit(NULL, NULL, NULL) ;
  DiagInit(NULL, NULL, NULL) ;
  if (argc == 0) usage_exit();
  parse_commandline(argc, argv);
  check_options();
  if (checkoptsonly) return(0);
  dump_options(stdout);

  SUBJECTS_DIR = getenv("SUBJECTS_DIR");
  if (SUBJECTS_DIR == NULL) {
    printf("ERROR: SUBJECTS_DIR not defined in environment\n");
    exit(1);
  }

  return 0;
}
Example #6
0
int
main(int argc, char **argv)
{

	/* Init configuration */
	init_config();
	parse_commandline(argc, argv);

	switch(config.command) {
	case WDCTL_STATUS:
		wdctl_status();
		break;

	// 停掉 wifidog进程
	case WDCTL_STOP:
		wdctl_stop();
		break;

	case WDCTL_KILL:
		wdctl_reset();
		break;

	case WDCTL_RESTART:
		wdctl_restart();
		break;

	default:
		/* XXX NEVER REACHED */
		fprintf(stderr, "Oops\n");
		exit(1);
		break;
	}
	exit(0);
}
Example #7
0
int main(int argc, const char **argv)
{
  clioptions opts;
  parse_commandline(argc, argv, &opts);
  run_server(&opts);
  return 0;
}
Example #8
0
File: mclrecv.c Project: jcable/mcl
int
main (int	argc,
      char	*argv[])
{
	parse_commandline(argc, argv);
	mclget();
	exit(0);
}
Example #9
0
/** Reads the configuration file and then starts the main loop */
int main(int argc, char **argv) {

	s_config *config = config_get_config();
	config_init();

	parse_commandline(argc, argv);

	/* Initialize the config */
	config_read(config->configfile);
	config_validate();

	/* Initializes the linked list of connected clients */
	client_list_init();

	/* Init the signals to catch chld/quit/etc */
	init_signals();


	if (restart_orig_pid) {
		/*
		 * We were restarted and our parent is waiting for us to talk to it over the socket
		 */
		get_clients_from_parent();

		/*
		 * At this point the parent will start destroying itself and the firewall. Let it finish it's job before we continue
		 */
		while (kill(restart_orig_pid, 0) != -1) {
			debug(LOG_INFO, "Waiting for parent PID %d to die before continuing loading", restart_orig_pid);
			sleep(1);
		}

		debug(LOG_INFO, "Parent PID %d seems to be dead. Continuing loading.");
	}

	if (config->daemon) {

		debug(LOG_INFO, "Forking into background");

		switch(safe_fork()) {
			case 0: /* child */
				setsid();
				append_x_restartargv();
				main_loop();
				break;

			default: /* parent */
				exit(0);
				break;
		}
	}
	else {
		append_x_restartargv();
		main_loop();
	}

	return(0); /* never reached */
}
Example #10
0
int main (int argc, char *argv[])
{
	srand (time (NULL));
	omp_set_nested (1);
	omp_set_num_threads (16);
	// process command line
	parse_commandline (&argc, &argv);
	LOG (INFO) << "rtrt init";
	Window win (FLAGS_width, FLAGS_height, FLAGS_fullscreen, "Real-time Ray Tracer", FLAGS_interval);
	Image front (win.width(), win.height()), back (win.width(), win.height()); // create the images
	Image *front_p = &front, *back_p = &back;
	World world;
	//world.fill(75, 4);
	world.demo0();
	RayTracer rt (world);
	#pragma omp parallel
	{
		#pragma omp single nowait
		{
			while (win.is_running())
			{
				// update frame
				PerformanceMonitor::instance().RT_FPS.count();
				//win.update_frame_rate();
				win.clearXY();
				// render the new back buffer
				rt.render (back_p);
				// swap buffers
				std::swap (front_p, back_p);
			}
		}
		#pragma omp master
		{
			while (win.is_running())
			{
				// main rendering loop, keep rendering the front buffer
				PerformanceMonitor::instance().GL_FPS.count();
				win.clear(); // clear the render windows back buffer

				if (FLAGS_fps)
				{
					win.update_title_with_frame_rate();    // show the frame rate in the window title
				}

				win.render_image (*front_p); // render the image to the back buffer
				win.update(); // swap the back buffer with the front buffer
				PerformanceMonitor::instance().update();
			}
		}
	}
	LOG (INFO) << "shutting down";
	LOG (INFO) << "Average frame rate was " << win.average_framerate();
	front.destroy_image();
	back.destroy_image();
	win.destroy_window();
	LOG (INFO) << PerformanceMonitor::instance();
	return (0);
}
Example #11
0
int main(int argc, char* argv[])
{
    char* prmfname = NULL;

    parse_commandline(argc, argv, &prmfname);
    gridgen_generategrid(prmfname);

    return 0;
}
/******************************************************************************
 *                                                                            *
 * Function:                                                                  *
 *                                                                            *
 * Purpose:                                                                   *
 *                                                                            *
 * Parameters:                                                                *
 *                                                                            *
 * Return value:                                                              *
 *                                                                            *
 * Comments:                                                                  *
 *                                                                            *
 ******************************************************************************/
int main(int argc, char **argv)
{
    progname = get_program_name(argv[0]);
    parse_commandline(argc, argv);
    ja_load_config(CONFIG_FILE);

    START_MAIN_ZABBIX_ENTRY(CONFIG_ALLOW_ROOT);
    exit(SUCCEED);
}
Example #13
0
void telemetry::parse_input()
{
   if(get_protocol() == protocol_t::command_line){
      parse_commandline();
   }else{
      parse_av_cobs();
      telemetry::parse_frsky_bytestuff();
   }
 //  parse_input_from_FrSky_with_cobs_protocol();
}
/**
*
* \brief implements the message server, which spawn the buisness logic process
*
* This is the main entry point for any C program.
*
* \param argc the number of arguments
* \param argv the arguments itselves (including the program name in argv[0])
*
* \return success or failure
*
*/
int main(int argc, const char * const * argv)
{
    
    int sockfd          = -1;  /* listen on sockfd */
    int sockfdchild     = -1;  /* new connection on sockfdchild */
    struct sockaddr_storage their_addr; /* client's address information */
    socklen_t sin_size  = -1;
    pid_t pid = -1;
    
    parse_commandline(argc,argv);
    
	sockfd = get_port(sockfd, argv);
    
    
    while(1) {  /* loop to accept() connections */
        sin_size = sizeof their_addr;
        sockfdchild = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size);
        if (sockfdchild == -1) {
            perror("accept");
            continue;
        }
        
       switch (pid = fork()) /*forking the child....*/
       {
		   case -1: { /*error*/
					close(sockfdchild);
					close(sockfd);
					fprintf(stderr,"error after forking");
					exit(1); /*maybe it would be better not to exit the program here...*/
					break;
			}
		   case 0:{/*child process*/
					close(sockfd);
					if (dup2(sockfdchild,0) == -1){ /*Umwandeln stdin*/
						close(sockfdchild);
						exit(EXIT_FAILURE);
					}
					if (dup2(sockfdchild,1) == -1){ /*Umwandeln stdout*/
						close(sockfdchild);
						exit(EXIT_FAILURE);
					}
                    errno = 0;
                    (void) execlp(PATHBULOGIC,"simple_message_server_logic" ,NULL);
                                        
					fprintf(stderr, "execlp() failed: %s\n", strerror(errno));
					exit(EXIT_FAILURE); 
		   }
		   default:{ /*mother process*/
					close(sockfdchild);  /* parent doesn't need this */
			}
	   }  
    }
    exit(EXIT_SUCCESS);
}
Example #15
0
int main(int argc, char* const argv[]) {
    SkTArray<SkString> inputs;
    sk_tools::PictureBenchmark* benchmark = NULL;

    parse_commandline(argc, argv, &inputs, benchmark);

    for (int i = 0; i < inputs.count(); ++i) {
        process_input(inputs[i], *benchmark);
    }

    SkDELETE(benchmark);
}
int main (int argc, char * const * const argv)
{
    NVQRConnection connection;
    NVQRQueryDataBuffer data;
    pid_t pid = 0;
    GLenum queryType;
    nvqrReturn_t result;

    result = parse_commandline(argc, argv, &pid, &queryType);
    if (result != NVQR_SUCCESS) {
        fprintf(stderr, "%s: invalid command line\n", argv[0]);
        return result;
    }

    result = nvqr_connect(&connection, pid);
    if (result != NVQR_SUCCESS) {
        if (result == NVQR_ERROR_NOT_SUPPORTED &&
            connection.process_name) {
            printf("Resource query not supported for '%s' (pid %ld)\n",
                   connection.process_name, (long) connection.pid);
        } else {
            fprintf(stderr, "Error: failed to open connection to pid %ld\n",
                    (long) connection.pid);
        }
        return result;
    }

    result = nvqr_request_meminfo(connection, queryType, &data);
    if (result == NVQR_SUCCESS) {
        int version = nvqr_get_data_format_version(data.data);
        if (version < NVQR_MIN_DATA_FORMAT_VERSION ||
            version > NVQR_MAX_DATA_FORMAT_VERSION) {
            fprintf(stderr, "Error: unrecognized data format version '%d'. "
                    "(Minimum supported: %d; Maximum supported: %d)\n", version,
                    NVQR_MIN_DATA_FORMAT_VERSION, NVQR_MAX_DATA_FORMAT_VERSION);
        }

        if (connection.process_name) {
            printf("%s, pid = %ld, data format version %d\n",
                   connection.process_name, (long) connection.pid, version);
        }

        print_memory_info(queryType, data.data);
    } else {
        fprintf(stderr, "Error: failed to query resource usage information "
                "for pid %ld.\n", (long) connection.pid);
    }

    result = nvqr_disconnect(&connection);
    return result;
}
Example #17
0
int main(int argc, char **argv)
{
	static acs_cli_info_t ai;
	int rc;

	/* Initalise our context object */
	memset(&ai, 0, sizeof(ai));
	ai.wl_ifname	= DEFAULT_WL_IFNAME;
	ai.server_host	= DEFAULT_SERVER_HOST;
	ai.server_port	= DEFAULT_SERVER_PORT;
	ai.socket	= -1;
	for (rc = 0; rc < CMDARG_MAX; ++rc) {
		ai.cmdarg[rc] = "";
	}

	rc = parse_commandline(&ai, argc, argv);
	if (rc != BCME_OK) {
		return rc;
	}

	switch (ai.action) {

	case ACTION_SHOW_COMMANDS:
		rc = show_command_list();
		break;

	case ACTION_SHOW_USAGE:
		rc = BCME_OK;
		usage(argv[0]);
		break;

	case ACTION_REPORT_VARIABLES:
		rc = report_all_variables(&ai);
		break;

	case ACTION_REPORT_EVERYTHING:
		rc = report_everything(&ai);
		break;

	case ACTION_DO_COMMAND:
		rc = connect_to_server(&ai);
		if (rc == BCME_OK) {
			rc = do_command_response(&ai);
			disconnect_from_server(&ai);
		}
		break;
	}
	return rc;
}
Example #18
0
int
main(int argc, char *argv[])
{
   parse_commandline(argc, argv);
  
   signal(SIGINT, sigproc);
   signal(SIGQUIT, sigproc);
   
   //infinte loop to pipe input until program is killed
   for(;;) {
	pipeInput();
   }

   return (EXIT_SUCCESS);
}
Example #19
0
/** Entry point to tor-gencert */
int
main(int argc, char **argv)
{
  int r = 1;
  init_logging(1);

  /* Don't bother using acceleration. */
  if (crypto_global_init(0, NULL, NULL)) {
    fprintf(stderr, "Couldn't initialize crypto library.\n");
    return 1;
  }
  if (crypto_seed_rng()) {
    fprintf(stderr, "Couldn't seed RNG.\n");
    goto done;
  }
  /* Make sure that files are made private. */
  umask(0077);

  if (parse_commandline(argc, argv))
    goto done;
  if (load_identity_key())
    goto done;
  if (reuse_signing_key) {
    if (load_signing_key())
      goto done;
  } else {
    if (generate_signing_key())
      goto done;
  }
  if (generate_certificate())
    goto done;

  r = 0;
 done:
  clear_passphrase();
  if (identity_key)
    EVP_PKEY_free(identity_key);
  if (signing_key)
    EVP_PKEY_free(signing_key);
  tor_free(address);
  tor_free(identity_key_file);
  tor_free(signing_key_file);
  tor_free(certificate_file);
  tor_free(address);

  crypto_global_cleanup();
  return r;
}
Example #20
0
int main(int argc, char* argv[])
{
    char* fname = NULL;
    int ij = 0;
    int compact = 0;
    NODETYPE nt = NT_DD;
    gridnodes* gn = NULL;
    poly* pl = NULL;

    parse_commandline(argc, argv, &fname, &compact, &ij, &nt);

    if (nt == NT_DD) {
        /*
         * read DD grid nodes 
         */
        gridnodes* gndd = gridnodes_read(fname, NT_DD);

        gridnodes_validate(gndd);
        /*
         * get corner grid nodes from DD grid nodes 
         */
        gn = gridnodes_transform(gndd, NT_COR);
        gridnodes_destroy(gndd);
    } else {
        gn = gridnodes_read(fname, NT_COR);
        gridnodes_validate(gn);
    }

    /*
     * build boundary polygon 
     */
    if (!ij)
        pl = poly_formbound(gridnodes_getnce1(gn), gridnodes_getnce2(gn), gridnodes_getx(gn), gridnodes_gety(gn));
    else
        pl = poly_formboundij(gridnodes_getnce1(gn), gridnodes_getnce2(gn), gridnodes_getx(gn));

    if (compact)
        poly_compact(pl, 1.0e-10);

    poly_write(pl, stdout);

    poly_destroy(pl);
    gridnodes_destroy(gn);

    return 0;
}
Example #21
0
int main(int argc, char *argv[])
{

    print_level = LOG_NOTICE;
    // print_level = LOG_DEBUG;
    if (!parse_commandline(argc, argv)) {
        help();
        return 1;
    }
    sprintf(program_info, "pidp11_blinkenlightd - Blinkenlight API server daemon for PiDP11 %s",
    VERSION);

//    info();

    print(LOG_INFO, "Start\n");

    // link set/get events
    blinkenlight_api_panel_get_controlvalues_evt = on_blinkenlight_api_panel_get_controlvalues;
    blinkenlight_api_panel_set_controlvalue_evt = on_blinkenlight_api_panel_set_controlvalue;
    blinkenlight_api_panel_set_controlvalues_evt = on_blinkenlight_api_panel_set_controlvalues;
    blinkenlight_api_panel_get_state_evt = on_blinkenlight_api_panel_get_state;
    blinkenlight_api_panel_set_state_evt = on_blinkenlight_api_panel_set_state;
    blinkenlight_api_panel_get_mode_evt = on_blinkenlight_api_panel_get_mode;
    blinkenlight_api_panel_set_mode_evt = on_blinkenlight_api_panel_set_mode;
    blinkenlight_api_get_info_evt = on_blinkenlight_api_get_info;

    register_controls();

    if (opt_test) {
        printf("Dump of register <-> control data struct:\n");
        blinkenlight_panels_diagprint(blinkenlight_panel_list, stdout);
        exit(0);
    }

    gpio_mux_thread_start();
    gpiopattern_start_thread();

    blinkenlight_api_server();
    // does never end!

    print_close(); // well ....

    blinkenlight_panels_destructor(blinkenlight_panel_list);

    return 0;
}
static pascal OSErr CmdLineMessage(const AppleEvent *evt, AppleEvent *b, long c)
{
  AEDescList	cmdList;
  DescType	retType;
  AEKeyword	keywd;
  char          *cmdLine;
  long          size;

  AEGetParamDesc(evt, keyDirectObject, typeAEList, &cmdList);
  size = 1023;
  cmdLine = (char *)malloc(size + 1);
  AEGetNthPtr(&cmdList, 1, typeChar, &keywd, &retType, (Ptr)cmdLine, size, &size);

  cmdLine[size] = 0;
  scheme_mac_ready = 1;
  parse_commandline(cmdLine, NULL, 0);
  
  return 0;
}
Example #23
0
/*---------------------------------------------------------------*/
int main(int argc, char *argv[]) {
  int nargs;
  char *surf1_fname ;
  char *surf2_fname ;
  char *out_fname ;
  MRI_SURFACE *mris1, *mris2 ;

  nargs = handle_version_option (argc, argv, vcid, "$Name:  $");
  if (nargs && argc - nargs == 1) exit (0);
  argc -= nargs;
  cmdline = argv2cmdline(argc,argv);
  uname(&uts);
  getcwd(cwd,2000);

  Progname = argv[0] ;
  argc --;
  argv++;
  ErrorInit(NULL, NULL, NULL) ;
  DiagInit(NULL, NULL, NULL) ;
  if (argc == 0) usage_exit();
  parse_commandline(argc, argv);
  check_options();
  if (checkoptsonly) return(0);
  dump_options(stdout);

  SUBJECTS_DIR = getenv("SUBJECTS_DIR");
  if (SUBJECTS_DIR == NULL) {
    printf("ERROR: SUBJECTS_DIR not defined in environment\n");
    exit(1);
  }

  surf1_fname = argv[0] ; surf2_fname = argv[1] ; out_fname = argv[2] ; 
  mris1 = MRISread(surf1_fname) ;
  if (mris1 == NULL)
    ErrorExit(ERROR_NOFILE, "could not read surface 1 from %s", surf1_fname) ;
  mris2 = MRISread(surf2_fname) ;
  if (mris2 == NULL)
    ErrorExit(ERROR_NOFILE, "could not read surface 2 from %s", surf2_fname) ;

  compute_surface_distance(mris1, mris2, mris1) ;
  MRISwriteValues(mris1, out_fname) ;
  return 0;
}
Example #24
0
int main (int argc, char **argv)
{
	
	//初始化必要的资源
	if( init_resource() < 0 ){
		debug(LOG_ERR, " init_resource fail !");
		return -1;		
	}
	
	parse_commandline(argc, argv);
	
	/* Init the signals to catch chld/quit/etc */
	init_signals();

	if( do_process() < 0 ) {
		debug(LOG_ERR, " do_process fail !");
		exit(-1);
	}
	debug(LOG_ERR, "%s : QUIT do_process()",__FUNCTION__);
	return 0;
}
Example #25
0
/* main
 * in: argc, argv:  Classic commandline parameters. 
 * returns: int: 0: success, !0: !success :-)
 */
int main(int argc, char ** argv)
{ 
  parameters_t param;
  sh_param = &param;

  y4m_accept_extensions(1);

  parse_commandline(argc, argv, &param);
  mjpeg_default_handler_verbosity(param.verbose);

  mjpeg_info("Parsing & checking input files.");
  if (init_parse_files(&param)) {
    mjpeg_error_exit1("* Error processing the PNG input.");
  }

  if (generate_YUV4MPEG(&param)) { 
    mjpeg_error_exit1("* Error processing the input files.");
  }

  return 0;
}
Example #26
0
/** Main entry point for nodogsplash.
 * Reads the configuration file and then starts the main loop.
 */
int main(int argc, char **argv) {

  s_config *config = config_get_config();
  config_init();

  parse_commandline(argc, argv);

  /* Initialize the config */
  debug(LOG_NOTICE,"Reading and validating configuration file %s", config->configfile);
  config_read(config->configfile);
  config_validate();

  /* Initializes the linked list of connected clients */
  client_list_init();

  /* Init the signals to catch chld/quit/etc */
  debug(LOG_NOTICE,"Initializing signal handlers");
  init_signals();

  if (config->daemon) {

    debug(LOG_NOTICE, "Starting as daemon, forking to background");

    switch(safe_fork()) {
    case 0: /* child */
      setsid();
      main_loop();
      break;

    default: /* parent */
      exit(0);
      break;
    }
  }
  else {
    main_loop();
  }

  return(0); /* never reached */
}
Example #27
0
File: main.cpp Project: to-miz/tm
int main(int argc, char const* argv[]) {
    auto params = parse_commandline(argc, argv);
    if (!params.valid) {
        printf(
            "OVERVIEW: A tool to merge multiple C/C++ files into one.\n"
            "\n"
            "Parses #include \".*\" directives and merges contents into output file.\n"
            "Any #defines before such an include that starts with MERGE_ will be\n"
            "automatically expanded and #undef statements will be removed.\n"
            "\n"
            "USAGE: %s <in-filename> <out-filename> <include-dir>",
            argv[0]);
        return -1;
    }

    auto in = read_file(params.in);
    if (!in.success) {
        fprintf(stderr, "Can't read from %s\n", params.in);
        return -1;
    }

    merge_result result = {};
    do {
        result = merge(in.data, params.dir, result.merged_files);
        if (!result.success) {
            return -1;
        }
        if (params.recursive && result.changed) {
            in.data = std::move(result.data);
            in.data.push_back(0);
            result.data.clear();
        }
    } while (params.recursive && result.changed);

    if (!write_file(params.out, result.data)) {
        printf("Can't write to file %s\n", params.out);
        return -1;
    }
    return 0;
}
Example #28
0
/**
 * Mainloop of olsrd
 * @return exit code for olsrd
 */
static int
mainloop(int argc, char **argv, const struct oonf_appdata *appdata) {
  int exit_code = 0;

  OONF_INFO(LOG_MAIN, "Starting %s", appdata->app_name);

  /* enter main loop */
  while (oonf_cfg_is_running()) {
    /* call event scheduler */
    if (_handle_scheduling()) {
      exit_code = 1;
      break;
    }

    /* reload configuration if triggered */
    if (oonf_cfg_is_reload_set()) {
      OONF_INFO(LOG_MAIN, "Reloading configuration");
      if (oonf_cfg_clear_rawdb()) {
        break;
      }
      if (parse_commandline(argc, argv, appdata, true) == -1) {
        if (oonf_cfg_apply()) {
          break;
        }
      }
    }

    /* commit config if triggered */
    if (oonf_cfg_is_commit_set()) {
      OONF_INFO(LOG_MAIN, "Commiting configuration");
      if (oonf_cfg_apply()) {
        break;
      }
    }
  }

  OONF_INFO(LOG_MAIN, "Ending %s", appdata->app_name);
  return exit_code;
}
Example #29
0
int main(int argc, char **argv)
{
  parse_commandline(argc, argv);
  //dump_options();
  if (!std::strlen(gFile))
  {
    usage();
    std::exit(1);
  }

  acquire_board(gFile);
  Sudoku board(BASESIZE, SYMBOL_TYPE, Callback);
  board.SetupBoard(gBoard, std::strlen(gBoard));
  board.Solve();
  PrintStats(board);

  std::cout << std::endl;

  delete [] gBoard;

  return 0;
}
int tool_main(int argc, char** argv) {
    SkAutoGraphics ag;
    SkTArray<SkString> inputs;
    sk_tools::PictureRenderer* renderer = NULL;
    SkString* outputDir = NULL;
    bool validate = false;
    int maxComponentDiff = 256;
    bool writeWholeImage = false;
    int clones = 0;
    parse_commandline(argc, argv, &inputs, renderer, outputDir,
                      &validate, &maxComponentDiff, &writeWholeImage, &clones);
    SkASSERT(renderer);

    int failures = 0;
    for (int i = 0; i < inputs.count(); i ++) {
        failures += process_input(inputs[i], outputDir, *renderer,
                                  validate, maxComponentDiff,
                                  writeWholeImage, clones);
    }
    if (failures != 0) {
        SkDebugf("Failed to render %i pictures.\n", failures);
        return 1;
    }
#if SK_SUPPORT_GPU
#if GR_CACHE_STATS
    if (renderer->isUsingGpuDevice()) {
        GrContext* ctx = renderer->getGrContext();

        ctx->printCacheStats();
    }
#endif
#endif
    if (NULL != outputDir) {
        SkDELETE(outputDir);
    }
    SkDELETE(renderer);
    return 0;
}