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);
}

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;
}

    /* 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;
}

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);
}

/*---------------------------------------------------------------*/
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;
}

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);
}

int main(int argc, const char **argv)
{
  clioptions opts;
  parse_commandline(argc, argv, &opts);
  run_server(&opts);
  return 0;
}

int
main (int	argc,
      char	*argv[])
{
	parse_commandline(argc, argv);
	mclget();
	exit(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 */
}

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);
}

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);
}

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);
}

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;
}

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;
}

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);
}

/** 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;
}

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;
}