void uncode_args(unsigned char *field, t_process *proc, int op_num, uint32_t *ar) { size_t i; size_t curr; short ind; curr = check_pc(proc->pc + 1 + (g_op[op_num].coding_byte)); i = 0; while (i < g_op[op_num].nbr_arg) { if (ar[i] == T_REG) { ar[i] = (uint32_t)field[curr]; curr = check_pc(curr + 1); } else if (ar[i] == T_DIR) ar[i] = convert_arg(field, &curr, g_op[op_num].flag_direct_size); else if (ar[i] == T_IND) { ind = (short)convert_arg(field, &curr, IND_READ); if (op_num != 12) ind = ind % IDX_MOD; ar[i] = ((op_num != 2) ? get_ind(field, (proc->pc + ind)) : ind); } i++; } }
static PyObject *entity_setstate(PyObject *self, PyObject *state) { PyObject *dict, *public_id, *system_id, *unparsed_entities, *children, *temp; Py_ssize_t i, n; if (!PyArg_UnpackTuple(state, NULL, 5, 5, &dict, &public_id, &system_id, &unparsed_entities, &children)) return NULL; if (!convert_arg(0, &PyDict_Type, &dict)) return NULL; if (!convert_arg(3, &PyDict_Type, &unparsed_entities)) return NULL; if (!convert_arg(4, &PyTuple_Type, &children)) return NULL; if (dict) { if (PyType_HasFeature(self->ob_type, Py_TPFLAGS_HEAPTYPE)) { temp = PyObject_GetAttrString(self, "__dict__"); if (temp == NULL) return NULL; if (PyDict_Update(temp, dict) < 0) { Py_DECREF(temp); return NULL; } Py_DECREF(temp); } } temp = Entity_GET_PUBLIC_ID(self); Entity_SET_PUBLIC_ID(self, public_id); Py_INCREF(public_id); Py_DECREF(temp); temp = Entity_GET_SYSTEM_ID(self); Entity_SET_SYSTEM_ID(self, system_id); Py_INCREF(system_id); Py_DECREF(temp); if (unparsed_entities) { temp = Entity_GET_UNPARSED_ENTITIES(self); PyDict_Clear(temp); if (PyDict_Update(temp, unparsed_entities) < 0) return NULL; } if (children) { for (i = 0, n = PyTuple_GET_SIZE(children); i < n; i++) { NodeObject *node = (NodeObject *)PyTuple_GET_ITEM(children, i); if (Container_Append((NodeObject *)self, node) < 0) return NULL; } } Py_RETURN_NONE; }
static void get_result(t_ullong arg, t_format *f) { t_uchar *tmp; if (f->precision < (int)ft_strlen(f->buf)) f->precision = ft_strlen(f->buf); if (f->width > f->precision && !f->flag_minus && !f->flag_zero && f->precision != -1) f->res += print_char(f->width - f->precision, ' '); if (f->flag_zero) f->res += print_char(f->width - ft_strlen(f->buf), '0'); f->res += print_char(f->precision - ft_strlen(f->buf), '0'); if (arg != 0 || f->precision || f->flag_minus) { if (f->mod_l) { tmp = convert_arg(arg); tmp--; while (*(++tmp)) f->res = print_char(ft_strlen((char *)tmp), *tmp); } else f->res = print_char(1, arg); } if (f->flag_minus) f->res += print_char(f->width - f->precision, ' '); }
uint32_t get_ind(unsigned char *field, size_t curr) { uint32_t arg; arg = convert_arg(field, &curr, IND_SIZE); return (arg); }
void ft_print_u(va_list *ap, t_format *f) { t_ullong arg; arg = va_arg(*ap, t_ullong); update_format(f); convert_arg(arg, f); get_result(arg, f); init_f(f); }
static void build_args(dfsch_object_t* list, int* pargc, char*** pargv){ int alloc = 16; char** argv = GC_MALLOC(sizeof(char*) * alloc); int argc = 0; while (DFSCH_PAIR_P(list)){ if (alloc <= argc){ alloc *= 2; argv = GC_REALLOC(argv, sizeof(char*) * alloc); } argv[argc] = convert_arg(DFSCH_FAST_CAR(list)); argc++; list = DFSCH_FAST_CDR(list); } *pargc = argc; *pargv = argv; }
static void convert_line (void) { char *c, *cc; char xbuf[BUFSZ]; cc = out_line; for (c = xcrypt(in_line, xbuf); *c; c++) { *cc = 0; switch(*c) { case '\r': case '\n': *(++cc) = 0; return; case '%': if (*(c+1)) { convert_arg(*(++c)); switch (*(++c)) { /* insert "a"/"an" prefix */ case 'A': strcat(cc, An(cvt_buf)); cc += strlen(cc); continue; /* for */ case 'a': strcat(cc, an(cvt_buf)); cc += strlen(cc); continue; /* for */ /* capitalize */ case 'C': cvt_buf[0] = highc(cvt_buf[0]); break; /* pluralize */ case 'P': cvt_buf[0] = highc(cvt_buf[0]); case 'p': strcpy(cvt_buf, makeplural(cvt_buf)); break; /* append possessive suffix */ case 'S': cvt_buf[0] = highc(cvt_buf[0]); case 's': strcpy(cvt_buf, "TODO: s_suffix(cvt_buf)"); break; /* strip any "the" prefix */ case 't': if (!strncmpi(cvt_buf, "the ", 4)) { strcat(cc, &cvt_buf[4]); cc += strlen(cc); continue; /* for */ } break; default: --c; /* undo switch increment */ break; } strcat(cc, cvt_buf); cc += strlen(cvt_buf); break; } /* else fall through */ default: *cc++ = *c; break; } } if (cc >= out_line + sizeof out_line) panic("convert_line: overflow"); *cc = 0; return; }
/** * We have a complete line from the user, lookup the commands and execute them * * Commands are tokenised based on white space and then the first * word is checked againts the cmds table. If a match is found the * second word is compared to the different options for that command. * * Commands may also take up to 3 additional arguments, these are all * assumed to the numeric values and will be converted before being passed * to the handler function for the command. * * @param cli The CLI_SESSION * @return Returns 0 if the interpreter should exit */ int execute_cmd(CLI_SESSION *cli) { DCB *dcb = cli->session->client; int argc, i, j, found = 0; char *args[MAXARGS]; char *saveptr, *delim = " \t\r\n"; unsigned long arg1, arg2, arg3; /* Tokenize the input string */ args[0] = strtok_r(cli->cmdbuf, delim, &saveptr); i = 0; do { i++; args[i] = strtok_r(NULL, delim, &saveptr); } while (args[i] != NULL && i < MAXARGS); if (args[0] == NULL) return 1; argc = i - 2; /* The number of extra arguments to commands */ if (!strcasecmp(args[0], "help")) { if (args[1] == NULL) { found = 1; dcb_printf(dcb, "Available commands:\n"); for (i = 0; cmds[i].cmd; i++) { for (j = 0; cmds[i].options[j].arg1; j++) { dcb_printf(dcb, " %s %s\n", cmds[i].cmd, cmds[i].options[j].arg1); } } } else { for (i = 0; cmds[i].cmd; i++) { if (!strcasecmp(args[1], cmds[i].cmd)) { found = 1; dcb_printf(dcb, "Available options to the %s command:\n", args[1]); for (j = 0; cmds[i].options[j].arg1; j++) { dcb_printf(dcb, " %-10s %s\n", cmds[i].options[j].arg1, cmds[i].options[j].help); } } } if (found == 0) { dcb_printf(dcb, "No command %s to offer help with\n", args[1]); } } found = 1; } else if (!strcasecmp(args[0], "quit")) { return 0; } else if (argc >= 0) { for (i = 0; cmds[i].cmd; i++) { if (strcasecmp(args[0], cmds[i].cmd) == 0) { for (j = 0; cmds[i].options[j].arg1; j++) { found = 1; /**< command and sub-command match */ if (strcasecmp(args[1], cmds[i].options[j].arg1) == 0) { if (argc != cmds[i].options[j].n_args) { dcb_printf(dcb, "Incorrect number of arguments: %s %s expects %d arguments\n", cmds[i].cmd, cmds[i].options[j].arg1, cmds[i].options[j].n_args); } else { switch (cmds[i].options[j].n_args) { case 0: cmds[i].options[j].fn(dcb); break; case 1: arg1 = convert_arg(args[2],cmds[i].options[j].arg_types[0]); if (arg1) cmds[i].options[j].fn(dcb, arg1); else dcb_printf(dcb, "Invalid argument: %s\n", args[2]); break; case 2: arg1 = convert_arg(args[2],cmds[i].options[j].arg_types[0]); arg2 = convert_arg(args[3],cmds[i].options[j].arg_types[1]); if (arg1 && arg2) cmds[i].options[j].fn(dcb, arg1, arg2); else if (arg1 == 0) dcb_printf(dcb, "Invalid argument: %s\n", args[2]); else dcb_printf(dcb, "Invalid argument: %s\n", args[3]); break; case 3: arg1 = convert_arg(args[2],cmds[i].options[j].arg_types[0]); arg2 = convert_arg(args[3],cmds[i].options[j].arg_types[1]); arg3 = convert_arg(args[4],cmds[i].options[j].arg_types[2]); if (arg1 && arg2 && arg3) cmds[i].options[j].fn(dcb, arg1, arg2, arg3); else if (arg1 == 0) dcb_printf(dcb, "Invalid argument: %s\n", args[2]); else if (arg2 == 0) dcb_printf(dcb, "Invalid argument: %s\n", args[3]); else if (arg3 == 0) dcb_printf(dcb, "Invalid argument: %s\n", args[4]); } } } } if (!found) { dcb_printf(dcb, "Unknown or missing option for the %s command. Valid sub-commands are:\n", cmds[i].cmd); for (j = 0; cmds[i].options[j].arg1; j++) { dcb_printf(dcb, " %-10s %s\n", cmds[i].options[j].arg1, cmds[i].options[j].help); } found = 1; } } } } else if (argc == -1) { dcb_printf(dcb, "Commands must consist of at least two words. Type help for a list of commands\n"); found = 1; } if (!found) dcb_printf(dcb, "Command '%s' not known, type help for a list of available commands\n", args[0]); memset(cli->cmdbuf, 0, 80); return 1; }
static const char * convert_line(const char *in_line) { /* xcrypt needs us to allocate a buffer for it */ char decrypted_line[strlen(in_line)+1]; xcrypt(in_line, decrypted_line); const char *rv = ""; char *c; /* Tokenize the decrypted line; we stop at \r, \n, or \0, and do special handling of "%" characters. The algorithm used here is quadratic (when linear is possible), but given that the lines are only 80 characters long, I feel that a clear algorithm is superior to a low computational complexity algorithm. */ for (c = xcrypt(in_line, decrypted_line);; c++) { switch (*c) { case '\r': case '\n': case '\0': return rv; case '%': if (c[1]) { const char *conversion = convert_arg(*(++c)); switch (*(++c)) { /* insert "a"/"an" prefix */ case 'A': rv = msgcat(rv, An(conversion)); break; case 'a': rv = msgcat(rv, an(conversion)); break; /* capitalize */ case 'C': rv = msgcat(rv, msgupcasefirst(conversion)); break; /* pluralize */ case 'P': /* Note: makeplural doesn't work on arbitrarily capitalized strings */ rv = msgcat(rv, msgupcasefirst(makeplural(conversion))); break; case 'p': rv = msgcat(rv, makeplural(conversion)); break; /* append possessive suffix */ case 'S': conversion = msgupcasefirst(conversion); /* fall through */ case 's': rv = msgcat(rv, s_suffix(conversion)); break; /* strip any "the" prefix */ case 't': if (!strncmpi(conversion, "the ", 4)) rv = msgcat(rv, conversion + 4); else rv = msgcat(rv, conversion); break; default: --c; /* undo switch increment */ rv = msgcat(rv, conversion); break; } break; } /* else fall through */ default: rv = msgkitten(rv, *c); break; } } }