bool CommandFileinfo::setup(const std::vector<std::string>& arguments) {
po::variables_map vm;
try {
po::options_description cmdline("Allowed options");
cmdline.add_options()
("extended,e", "Extended output")
("input-format,F", po::value<std::string>(), "Format of input file")
;
po::options_description hidden("Hidden options");
hidden.add_options()
("input-filename", po::value<std::string>(), "Input file")
;
po::options_description desc("Allowed options");
desc.add(cmdline).add(hidden);
po::positional_options_description positional;
positional.add("input-filename", 1);
po::store(po::command_line_parser(arguments).options(desc).positional(positional).run(), vm);
po::notify(vm);
if (vm.count("extended")) {
m_extended = true;
}
if (vm.count("input-format")) {
m_input_format = vm["input-format"].as<std::string>();
}
if (vm.count("input-filename")) {
m_input_filename = vm["input-filename"].as<std::string>();
}
} catch (boost::program_options::error& e) {
std::cerr << "Error parsing command line: " << e.what() << std::endl;
return false;
}
if ((m_input_filename == "-" || m_input_filename == "") && m_input_format.empty()) {
std::cerr << "When reading from STDIN you need to use the --input-format,F option to declare the file format.\n";
return false;
}
m_input_file = osmium::io::File(m_input_filename, m_input_format);
return true;
}
std::string plugin_searcher::get_command_line() {
#if __linux__
std::ifstream cmdline("/proc/self/cmdline");
std::string file_contents;
std::string line;
while (std::getline(cmdline, line)) {
file_contents += line;
file_contents.push_back('\n'); //#TODO can linux even have more than one line?
}
std::cout << "cmdLine " << file_contents << "\n";
return file_contents;
#else
return GetCommandLineA();
#endif
}
int main_mip(int argc, char* argv[argc])
{
bool mIP = false;
const struct opt_s opts[] = {
OPT_SET('m', &mIP, "minimum" ),
};
cmdline(&argc, argv, 3, 3, usage_str, help_str, ARRAY_SIZE(opts), opts);
unsigned int flags = atoi(argv[1]);
long idims[DIMS];
complex float* in = load_cfl(argv[2], DIMS, idims);
long odims[DIMS];
md_select_dims(DIMS, ~flags, odims, idims);
complex float* out = create_cfl(argv[3], DIMS, odims);
complex float* tmp = md_alloc(DIMS, idims, CFL_SIZE);
md_zabs(DIMS, idims, tmp, in);
long istr[DIMS];
long ostr[DIMS];
md_calc_strides(DIMS, istr, idims, CFL_SIZE);
md_calc_strides(DIMS, ostr, odims, CFL_SIZE);
md_clear(DIMS, odims, out, CFL_SIZE);
md_max2(DIMS, idims, ostr, (float*)out, ostr, (const float*)out, istr, (const float*)tmp);
if (mIP) {
// need result of max in output
md_min2(DIMS, idims, ostr, (float*)out, ostr, (const float*)out, istr, (const float*)tmp);
}
md_free(tmp);
unmap_cfl(DIMS, idims, in);
unmap_cfl(DIMS, odims, out);
exit(0);
}
TEST(CommandLineTest, QuerySwitchValue)
{
kbase::CommandLine cmdline(L"C:\\windows\\system32\\notepad.exe -a=1 --maxmize --t=1024 D:\\test.txt");
std::wstring value;
bool rv = cmdline.GetSwitchValue(L"a", &value);
EXPECT_TRUE(rv);
EXPECT_EQ(value, L"1");
rv = cmdline.GetSwitchValue(L"maxmize", &value);
EXPECT_TRUE(rv);
EXPECT_TRUE(value.empty());
rv = cmdline.GetSwitchValue(L"ta", &value);
EXPECT_FALSE(rv);
}
int main_bitmask(int argc, char* argv[])
{
bool inverse = false;
long flags = 0;
const struct opt_s opts[] = {
{ 'b', false, opt_set, &inverse, "\tdimensions from bitmask" },
};
cmdline(&argc, argv, 0, 1000, usage_str, help_str, ARRAY_SIZE(opts), opts);
if ((2 != argc) && inverse)
error("exactly one argument needed.\n");
if (!inverse) {
for (int i = 1; i < argc; i++) {
int d = atoi(argv[i]);
assert(d >= 0);
flags = MD_SET(flags, d);
}
printf("%ld\n", flags);
} else {
int i = 0;
flags = atoi(argv[1]);
while (flags) {
if (flags & 1)
printf("%d ", i);
flags >>= 1;
i++;
}
printf("\n");
}
exit(0);
}
int main_reshape(int argc, char* argv[])
{
cmdline(&argc, argv, 3, 100, usage_str, help_str, 0, NULL);
num_init();
unsigned int flags = atoi(argv[1]);
unsigned int n = bitcount(flags);
assert((int)n + 3 == argc - 1);
long in_dims[DIMS];
long in_strs[DIMS];
long out_dims[DIMS];
long out_strs[DIMS];
complex float* in_data = load_cfl(argv[n + 2], DIMS, in_dims);
md_calc_strides(DIMS, in_strs, in_dims, CFL_SIZE);
md_copy_dims(DIMS, out_dims, in_dims);
unsigned int j = 0;
for (unsigned int i = 0; i < DIMS; i++)
if (MD_IS_SET(flags, i))
out_dims[i] = atoi(argv[j++ + 2]);
assert(j == n);
assert(md_calc_size(DIMS, in_dims) == md_calc_size(DIMS, out_dims));
md_calc_strides(DIMS, out_strs, out_dims, CFL_SIZE);
for (unsigned int i = 0; i < DIMS; i++)
if (!(MD_IS_SET(flags, i) || (in_strs[i] == out_strs[i])))
error("Dimensions are not consistent at index %d.\n");
complex float* out_data = create_cfl(argv[n + 3], DIMS, out_dims);
md_copy(DIMS, in_dims, out_data, in_data, CFL_SIZE);
unmap_cfl(DIMS, in_dims, in_data);
unmap_cfl(DIMS, out_dims, out_data);
exit(0);
}
char *CommandLine :: GetMLCommand (char *prompt )
{
static NString nstring(4000);
nstring = "";
CommandLine cmdline(file_handle,echo,top_cmdline);
while ( cmdline.InputCommand(prompt) )
{
if ( cmdline.GetCommandType(this) == CLT_end )
break;
nstring += command;
nstring += ' ';
}
return(nstring);
}
int main_copy(int argc, char* argv[])
{
const struct opt_s opts[] = { };
cmdline(&argc, argv, 4, 1000, usage_str, help_str, ARRAY_SIZE(opts), opts);
num_init();
unsigned int N = DIMS;
int count = argc - 3;
assert((count > 0) && (count % 2 == 0));
long in_dims[N];
long out_dims[N];
void* in_data = load_cfl(argv[argc - 2], N, in_dims);
void* out_data = load_cfl(argv[argc - 1], N, out_dims);
// reload
unmap_cfl(N, out_dims, out_data);
out_data = create_cfl(argv[argc - 1], N, out_dims);
long position[N];
for (unsigned int i = 0; i < N; i++)
position[i] = 0;
for (int i = 0; i < count; i += 2) {
unsigned int dim = atoi(argv[i + 1]);
long pos = atol(argv[i + 2]);
assert(dim < N);
assert((0 <= pos) && (pos < out_dims[dim]));
position[dim] = pos;
}
md_copy_block(N, position, out_dims, out_data, in_dims, in_data, CFL_SIZE);
unmap_cfl(N, in_dims, in_data);
unmap_cfl(N, out_dims, out_data);
exit(0);
}
unsigned beanstalk::watch(const char* tube)
{
// 先检查是否已经监控相同队列
std::vector<char*>::iterator it = tubes_watched_.begin();
for (; it != tubes_watched_.end(); ++it)
{
if (strcmp(*it, tube) == 0)
break;
}
string cmdline(128);
cmdline.format("watch %s\r\n", tube);
ACL_ARGV* tokens = beanstalk_request(cmdline);
if (tokens == NULL)
{
logger_error("'%s' error", cmdline.c_str());
return 0;
}
if (tokens->argc < 2 || strcasecmp(tokens->argv[0], "WATCHING"))
{
logger_error("'%s' error %s", cmdline.c_str(), tokens->argv[0]);
errbuf_ = tokens->argv[0];
acl_argv_free(tokens);
close();
return 0;
}
unsigned n = (unsigned) atoi(tokens->argv[1]);
acl_argv_free(tokens);
// 如果服务器返回所关注的队列数为 0，肯定是出错了，因为至少还有一个
// 缺省队列：default，所以此时需要关闭连接，以尽量消除与本连接相关
// 的错误，下一个命令会自动进行重连操作以恢复操作过程
if (n == 0)
{
logger_error("'%s' error, tube watched is 0", cmdline.c_str());
errbuf_ = "watching";
close();
}
// 添加进监控集合中
else if (it == tubes_watched_.end())
tubes_watched_.push_back(acl_mystrdup(tube));
return n;
}
int main(int argc, char *argv[])
{
struct opts_val val = {0};
struct sar_file *f = NULL;
opt_value = &val;
atexit(clean_exit);
cmdline(argc, argv, &val);
switch(val.mode) {
case(MD_NONE):
break;
case(MD_INFORMATION):
f = sar_read(val.file, val.compress, val.verbose);
sar_info(f);
break;
case(MD_CREATE):
f = sar_creat(val.file,
val.compress,
!val.no_crc,
!val.no_nano,
val.verbose);
if(val.tmp_cwd)
xchdir(val.tmp_cwd);
sar_add(f, val.source);
break;
case(MD_EXTRACT):
f = sar_read(val.file, val.compress, val.verbose);
if(val.tmp_cwd)
xchdir(val.tmp_cwd);
sar_extract(f);
break;
case(MD_LIST):
f = sar_read(val.file, val.compress, val.verbose);
if(val.tmp_cwd)
xchdir(val.tmp_cwd);
sar_list(f);
break;
}
if(val.mode != MD_NONE)
sar_close(f);
exit(EXIT_SUCCESS);
}
void
opengffile ( void )
{
gffile = kpseopenfile ( cmdline ( optind ) , kpsegfformat ) ;
curloc = 0 ;
Fputs ( stdout , "Options selected: Mnemonic output = " ) ;
if ( wantsmnemonics )
Fputs ( stdout , "true" ) ;
else
Fputs ( stdout , "false" ) ;
Fputs ( stdout , "; pixel output = " ) ;
if ( wantspixels )
Fputs ( stdout , "true" ) ;
else
Fputs ( stdout , "false" ) ;
{ putc ( '.' , stdout ); putc ( '\n', stdout ); }
}
int main_resize(int argc, char* argv[])
{
bool center = false;
const struct opt_s opts[] = {
OPT_SET('c', ¢er, "center"),
};
cmdline(&argc, argv, 4, 1000, usage_str, help_str, ARRAY_SIZE(opts), opts);
num_init();
unsigned int N = DIMS;
int count = argc - 3;
assert((count > 0) && (count % 2 == 0));
long in_dims[N];
long out_dims[N];
void* in_data = load_cfl(argv[argc - 2], N, in_dims);
md_copy_dims(N, out_dims, in_dims);
for (int i = 0; i < count; i += 2) {
unsigned int dim = atoi(argv[i + 1]);
unsigned int size = atoi(argv[i + 2]);
assert(dim < N);
assert(size >= 1);
out_dims[dim] = size;
}
void* out_data = create_cfl(argv[argc - 1], N, out_dims);
(center ? md_resize_center : md_resize)(N, out_dims, out_data, in_dims, in_data, CFL_SIZE);
unmap_cfl(N, in_dims, in_data);
unmap_cfl(N, out_dims, out_data);
return 0;
}
TEST(CommandLineTest, GetOrSetProgram)
{
kbase::Path path(L"C:\\windows\\system32\\calc.exe");
kbase::CommandLine cmdline(path);
EXPECT_EQ(cmdline.GetProgram().value(), path.value());
kbase::Path path_with_space(L" C:\\windows\\system32\\calc.exe ");
cmdline.SetProgram(path_with_space);
EXPECT_EQ(cmdline.GetProgram(), path);
kbase::Path path_with_tabs(L"\tC:\\windows\\system32\\calc.exe\t\t");
cmdline.SetProgram(path_with_tabs);
EXPECT_EQ(cmdline.GetProgram(), path);
kbase::Path path_with_hybrid(L" \tC:\\windows\\system32\\calc.exe \t ");
cmdline.SetProgram(path_with_hybrid);
EXPECT_EQ(cmdline.GetProgram(), path);
}
bool beanstalk::list_tubes_fmt(string& buf, const char* fmt, ...)
{
buf.clear(); // 虽然读操作过程也会清空缓存
string cmdline(128);
va_list ap;
va_start(ap, fmt);
cmdline.vformat(fmt, ap);
va_end(ap);
ACL_ARGV* tokens = beanstalk_request(cmdline);
if (tokens == NULL)
{
logger_error("'%s' error", cmdline.c_str());
return false;
}
if (tokens->argc < 2 || strcasecmp(tokens->argv[0], "OK"))
{
errbuf_ = tokens->argv[0];
acl_argv_free(tokens);
close();
return false;
}
unsigned short n = (unsigned short) atoi(tokens->argv[1]);
acl_argv_free(tokens);
if (n == 0)
{
logger_error("list data's length 0");
errbuf_ = "length";
close();
return false;
}
// 读取规定的字节数
if (conn_.read(buf, n, true) == false)
{
logger_error("peek read body failed");
errbuf_ = "read";
close();
return false;
}
return true;
}
int
main(int argc, char **argv)
{
pid_t pid;
ulog_open(ULOG_KMSG, LOG_DAEMON, "init");
sigaction(SIGTERM, &sa_shutdown, NULL);
sigaction(SIGUSR1, &sa_shutdown, NULL);
sigaction(SIGUSR2, &sa_shutdown, NULL);
early();
cmdline();
watchdog_init(1);
pid = fork();
if (!pid) {
char *kmod[] = { "/sbin/kmodloader", "/etc/modules-boot.d/", NULL };
if (debug < 3)
patch_stdio("/dev/null");
execvp(kmod[0], kmod);
ERROR("Failed to start kmodloader\n");
exit(-1);
}
if (pid <= 0) {
ERROR("Failed to start kmodloader instance\n");
} else {
int i;
for (i = 0; i < 1200; i++) {
if (waitpid(pid, NULL, WNOHANG) > 0)
break;
usleep(10 * 1000);
watchdog_ping();
}
}
uloop_init();
preinit();
uloop_run();
return 0;
}
int main(int argc, char **argv)
{
new QCoreApplication(argc, argv);
// the 'torc-' prefix is used for identification purposes elsewhere, don't change it
QCoreApplication::setApplicationName("torc-utils");
QThread::currentThread()->setObjectName(TORC_MAIN_THREAD);
int ret = GENERIC_EXIT_OK;
{
QScopedPointer<TorcCommandLine> cmdline(new TorcCommandLine(TorcCommandLine::URI | TorcCommandLine::LogFile));
if (!cmdline.data())
return GENERIC_EXIT_NOT_OK;
cmdline->Add("probe", QVariant(), "Probe the given URI for media content (audio, video and still images).", TorcCommandLine::None);
cmdline->Add("play", QVariant(), "Play the given URI.", TorcCommandLine::None);
bool justexit = false;
ret = cmdline->Evaluate(argc, argv, justexit);
if (ret != GENERIC_EXIT_OK)
return ret;
if (justexit)
return ret;
if (int error = TorcLocalContext::Create(cmdline.data(), Torc::Network))
return error;
QString uri = cmdline->GetValue("f").toString();
if (!uri.isEmpty())
{
if (cmdline.data()->GetValue("probe").isValid())
ret = TorcUtils::Probe(uri);
else if (cmdline.data()->GetValue("play").isValid())
ret = TorcUtils::Play(uri);
}
}
TorcLocalContext::TearDown();
return ret;
}
TEST(LoadingAddon, TestAdon)
{
char* argv[4] = { "test.exe", "--config=./tests/configs", "--log-file=/path/to/log/server.log", "--daemon" };
OpcUa::UaServer::CommandLine cmdline(4, argv);
EXPECT_EQ(cmdline.GetLogFile(), "/path/to/log/server.log");
EXPECT_TRUE(cmdline.IsDaemonMode());
OpcUa::Application::UniquePtr server = OpcUa::CreateApplication();
ASSERT_NO_THROW(server->Start(cmdline.GetModules()));
ASSERT_NO_THROW(server->GetAddonsManager());
OpcUa::Test::TestAddon::SharedPtr testAddon;
ASSERT_NO_THROW(testAddon = server->GetAddonsManager().GetAddon<OpcUa::Test::TestAddon>(OpcUa::Test::TestAddonID));
ASSERT_NE(testAddon, OpcUa::Test::TestAddon::SharedPtr());
const Common::AddonParameters params = testAddon->GetParameters();
ASSERT_EQ(params.Parameters.size(), 1);
ASSERT_EQ(params.Parameters[0].Name, "hello");
ASSERT_EQ(params.Parameters[0].Value, "world");
}
int main(int argc, char* argv[])
{
bool help;
cCmdline cmdline (argc, argv);
cmdline.addOption ('h', "help", "Display this text", &help, true);
int index = 0;
if (!cmdline.parse (&index))
{
fprintf (stderr, "try %s -h\n", argv[0]);
return -1;
}
cPcapNetIf obj;
obj.printInterfaces ();
return 0;
}
int main(int argc, char *argv[])
{
CommandLine cmdline(argc, argv);
std::cout << "Gen tool - Copyright 2014 - Jeroen Broekhuizen" << std::endl;
if ( cmdline.size() == 0 )
{
// print help information
std::cout << "Invalid arguments.";
}
else
{
const CommandLineArgument& argument = cmdline[0];
ASSERT(argument.getType() == CommandLineArgument::eCommand);
Generator* pgenerator = NULL;
if ( argument.getName() == UTEXT("project") )
{
pgenerator = new ProjectGenerator();
}
else if ( argument.getName() == UTEXT("mod") )
{
pgenerator = new ModuleGenerator();
}
else if ( argument.getName() == UTEXT("class") )
{
pgenerator = new ClassGenerator();
}
else
{
std::cerr << argument.getName().toUtf8() << " is not a valid target.";
return -1;
}
if ( !pgenerator->generate(cmdline) )
{
return -2;
}
}
return 0;
}
int Main(void)
{
char *cmd[8];
int cmdcnt;
char buff[32];
init();
start();
puts(help[0]);
init_taglist(0x40000000);
while(1)
{
puts("IMX233# ");
cmdcnt = cmdline(cmd);
if (cmdcnt == 1 && strcmp(cmd[0], "h") == 0)
{
int i;
for (i = 0; i < 3; i++)
{
puts("\r\n");
puts(help[i]);
}
}
if (cmdcnt == 2 && strcmp(cmd[0], "get") == 0)
{
cmd_get(cmd[1]);
}
if (cmdcnt == 2 && strcmp(cmd[0], "go") == 0)
{
cmd_go(cmd[1]);
}
if (cmdcnt == 1 && strcmp(cmd[0], "ddr") == 0)
{
ddrtest();
}
putchr('\n');
putchr('\r');
}
return 0;
}
std::vector<u8string> getargv() {
#if defined(_WIN32)
int argc;
wchar_t **wargv = CommandLineToArgvW(GetCommandLineW(), &argc);
std::vector<u8string> result;
result.reserve(argc);
for(int i = 0; i < argc; ++i)
result.push_back(u8string::from_wide(wargv[i]));
LocalFree(static_cast<void *>(wargv));
return result;
#elif defined(__APPLE__) && defined(__MACH__)
int argc = *_NSGetArgc();
char **argv = *_NSGetArgv();
std::vector<u8string> result;
result.reserve(argc);
for(int i = 0; i < argc; ++i)
result.push_back(u8string(argv[i]));
return result;
#else
std::ifstream cmdline("/proc/self/cmdline");
if(cmdline.is_open()) {
std::vector<u8string> result;
for(;;) {
u8string argi;
for(;;) {
char c;
if(cmdline.get(c))
if(c != '\0')
argi.push_back(c);
else
break;
else if(cmdline.eof() && argi.empty())
return result;
else
throw std::runtime_error("Unable to get commandline arguments");
}
result.push_back(std::move(argi));
}
} else
throw std::runtime_error("Unable to get commandline arguments");
#endif
}
int main(int argc, char** argv)
{
int r = cmdline(argc, argv);
if(r != -1) {
return r;
}
if(freq < 0) {
fprintf(stderr, "please specify frequency with -f\n");
return 1;
}
VESNA::SpectrumSensor ss(device);
boost::shared_ptr<VESNA::ConfigList> cl = ss.get_config_list();
int config_id;
VESNA::DeviceConfig* c;
for(config_id = 0; config_id < cl->get_config_num(); config_id++) {
c = cl->get_config(0, config_id);
if(c->bw == samp_rate/2 && c->covers(freq, freq)) {
break;
}
}
if(config_id >= cl->get_config_num()) {
fprintf(stderr, "unsupported configuration (samp_rate=%d freq=%lld)\n",
samp_rate, freq);
return 1;
}
int nsamples_run = nsamples;
if(nsamples_run > max_nsamples_run || nsamples < 1) {
nsamples_run = max_nsamples_run;
}
out = fopen(outp, "wb");
boost::shared_ptr<VESNA::SweepConfig> sc = c->get_sample_config(freq, nsamples_run);
ss.sample_run(sc, cb);
}
int main_walsh(int argc, char* argv[])
{
long bsize[3] = { 20, 20, 20 };
long calsize[3] = { 24, 24, 24 };
const struct opt_s opts[] = {
{ 'r', true, opt_vec3, &calsize, " cal_size\tLimits the size of the calibration region." },
{ 'R', true, opt_vec3, &calsize, NULL },
{ 'b', true, opt_vec3, &bsize, " block_size\tBlock size." },
{ 'B', true, opt_vec3, &bsize, NULL },
};
cmdline(&argc, argv, 2, 2, usage_str, help_str, ARRAY_SIZE(opts), opts);
long dims[DIMS];
complex float* in_data = load_cfl(argv[1], DIMS, dims);
assert((dims[0] == 1) || (calsize[0] < dims[0]));
assert((dims[1] == 1) || (calsize[1] < dims[1]));
assert((dims[2] == 1) || (calsize[2] < dims[2]));
assert(1 == dims[MAPS_DIM]);
long caldims[DIMS];
complex float* cal_data = extract_calib(caldims, calsize, dims, in_data, false);
unmap_cfl(DIMS, dims, in_data);
debug_printf(DP_INFO, "Calibration region %ldx%ldx%ld\n", caldims[0], caldims[1], caldims[2]);
dims[COIL_DIM] = dims[COIL_DIM] * (dims[COIL_DIM] + 1) / 2;
complex float* out_data = create_cfl(argv[2], DIMS, dims);
walsh(bsize, dims, out_data, caldims, cal_data);
debug_printf(DP_INFO, "Done.\n");
md_free(cal_data);
unmap_cfl(DIMS, dims, out_data);
exit(0);
}
bool CommandMergeChanges::setup(const std::vector<std::string>& arguments) {
po::options_description cmdline("Available options");
cmdline.add_options()
("simplify,s", "Simplify change")
;
add_common_options(cmdline);
add_multiple_inputs_options(cmdline);
add_output_options(cmdline);
po::options_description hidden("Hidden options");
hidden.add_options()
("input-filenames", po::value<std::vector<std::string>>(), "Input files")
;
po::options_description desc("Allowed options");
desc.add(cmdline).add(hidden);
po::positional_options_description positional;
positional.add("input-filenames", -1);
po::variables_map vm;
po::store(po::command_line_parser(arguments).options(desc).positional(positional).run(), vm);
po::notify(vm);
if (vm.count("help")) {
std::cout << "Usage: osmium merge-changes [OPTIONS] OSM-CHANGE-FILE...\n\n";
std::cout << cmdline << "\n";
exit(0);
}
setup_common(vm);
setup_input_files(vm);
setup_output_file(vm);
if (vm.count("simplify")) {
m_simplify_change = true;
}
return true;
}
int main(int argc,char**argv)
{
try
{
sg::CommandLineParser cmdline(argc, argv);
cmdline.addIntOption("routing.port,p", "routing on specified port");
cmdline.addStringOption("config_server.address", "config server address");
group_messaging_server::GroupMessagingService gms(cmdline);
gms.start();
}
catch (exception& e)
{
LOG(error, EXCEPTION_DIAG_INFO(e));
}
LOG(info, "exit.");
return 0;
}
bool beanstalk::touch(unsigned long long id)
{
string cmdline(128);
cmdline.format("touch %llu\r\n", id);
ACL_ARGV* tokens = beanstalk_request(cmdline);
if (tokens == NULL)
{
logger_error("'%s' error", cmdline.c_str());
return false;
}
if (strcasecmp(tokens->argv[0], "TOUCHED"))
{
logger_error("'%s' error %s", cmdline.c_str(), tokens->argv[0]);
errbuf_ = tokens->argv[0];
acl_argv_free(tokens);
return false;
}
acl_argv_free(tokens);
return true;
}
bool beanstalk::pause_tube(const char* tube, unsigned delay)
{
string cmdline(128);
cmdline.format("pause-tube %s %u\r\n", tube, delay);
ACL_ARGV* tokens = beanstalk_request(cmdline);
if (tokens == NULL)
{
logger_error("'%s' error", cmdline.c_str());
return false;
}
if (strcasecmp(tokens->argv[0], "PAUSED"))
{
logger_error("'%s' error %s", cmdline.c_str(), tokens->argv[0]);
errbuf_ = tokens->argv[0];
acl_argv_free(tokens);
return false;
}
acl_argv_free(tokens);
return true;
}
int main(int argc, char* argv[])
{
//initialize program
std::vector<std::string> cfg;
cfg.push_back("hpx.os_threads=" +
boost::lexical_cast<std::string>(hpx::threads::hardware_concurrency()));
boost::program_options::options_description cmdline(
"usage: " HPX_APPLICATION_STRING " [options]");
cmdline.add_options()
( "vector_size"
, boost::program_options::value<std::size_t>()->default_value(10)
, "size of vector")
("chunk_size"
, boost::program_options::value<int>()->default_value(0)
, "number of iterations to combine while parallelization")
;
return hpx::init(cmdline, argc, argv, cfg);
}
bool beanstalk::bury(unsigned long long id, unsigned int pri /* = 1024 */)
{
string cmdline(128);
cmdline.format("bury %llu %u\r\n", id, pri);
ACL_ARGV* tokens = beanstalk_request(cmdline);
if (tokens == NULL)
{
logger_error("'%s' error", cmdline.c_str());
return false;
}
if (strcasecmp(tokens->argv[0], "BURIED"))
{
logger_error("'%s' error %s", cmdline.c_str(), tokens->argv[0]);
errbuf_ = tokens->argv[0];
acl_argv_free(tokens);
return false;
}
acl_argv_free(tokens);
return true;
}
static void
cmdkey(Win *w, Rune r)
{
switch(r){
case Kview:
cmdscroll(w, 3);
return;
case Kup:
cmdscroll(w, -3);
return;
case Kleft:
if(w->fr.p0 == 0)
return;
setsel(w, w->fr.p0 - 1, w->fr.p0 - 1);
return;
case Kright:
if(w->toprune + w->fr.p1 == w->nrunes)
return;
setsel(w, w->fr.p1 + 1, w->fr.p1 + 1);
return;
}
if(w->fr.p0 < w->fr.p1)
cmddel(w, w->toprune + w->fr.p0, w->toprune + w->fr.p1);
switch(r){
case 0x00:
case Kesc:
break;
case '\b':
if(w->fr.p0 > 0 && w->toprune + w->fr.p0 != w->opoint)
cmddel(w, w->toprune + w->fr.p0 - 1, w->toprune + w->fr.p0);
break;
case '\n':
cmdinsert(w, &r, 1, w->fr.p0 + w->toprune);
if(w->toprune + w->fr.p0 == w->nrunes)
cmdline(w);
break;
default:
cmdinsert(w, &r, 1, w->fr.p0 + w->toprune);
}
}
