/*
* === FUNCTION ======================================================================
* Name: parse_input
* Description: separates a line of input into tokens. Passes tokens off for additional
* processing.
* =====================================================================================
*/
void
parse_input (char *input, size_t size)
{
char s[(int)size];
strcpy(s, input);
char *op_code = strtok(s, " ");
char *raw_arg_a = strtok(NULL, " ");
char *raw_arg_b = strtok(NULL, " ");
char *raw_arg_c = strtok(NULL, " ");
int argc = 0;
struct arg_t args[3];
if(raw_arg_a != 0) {
args[0] = parse_arg(raw_arg_a);
argc++;
}
if(raw_arg_b != 0) {
args[1] = parse_arg(raw_arg_b);
argc++;
}
if(raw_arg_c != 0) {
args[2] = parse_arg(raw_arg_b);
argc++;
}
op_code = trim_whitespace(op_code);
str_to_lower(op_code);
unsigned long op_hashed = hash(op_code);
assemble_op(op_hashed, args, argc);
} /* ----- end of function parse_input ----- */
static void parse_config(void)
{
int i;
json_t *val;
if (!json_is_object(opt_config))
return;
for (i = 0; i < ARRAY_SIZE(options); i++) {
if (!options[i].name)
break;
if (!strcmp(options[i].name, "config"))
continue;
val = json_object_get(opt_config, options[i].name);
if (!val)
continue;
if (options[i].has_arg && json_is_string(val)) {
char *s = strdup(json_string_value(val));
if (!s)
break;
parse_arg(options[i].val, s);
free(s);
} else if (!options[i].has_arg && json_is_true(val))
parse_arg(options[i].val, "");
else
fprintf(stderr, "JSON option %s invalid\n",
options[i].name);
}
}
int
oly_parse(struct command *c, char *s)
{
c->a = 0;
c->b = 0;
c->c = 0;
c->d = 0;
c->e = 0;
c->f = 0;
c->g = 0;
c->h = 0;
if (!oly_parse_cmd(c, s))
return FALSE;
switch (min(ilist_len(c->parse), 9))
{
case 9: c->h = parse_arg(c->who, c->parse[8]);
case 8: c->g = parse_arg(c->who, c->parse[7]);
case 7: c->f = parse_arg(c->who, c->parse[6]);
case 6: c->e = parse_arg(c->who, c->parse[5]);
case 5: c->d = parse_arg(c->who, c->parse[4]);
case 4: c->c = parse_arg(c->who, c->parse[3]);
case 3: c->b = parse_arg(c->who, c->parse[2]);
case 2: c->a = parse_arg(c->who, c->parse[1]);
}
return TRUE;
}
static int do_failed(char *arg)
{
char *msg = NULL;
int msec = parse_arg(arg, &msg);
return wdog_failed(cause, pid, msg, msec);
}
int trans_inst(const char* name, int argc, char* const* argv, int* bin_ptr) {
int _instno = 0;
int _argi = 0;
int _parg = 0;
for (; _instno != INST_COUNT; ++_instno) {
if (!util_stricmp(name, __inst[_instno].name)) {
break;
}
}
if (_instno == INST_COUNT) {
fprintf(stderr, "no match function [%s] found.\n", name);
return FAILURE;
}
if (argc > 0 && argc != strlen(__inst[_instno].argument)) {
fputs("argument count not matched.\n", stderr);
return FAILURE;
}
*(bin_ptr++) = _instno;
for (; _argi != argc; ++_argi) {
_parg = parse_arg(__inst[_instno].argument[_argi],
argv[_argi], bin_ptr);
if (_parg == FAILURE) {
fputs("argument parse error.\n", stderr);
return FAILURE;
}
bin_ptr += typechr_len(__inst[_instno].argument[_argi]);
}
return (arg_len(_instno) + 1);
}
int main(int argc, const char** argv)
{
const char* input_path = 0;
output_list outputs;
Mode mode = textureMode;
InputFileType inputType;
size_t optimize = 1;
bool bench = false;
bool verbose = false;
int result;
parse_arg(argc, argv, input_path, outputs, optimize, bench, verbose, mode, inputType);
if (input_path == 0 || outputs.size() == 0)
{
mode = helpMode;
}
if (mode == helpMode)
{
help();
result = 1;
}
else
{
process_image(input_path, outputs, optimize, bench, verbose, mode, inputType);
result = 0;
}
return result;
}
int main(int argc,
char **argv)
{
SOCKET listen_sock;
struct sockaddr_un addr;
union conv_sockaddr u_sock_addr;
int len, nb_str;
char **print_me;
listen_sock = create_socket();
strcpy(addr.sun_path, get_path());
addr.sun_family = AF_LOCAL;
u_sock_addr.un = &addr;
if (connect(listen_sock, u_sock_addr.ad, sizeof(addr)) == -1)
{
printf("Client not connected.\n");
return (-1);
}
if ((nb_str =parse_arg(argc, argv, &print_me)) == 0)
return (close_server(listen_sock));
for (; nb_str > 0; nb_str--)
{
len = strlen(print_me[nb_str - 1]);
write(listen_sock, &len, sizeof(len));
write(listen_sock, print_me[nb_str - 1], len);
}
close(listen_sock);
free(print_me);
return (0);
}
static int do_reset(char *arg)
{
char *msg = NULL;
int msec = parse_arg(arg, &msg);
return wdog_reset_timeout(pid, msg, msec);
}
bool add_entry(char *lbuf, int length, struct dict_entry_t *entry)
{
char *cp;
if (length == 0)
return false;
/* allocate line buffer */
entry->lbuf = (char *) ecalloc(1, length + 1);
strncpy(entry->lbuf, lbuf, length);
/* format: keyword TAB candidate1 TAB candidate2 TAB candidate3... TAB */
if ((cp = strchr(entry->lbuf, '\t')) == NULL)
goto error;
*cp = '\0';
entry->keyword = entry->lbuf;
parse_reset(&entry->candidate);
parse_arg(cp + 1, &entry->candidate, '\t', not_tab);
/* illegal entry */
if (entry->candidate.argc <= 0)
goto error;
return true;
error:
free(entry->lbuf);
return false;
}
int getopt(int argc, char *const argv[], const char *optstring) {
if (!optinited) {
parse_arg(optstring);
optinited = true;
}
optarg = nullptr;
if (optind >= argc) {
return -1;
}
else if (argv[optind][0] != '-' || argv[optind][1] == '\0') {
// begin with no dash or dash alone
return -1;
}
char optname = argv[optind][1];
if (optnames[optname] == 0) {
return -1;
return '?';
}
if (optnames[optname] == 2) {
// an argument
if (++optind >= argc) {
return -1;
}
optarg = argv[optind];
}
else {
++optind;
}
return optname;
}
static cell AMX_NATIVE_CALL parse(AMX *amx, cell *params) /* 3 param */
{
int inum = *params / sizeof(cell), iarg = 2, c;
char* arg, *parse = get_amxstring(amx, params[1], 0, c);
cell *cptr;
int state;
while (*parse)
{
arg = parse_arg(&parse,state);
if (state)
{
if (inum <= iarg)
return ((iarg - 2)>>1);
cptr = get_amxaddr(amx, params[iarg++]);
c = *get_amxaddr(amx, params[iarg++]);
while (c-- && *arg)
*cptr++ = (cell)*arg++;
*cptr = 0;
}
}
return ((iarg - 2)>>1);
}
static int parse_line(struct binrpc_cmd* cmd, char* line)
{
char* p;
int count;
cmd->method=strtok(line, " \t");
if (cmd->method==0)
goto error_no_method;
count=0;
for(p=strtok(0, " \t"); p; p=strtok(0, " \t")){
if (count>=MAX_BINRPC_ARGS)
goto error_too_many;
if (parse_arg(&cmd->argv[count], p)<0){
goto error_arg;
}
count++;
}
cmd->argc=count;
return 0;
error_no_method:
printf( "ERROR: no method name\n");
return -1;
error_too_many:
printf("ERROR: too many arguments (%d), no more than %d allowed\n",
count, MAX_BINRPC_ARGS);
return -1;
error_arg:
printf("ERROR: bad argument %d: %s\n", count+1, p);
return -1;
}
void read_args(int argc, const char** argv,
GD<COMP_T, SUPV_T, DAT_DIM_T, N_DAT_T>::GDParam& gd_param,
SGD<COMP_T, SUPV_T, DAT_DIM_T, N_DAT_T>::SGDParam& sgd_param,
MySolver::MyParam& my_param,
char* data_file) {
int i;
for (i = 1; i < argc && argv[i][0] == '-'; ++i) {
switch (parse_arg(argv[i])) {
case 0 : print_help(); exit(0);
case 1 : ++i; gd_param.verbosity(argv[i][0] - '0');
case 2 : ++i; my_param.regul_coef(std::atof(argv[i]));
case 3 : ++i; my_param.regul_coef(std::atof(argv[i])); break;
case 5 : ++i; sgd_param.num_of_epoches(std::atoi(argv[i]));
case 6 : ++i; sgd_param.num_of_epoches(std::atoi(argv[i])); break;
case 11 : ++i; gd_param.init_learning_rate(std::atof(argv[i]));
case 12 : ++i; gd_param.init_learning_rate(std::atof(argv[i])); break;
case 14 : ++i; gd_param.learning_rate_1st_try(std::atof(argv[i]));
case 15 : ++i; gd_param.learning_rate_1st_try(std::atof(argv[i])); break;
case 17 : ++i; gd_param.learning_rate_try_factor(std::atof(argv[i]));
case 18 : ++i; gd_param.learning_rate_try_factor(std::atof(argv[i])); break;
default:
std::cerr << "Unrecognized option " << argv[i] << "! Please type \"labeltree_train -h\" for help.\n";
exit(1);
}
}
if (i >= argc) {
std::cerr << "Not enough input parameters! Please type \"main -h\" for help.\n";
exit(1);
}
std::strcpy(data_file, argv[i]);
}
int
main(int argc, char *argv[])
{
int ii;
int ret = 0;
if (argc < 2) {
fprintf(stderr, "arguments plox\n");
exit(1);
}
g_hdl = pcidb_open(PCIDB_VERSION);
if (g_hdl == NULL)
fatal("failed to open pci database: %s\n", strerror(errno));
for (ii = 1; ii < argc; ii++) {
g_case = L_INVALID;
parse_arg(argv[ii]);
print_arg();
}
pcidb_close(g_hdl);
return (ret);
}
int main(int argc, char **argv)
{
int n;
OPTION opt;
#if defined(WIN32)
_CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_WARN, _CRTDBG_FILE_STDOUT );
_CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_ERROR, _CRTDBG_FILE_STDOUT );
_CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_ASSERT, _CRTDBG_FILE_STDOUT );
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF|_CRTDBG_DELAY_FREE_MEM_DF|_CRTDBG_CHECK_ALWAYS_DF|_CRTDBG_LEAK_CHECK_DF);
#endif
n = parse_arg(&opt, argc, argv);
if(n+2 > argc){
show_usage();
exit(EXIT_FAILURE);
}
for(;n<=(argc-2);n+=2){
test_arib_std_b25(argv[n+0], argv[n+1], &opt);
}
#if defined(WIN32)
_CrtDumpMemoryLeaks();
#endif
return EXIT_SUCCESS;
}
void
cmd_shift(struct command *c)
{
if (ilist_len(c->parse) > 1) {
/*
* Deleted argument need not be freed, since it's just a
* pointer into another string. It was never allocated
* itself.
*/
ilist_delete((ilist *) & c->parse, 1);
}
c->a = c->b;
c->b = c->c;
c->c = c->d;
c->d = c->e;
c->e = c->f;
c->f = c->g;
c->g = c->h;
if (numargs(c) >= 8)
c->h = parse_arg(c->who, c->parse[8]);
else
c->h = 0;
}
int
run_main (int argc, ACE_TCHAR *argv[])
{
ACE_START_TEST (ACE_TEXT ("Thread_Pool_Reactor_Test"));
parse_arg (argc, argv);
// Changed the default
ACE_TP_Reactor sr;
ACE_Reactor new_reactor (&sr);
ACE_Reactor::instance (&new_reactor);
ACCEPTOR acceptor;
ACE_INET_Addr accept_addr (rendezvous);
if (acceptor.open (accept_addr) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("open")),
1);
ACE_DEBUG((LM_DEBUG,
ACE_TEXT ("(%t) Spawning %d server threads...\n"),
svr_thrno));
ACE_Thread_Manager::instance ()->spawn_n (svr_thrno,
svr_worker);
ACE_Thread_Manager::instance ()->spawn (worker);
ACE_Thread_Manager::instance ()->wait ();
ACE_END_TEST;
return 0;
}
//read config file, and start to listen
void csiebox_server_init(/*{{{*/
csiebox_server** server, int argc, char** argv) {
csiebox_server* tmp = (csiebox_server*)malloc(sizeof(csiebox_server));
if (!tmp) {
fprintf(stderr, "server malloc fail\n");
return;
}
memset(tmp, 0, sizeof(csiebox_server));
if (!parse_arg(tmp, argc, argv)) {
fprintf(stderr, "Usage: %s [config file]\n", argv[0]);
free(tmp);
return;
}
int fd = server_start();
if (fd < 0) {
fprintf(stderr, "server fail\n");
free(tmp);
return;
}
tmp->client = (csiebox_client_info**)
malloc(sizeof(csiebox_client_info*) * getdtablesize());
if (!tmp->client) {
fprintf(stderr, "client list malloc fail\n");
close(fd);
free(tmp);
return;
}
memset(tmp->client, 0, sizeof(csiebox_client_info*) * getdtablesize());
tmp->listen_fd = fd;
*server = tmp;
}
int
parse_arg_list(unsigned char *buf, int len, userfw_arg *dst, int count, uint8_t const *types)
{
struct userfw_io_header *arg = (struct userfw_io_header *)buf;
int err = 0, i;
for(i = 0; i < count; i++)
{
if (len < sizeof(*arg))
return EINVAL;
if (arg->subtype == ST_ARG)
{
if (arg->type != types[i] || arg->length > len)
return EINVAL;
if ((err = parse_arg((unsigned char *)arg, &(dst[i]))) != 0 )
return err;
}
else
i--;
len -= arg->length;
arg = (struct userfw_io_header *)(((unsigned char *)arg) + arg->length);
}
if (i != count)
return EINVAL;
return 0;
}
static t_syntax_error *parse_args(t_instr *instr,
t_token_list **list_pointer,
const t_token *prev)
{
int i;
t_syntax_error *error;
t_token *comma;
i = -1;
while (++i < instr->info->argument_count)
{
if (i)
{
comma = try_to_read_token(list_pointer, TOKEN_TYPE_COMMA);
if (!comma)
{
free_args(instr, i);
return (syntax_error_new(&prev->position, "Expected comma"));
}
}
error = parse_arg(instr->arguments + i, list_pointer, prev,
instr->info->argument_types[i]);
if (error)
{
free_args(instr, i);
return (error);
}
}
return (NULL);
}
static void nativeNew(JNIEnv *env, jobject thiz, jstring cmdline)
{
const char *str;
str = env->GetStringUTFChars(cmdline, NULL);
if (!str) {
throw_IllegalArgumentException(env, "cmdline invalid");
return;
}
if (parse_arg(str) < 0) {
E("parse_arg failed");
goto out;
}
gfq.weak_thiz = env->NewWeakGlobalRef(thiz);
if (!gfq.weak_thiz) {
E("Create weak-reference for libfqrtmp instance failed");
goto out;
}
libfqrtmp_event_send(OPENING, 0, jnu_new_string(""));
gfq.rtmp_hdlr = new RtmpHandler;
if (gfq.rtmp_hdlr->connect(liveurl) < 0) {
libfqrtmp_event_send(ENCOUNTERED_ERROR,
-1001, jnu_new_string("rtmp_connect failed"));
goto out;
}
libfqrtmp_event_send(CONNECTED, 0, jnu_new_string(""));
out:
env->ReleaseStringUTFChars(cmdline, str);
}
bool Parser::parse_call_details(Call *call, Mode mode) {
do {
int c = read_byte();
switch (c) {
case trace::CALL_END:
#if TRACE_VERBOSE
std::cerr << "\tCALL_END\n";
#endif
return true;
case trace::CALL_ARG:
#if TRACE_VERBOSE
std::cerr << "\tCALL_ARG\n";
#endif
parse_arg(call, mode);
break;
case trace::CALL_RET:
#if TRACE_VERBOSE
std::cerr << "\tCALL_RET\n";
#endif
call->ret = parse_value(mode);
break;
default:
std::cerr << "error: ("<<call->name()<< ") unknown call detail "
<< c << "\n";
exit(1);
case -1:
return false;
}
} while(true);
}
int main(int argc, char *argv[])
{
FILE *forigin;
char mbr[SECTOR];
int i;
for(i=1; i < argc ; i++) {
args |= parse_arg(argv[i], (argc-i > 1)?argv[i+1]:NULL);
}
if (argc == 1 || (args & A_HELP)) { usage(argv[0]); }
forigin = fopen(origin, "rb");
if (!forigin)
ERROR("ERROR: failed to open input %s\n", origin);
if (fread(mbr, SECTOR, 1, forigin) != 1) ERROR("ERROR: Can't load MBR\n");
checkHeader((mainheader*) mbr);
if (args & A_INFO) {
printinfo(mbr, 0);
putchar('\n');
printinfo(mbr, MBR_HDR_LEN);
}
if (memcmp(mbr, mbr+MBR_HDR_LEN, MBR_HDR_LEN - 8))
MESSAGE("WARNING: divergent MBR image records, using the %s one\n", (second)?"second":"first");
process_mbr(mbr, (second)?MBR_HDR_LEN:0, forigin);
return 0;
}
static int smb_modinit(void)
{
int ret = 0;
struct i2c_adapter *adapter = NULL;
struct i2c_client *client = NULL;
printk(" smb_modinit \n");
#ifdef CONFIG_MTD_WMT_SF
parse_arg();
#endif
if (!g_battery_charging_en) {
printk("NO SMB358\n");
return -EIO;
}
smb_conf.bus_id = g_i2cbus_id;
adapter = i2c_get_adapter(smb_conf.bus_id);
smb_conf.i2c_adap = adapter;
if (adapter == NULL) {
printk("can not get smb i2c adapter, client address error");
return -ENODEV;
}
if ((client=i2c_new_device(adapter, smb_board_info)) == NULL) {
printk("allocate smb i2c client failed");
return -ENOMEM;
}
ret = i2c_add_driver(&smb_i2c_driver);
if(ret )
printk("SMB 358 i2c fail\n");
return ret;
}
int
main(int argc, char *argv[])
{
gint result;
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
bind_textdomain_codeset(PACKAGE, "UTF-8");
parse_arg(argc, argv);
gtk_init(&argc, &argv);
setup_default_icon();
result = create_window();
if (result == -1) {
g_printerr(_("Error:%s\n"), get_error_msg());
exit(EXIT_FAILURE);
}
gtk_main ();
return 0;
}
int hpx_main(variables_map& vm){
uint64_t num = vm["number-spawned"].as<uint64_t>();
string atype = vm["arg-type"].as<string>();
int c = vm["argc"].as<int>();
csv = (vm.count("csv") ? true : false);
parse_arg(atype, true, num, c);
return hpx::finalize();
}
void parse_cmdline(int argc, char *argv[])
{
int arg;
for(arg = 1; arg < argc; arg++) {
int sw;
char *argp, *start_argp;
argp = argv[arg];
while(*argp) {
start_argp = argp;
sw = get_opt(&argp, switches, sizeof(switches) / sizeof(switches[0]));
switch(sw) {
case GETOPT_PARAM:
if (isdigit(*argp) && *(argp+1) != ':') {
long n;
n = parse_kilobyte(argp, &argp);
if (n > 0x3FFFFFL)
syntax("Invalid disk size");
newf.size = n;
defined_format |= DISK_SIZE;
forced_format |= DISK_SIZE;
}
else {
if (drive)
goto bad_char;
drive = toupper(*argp);
if ( !( (drive >= 'A' && drive <= 'Z')
|| (drive >= '1' && drive <= '9')) )
bad_char:
syntax("Unrecognised character '%c' on command line", *argp);
if (*++argp == ':') argp++;
}
break;
case GETOPT_NOMATCH:
/* !!!! Should I try to cut any extra parameters off? */
syntax("Unknown switch %s", argp);
break;
case GETOPT_AMBIGUOUS:
/* !!!! Should list the ambiguities */
syntax("Ambiguous switch %s", argp);
break;
default:
argp = parse_arg(argp, sw);
break;
}
assert(argp != start_argp);
}
}
{ int c = 0;
if (defined_format & DISK_SIZE) c++;
if (defined_format & SPACE_AVAILABLE) c++;
if (defined_format & FILE_SPACE) c++;
if (defined_format & FREE_MEMORY) c++;
if (c > 1)
syntax("You specified many sizes for the disk");
}
}
/* Parse arguments, exit on error */
extern void parse_args (const int argc, const char *argv[]) {
char buffer [sizeof(prog_name)];
char *debugstr;
/* Store program name (basename alters buffer) */
strcpy (buffer, argv[0]);
strcpy (prog_name, basename(buffer));
/* Set debug */
debugstr = getenv (DEBUG_VAR);
if ( (debugstr != NULL) && (toupper(debugstr[0]) == 'Y') ) {
debug = TRUE;
}
/* Parse arguments */
if (argc == 1) {
error ("missing argument", "");
} else if (argc == 2) {
if ( (strcmp (argv[1], "-h") == 0)
|| (strcmp (argv[1], "--help") == 0) ) {
usage();
exit (ERROR_EXIT_CODE);
} else if ( (strcmp (argv[1], "-v") == 0)
|| (strcmp (argv[1], "--version") == 0) ) {
fprintf (stderr, "%s version %s\n", prog_name, VERSION);
exit (ERROR_EXIT_CODE);
} else {
dump_kind = no_dump;
parse_arg (argv[1]);
}
} else if (argc == 3) {
if (parse_dump(argv[1])) {
trace ("Dump detected as arg 1", "");
parse_arg (argv[2]);
} else if (parse_dump(argv[2])) {
trace ("Dump detected as arg 2", "");
parse_arg (argv[1]);
} else {
trace ("Full not detected", "");
error ("invalid arguments", "");
}
} else {
error ("too many arguments", "");
}
}
static ssize_t store_sys_hwmon(void (*set) (int), const char *buf, size_t count)
{
int rv, value;
rv = parse_arg(buf, count, &value);
if (rv > 0)
set(value);
return rv;
}
int main(int argc,char *argv[])
{
parse_arg(argc,argv);
Cache* C = make_cache();
caching(C,trace_file);
printSummary(C->num_of_hit,C->num_of_miss,C->num_of_evict);
delete_cache(C);
return 0;
}
