static void readline_backword(ReadLineState *rs) { int start; if (rs->cmd_buf_index == 0 || rs->cmd_buf_index > rs->cmd_buf_size) { return; } start = rs->cmd_buf_index - 1; /* find first word (backwards) */ while (start > 0) { if (!qemu_isspace(rs->cmd_buf[start])) { break; } --start; } /* find first space (backwards) */ while (start > 0) { if (qemu_isspace(rs->cmd_buf[start])) { ++start; break; } --start; } /* remove word */ if (start < rs->cmd_buf_index) { memmove(rs->cmd_buf + start, rs->cmd_buf + rs->cmd_buf_index, rs->cmd_buf_size - rs->cmd_buf_index); rs->cmd_buf_size -= rs->cmd_buf_index - start; rs->cmd_buf_index = start; } }
static void term_backword(void) { int start; if (term_cmd_buf_index == 0 || term_cmd_buf_index > term_cmd_buf_size) { return; } start = term_cmd_buf_index - 1; /* find first word (backwards) */ while (start > 0) { if (!qemu_isspace(term_cmd_buf[start])) { break; } --start; } /* find first space (backwards) */ while (start > 0) { if (qemu_isspace(term_cmd_buf[start])) { ++start; break; } --start; } /* remove word */ if (start < term_cmd_buf_index) { memmove(term_cmd_buf + start, term_cmd_buf + term_cmd_buf_index, term_cmd_buf_size - term_cmd_buf_index); term_cmd_buf_size -= term_cmd_buf_index - start; term_cmd_buf_index = start; } }
static int get_tag_value(char *buf, int buf_size, const char *str, const char *tag, const char *stopchars) { const char *p; char *q; p = strstr(str, tag); if (!p) return -1; p += strlen(tag); while (qemu_isspace(*p)) p++; q = buf; while (*p != '\0' && !strchr(stopchars, *p)) { if ((q - buf) < (buf_size - 1)) *q++ = *p; p++; } *q = '\0'; return q - buf; }
/* * Convert string to bytes, allowing either B/b for bytes, K/k for KB, * M/m for MB, G/g for GB or T/t for TB. Default without any postfix * is MB. End pointer will be returned in *end, if not NULL. A valid * value must be terminated by whitespace, ',' or '\0'. Return -1 on * error. */ int64_t strtosz_suffix(const char *nptr, char **end, const char default_suffix) { int64_t retval = -1; char *endptr; unsigned char c, d; int mul_required = 0; double val, mul, integral, fraction; errno = 0; val = strtod(nptr, &endptr); if (isnan(val) || endptr == nptr || errno != 0) { goto fail; } fraction = modf(val, &integral); if (fraction != 0) { mul_required = 1; } /* * Any whitespace character is fine for terminating the number, * in addition we accept ',' to handle strings where the size is * part of a multi token argument. */ c = *endptr; d = c; if (qemu_isspace(c) || c == '\0' || c == ',') { c = 0; if (default_suffix) { d = default_suffix; } else { d = c; } } switch (qemu_toupper(d)) { case STRTOSZ_DEFSUFFIX_B: mul = 1; if (mul_required) { goto fail; } break; case STRTOSZ_DEFSUFFIX_KB: mul = 1 << 10; break; case 0: if (mul_required) { goto fail; } case STRTOSZ_DEFSUFFIX_MB: mul = 1ULL << 20; break; case STRTOSZ_DEFSUFFIX_GB: mul = 1ULL << 30; break; case STRTOSZ_DEFSUFFIX_TB: mul = 1ULL << 40; break; default: goto fail; } /* * If not terminated by whitespace, ',', or \0, increment endptr * to point to next character, then check that we are terminated * by an appropriate separating character, ie. whitespace, ',', or * \0. If not, we are seeing trailing garbage, thus fail. */ if (c != 0) { endptr++; if (!qemu_isspace(*endptr) && *endptr != ',' && *endptr != 0) { goto fail; } } if ((val * mul >= INT64_MAX) || val < 0) { goto fail; } retval = val * mul; fail: if (end) { *end = endptr; } return retval; }