sys64738
/
mspdebug
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Move some unrelated functions out of parse.c

This commit is contained in:
Daniel Beer 2010-04-21 14:12:12 +12:00
parent 8655a64ef2
commit 90d39a96f5
12 changed files with 424 additions and 408 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
devcmd.c
View File

@ -92,13 +92,13 @@ static int cmd_md(char **arg)
return -1; return -1;
} }
if (addr_exp(off_text, &offset) < 0) { if (stab_exp(off_text, &offset) < 0) {
fprintf(stderr, "md: can't parse offset: %s\n", off_text); fprintf(stderr, "md: can't parse offset: %s\n", off_text);
return -1; return -1;
} }
if (len_text) { if (len_text) {
if (addr_exp(len_text, &length) < 0) { if (stab_exp(len_text, &length) < 0) {
fprintf(stderr, "md: can't parse length: %s\n", fprintf(stderr, "md: can't parse length: %s\n",
len_text); len_text);
return -1; return -1;
@ -149,7 +149,7 @@ static int cmd_mw(char **arg)
return -1; return -1;
} }
if (addr_exp(off_text, &offset) < 0) { if (stab_exp(off_text, &offset) < 0) {
fprintf(stderr, "md: can't parse offset: %s\n", off_text); fprintf(stderr, "md: can't parse offset: %s\n", off_text);
return -1; return -1;
} }
@ -248,7 +248,7 @@ static int cmd_run(char **arg)
device_status_t status; device_status_t status;
if (bp_text) { if (bp_text) {
if (addr_exp(bp_text, &bp_addr) < 0) { if (stab_exp(bp_text, &bp_addr) < 0) {
fprintf(stderr, "run: can't parse breakpoint: %s\n", fprintf(stderr, "run: can't parse breakpoint: %s\n",
bp_text); bp_text);
return -1; return -1;
@ -303,7 +303,7 @@ static int cmd_set(char **arg)
reg_text++; reg_text++;
reg = atoi(reg_text); reg = atoi(reg_text);
if (addr_exp(val_text, &value) < 0) { if (stab_exp(val_text, &value) < 0) {
fprintf(stderr, "set: can't parse value: %s\n", val_text); fprintf(stderr, "set: can't parse value: %s\n", val_text);
return -1; return -1;
} }
@ -344,13 +344,13 @@ static int cmd_dis(char **arg)
return -1; return -1;
} }
if (addr_exp(off_text, &offset) < 0) { if (stab_exp(off_text, &offset) < 0) {
fprintf(stderr, "dis: can't parse offset: %s\n", off_text); fprintf(stderr, "dis: can't parse offset: %s\n", off_text);
return -1; return -1;
} }
if (len_text) { if (len_text) {
if (addr_exp(len_text, &length) < 0) { if (stab_exp(len_text, &length) < 0) {
fprintf(stderr, "dis: can't parse length: %s\n", fprintf(stderr, "dis: can't parse length: %s\n",
len_text); len_text);
return -1; return -1;
@ -468,8 +468,8 @@ static int cmd_hexout(char **arg)
return -1; return -1;
} }
if (addr_exp(off_text, &off) < 0 || if (stab_exp(off_text, &off) < 0 ||
addr_exp(len_text, &length) < 0) stab_exp(len_text, &length) < 0)
return -1; return -1;
if (hexout_start(filename) < 0) if (hexout_start(filename) < 0)

366
parse.c
View File

@ -82,112 +82,6 @@ int is_interactive(void)
return interactive_call; return interactive_call;
} }
char *get_arg(char **text)
{
char *start;
char *rewrite;
char *end;
int qstate = 0;
int qval = 0;
if (!text)
return NULL;
start = *text;
while (*start && isspace(*start))
start++;
if (!*start)
return NULL;
/* We've found the start of the argument. Parse it. */
end = start;
rewrite = start;
while (*end) {
switch (qstate) {
case 0: /* Bare */
if (isspace(*end))
goto out;
else if (*end == '"')
qstate = 1;
else
*(rewrite++) = *end;
break;
case 1: /* In quotes */
if (*end == '"')
qstate = 0;
else if (*end == '\\')
qstate = 2;
else
*(rewrite++) = *end;
break;
case 2: /* Backslash */
if (*end == '\\')
*(rewrite++) = '\\';
else if (*end == 'n')
*(rewrite++) = '\n';
else if (*end == 'r')
*(rewrite++) = '\r';
else if (*end == 't')
*(rewrite++) = '\t';
else if (*end >= '0' && *end <= '3') {
qstate = 30;
qval = *end - '0';
} else if (*end == 'x') {
qstate = 40;
qval = 0;
} else
*(rewrite++) = *end;
if (qstate == 2)
qstate = 1;
break;
case 30: /* Octal */
case 31:
if (*end >= '0' && *end <= '7')
qval = (qval << 3) | (*end - '0');
if (qstate == 31) {
*(rewrite++) = qval;
qstate = 1;
} else {
qstate++;
}
break;
case 40: /* Hex */
case 41:
if (isdigit(*end))
qval = (qval << 4) | (*end - '0');
else if (isupper(*end))
qval = (qval << 4) | (*end - 'A' + 10);
else if (islower(*end))
qval = (qval << 4) | (*end - 'a' + 10);
if (qstate == 41) {
*(rewrite++) = qval;
qstate = 1;
} else {
qstate++;
}
break;
}
end++;
}
out:
/* Leave the text pointer at the end of the next argument */
while (*end && isspace(*end))
end++;
*rewrite = 0;
*text = end;
return start;
}
int process_command(char *arg, int interactive) int process_command(char *arg, int interactive)
{ {
const char *cmd_text; const char *cmd_text;
@ -444,7 +338,7 @@ static int parse_option(struct option *o, const char *word)
break; break;
case OPTION_NUMERIC: case OPTION_NUMERIC:
return addr_exp(word, &o->data.numeric); return stab_exp(word, &o->data.numeric);
case OPTION_TEXT: case OPTION_TEXT:
strncpy(o->data.text, word, sizeof(o->data.text)); strncpy(o->data.text, word, sizeof(o->data.text));
@ -575,264 +469,6 @@ void parse_init(void)
register_command(&command_read); register_command(&command_read);
} }
struct addr_exp_state {
int last_operator;
int data_stack[32];
int data_stack_size;
int op_stack[32];
int op_stack_size;
};
static int addr_exp_data(struct addr_exp_state *s, const char *text)
{
int value;
if (!s->last_operator || s->last_operator == ')') {
fprintf(stderr, "syntax error at token %s\n", text);
return -1;
}
/* Hex value */
if (*text == '0' && text[1] == 'x')
value = strtoul(text + 2, NULL, 16);
else if (isdigit(*text))
value = atoi(text);
else if (stab_get(text, &value) < 0) {
fprintf(stderr, "can't parse token: %s\n", text);
return -1;
}
if (s->data_stack_size + 1 > ARRAY_LEN(s->data_stack)) {
fprintf(stderr, "data stack overflow at token %s\n", text);
return -1;
}
s->data_stack[s->data_stack_size++] = value;
s->last_operator = 0;
return 0;
}
static int addr_exp_pop(struct addr_exp_state *s)
{
char op = s->op_stack[--s->op_stack_size];
int data1 = s->data_stack[--s->data_stack_size];
int data2 = 0;
int result = 0;
if (op != 'N')
data2 = s->data_stack[--s->data_stack_size];
assert (s->op_stack_size >= 0);
assert (s->data_stack_size >= 0);
switch (op) {
case '+':
result = data2 + data1;
break;
case '-':
result = data2 - data1;
break;
case '*':
result = data2 * data1;
break;
case '/':
if (!data1)
goto divzero;
result = data2 / data1;
break;
case '%':
if (!data1)
goto divzero;
result = data2 % data1;
break;
case 'N':
result = -data1;
break;
}
s->data_stack[s->data_stack_size++] = result;
return 0;
divzero:
fprintf(stderr, "divide by zero\n");
return -1;
}
static int can_push(struct addr_exp_state *s, char op)
{
char top;
if (!s->op_stack_size || op == '(')
return 1;
top = s->op_stack[s->op_stack_size - 1];
if (top == '(')
return 1;
switch (op) {
case 'N':
return 1;
case '*':
case '%':
case '/':
return top == '+' || top == '-';
default:
break;
}
return 0;
}
static int addr_exp_op(struct addr_exp_state *s, char op)
{
if (op == '(') {
if (!s->last_operator || s->last_operator == ')')
goto syntax_error;
} else if (op == '-') {
if (s->last_operator && s->last_operator != ')')
op = 'N';
} else {
if (s->last_operator && s->last_operator != ')')
goto syntax_error;
}
if (op == ')') {
/* ) collapses the stack to the last matching ( */
while (s->op_stack_size &&
s->op_stack[s->op_stack_size - 1] != '(')
if (addr_exp_pop(s) < 0)
return -1;
if (!s->op_stack_size) {
fprintf(stderr, "parenthesis mismatch: )\n");
return -1;
}
s->op_stack_size--;
} else {
while (!can_push(s, op))
if (addr_exp_pop(s) < 0)
return -1;
if (s->op_stack_size + 1 > ARRAY_LEN(s->op_stack)) {
fprintf(stderr, "operator stack overflow: %c\n", op);
return -1;
}
s->op_stack[s->op_stack_size++] = op;
}
s->last_operator = op;
return 0;
syntax_error:
fprintf(stderr, "syntax error at operator %c\n", op);
return -1;
}
static int addr_exp_finish(struct addr_exp_state *s, int *ret)
{
if (s->last_operator && s->last_operator != ')') {
fprintf(stderr, "syntax error at end of expression\n");
return -1;
}
while (s->op_stack_size) {
if (s->op_stack[s->op_stack_size - 1] == '(') {
fprintf(stderr, "parenthesis mismatch: (\n");
return -1;
}
if (addr_exp_pop(s) < 0)
return -1;
}
if (s->data_stack_size != 1) {
fprintf(stderr, "no data: stack size is %d\n",
s->data_stack_size);
return -1;
}
if (ret)
*ret = s->data_stack[0];
return 0;
}
int addr_exp(const char *text, int *addr)
{
const char *text_save = text;
int last_cc = 1;
char token_buf[64];
int token_len = 0;
struct addr_exp_state s = {0};
s.last_operator = '(';
for (;;) {
int cc;
/* Figure out what class this character is */
if (*text == '+' || *text == '-' ||
*text == '*' || *text == '/' ||
*text == '%' || *text == '(' ||
*text == ')')
cc = 1;
else if (!*text || isspace(*text))
cc = 2;
else if (isalnum(*text) || *text == '.' || *text == '_' ||
*text == '$' || *text == ':')
cc = 3;
else {
fprintf(stderr, "illegal character in expression: %c\n",
*text);
return -1;
}
/* Accumulate and process token text */
if (cc == 3) {
if (token_len + 1 < sizeof(token_buf))
token_buf[token_len++] = *text;
} else if (token_len) {
token_buf[token_len] = 0;
token_len = 0;
if (addr_exp_data(&s, token_buf) < 0)
goto fail;
}
/* Process operators */
if (cc == 1) {
if (addr_exp_op(&s, *text) < 0)
goto fail;
}
if (!*text)
break;
last_cc = cc;
text++;
}
if (addr_exp_finish(&s, addr) < 0)
goto fail;
return 0;
fail:
fprintf(stderr, "bad address expression: %s\n", text_save);
return -1;
}
static int modify_flags; static int modify_flags;
void modify_set(int flags) void modify_set(int flags)

12
parse.h
View File

@ -34,11 +34,6 @@ struct command {
/* Add a command to the global command table */ /* Add a command to the global command table */
void register_command(struct command *c); void register_command(struct command *c);
/* Retrieve the next word from a pointer to the rest of a command
* argument buffer. Returns NULL if no more words.
*/
char *get_arg(char **text);
/* Process a command, returning -1 on error or 0 if executed /* Process a command, returning -1 on error or 0 if executed
* successfully. * successfully.
* *
@ -63,13 +58,6 @@ int colorize(const char *text);
/* Return non-zero if executing in an interactive context. */ /* Return non-zero if executing in an interactive context. */
int is_interactive(void); int is_interactive(void);
/* Parse an address expression, storing the result in the integer
* pointed to. Returns 0 if parsed successfully, -1 if not.
*/
typedef int (*token_func_t)(const char *text, int *value);
int addr_exp(const char *text, int *value);
/* Mark/unmark items as modified. The modify_prompt function, when /* Mark/unmark items as modified. The modify_prompt function, when
* called in interactive context, prompts the user before continuing * called in interactive context, prompts the user before continuing
* if any of the items specified are modified. If the user elects * if any of the items specified are modified. If the user elects

10
rf2500.c
View File

@ -23,10 +23,6 @@
#include "transport.h" #include "transport.h"
#include "util.h" #include "util.h"
#ifdef DEBUG_USBTR
#include "parse.h"
#endif
/********************************************************************* /*********************************************************************
* USB transport * USB transport
* *
@ -111,8 +107,7 @@ static int usbtr_send(const u_int8_t *data, int len)
pbuf[0] = txlen - 1; pbuf[0] = txlen - 1;
#ifdef DEBUG_USBTR #ifdef DEBUG_USBTR
puts("USB transfer out:"); debug_hexdump("USB transfer out", pbuf, txlen);
hexdump(0, pbuf, txlen);
#endif #endif
if (usb_bulk_write(usbtr_handle, USB_FET_OUT_EP, if (usb_bulk_write(usbtr_handle, USB_FET_OUT_EP,
(const char *)pbuf, txlen, 10000) < 0) { (const char *)pbuf, txlen, 10000) < 0) {
@ -154,8 +149,7 @@ static int usbtr_recv(u_int8_t *databuf, int max_len)
} }
#ifdef DEBUG_USBTR #ifdef DEBUG_USBTR
puts("USB transfer in:"); debug_hexdump("USB transfer in", usbtr_buf, 64);
hexdump(0, usbtr_buf, 64);
#endif #endif
usbtr_len = usbtr_buf[1] + 2; usbtr_len = usbtr_buf[1] + 2;

7
rtools.c
View File

@ -26,6 +26,7 @@
#include "device.h" #include "device.h"
#include "dis.h" #include "dis.h"
#include "rtools.h" #include "rtools.h"
#include "stab.h"
#include "parse.h" #include "parse.h"
#define ISEARCH_OPCODE 0x0001 #define ISEARCH_OPCODE 0x0001
@ -131,7 +132,7 @@ static int isearch_addr(const char *term, char **arg,
return -1; return -1;
} }
if (addr_exp(addr_text, &addr) < 0) if (stab_exp(addr_text, &addr) < 0)
return -1; return -1;
q->flags |= which; q->flags |= which;
@ -387,8 +388,8 @@ static int cmd_isearch(char **arg)
return -1; return -1;
} }
if (addr_exp(addr_text, &addr) < 0 || if (stab_exp(addr_text, &addr) < 0 ||
addr_exp(len_text, &len) < 0) stab_exp(len_text, &len) < 0)
return -1; return -1;
q.flags = 0; q.flags = 0;

2
sim.c
View File

@ -99,7 +99,7 @@ static int fetch_io(u_int16_t addr, int is_byte, u_int32_t *data_ret)
return 0; return 0;
} }
if (!addr_exp(text, &data)) { if (!stab_exp(text, &data)) {
if (data_ret) if (data_ret)
*data_ret = data; *data_ret = data;
return 0; return 0;

264
stab.c
View File

@ -23,8 +23,10 @@
#include <sys/types.h> #include <sys/types.h>
#include <regex.h> #include <regex.h>
#include <errno.h> #include <errno.h>
#include <assert.h>
#include "btree.h" #include "btree.h"
#include "stab.h" #include "stab.h"
#include "util.h"
struct sym_key { struct sym_key {
char name[64]; char name[64];
@ -226,3 +228,265 @@ void stab_exit(void)
btree_free(sym_table); btree_free(sym_table);
btree_free(addr_table); btree_free(addr_table);
} }
/************************************************************************
* Address expression parsing.
*/
struct addr_exp_state {
int last_operator;
int data_stack[32];
int data_stack_size;
int op_stack[32];
int op_stack_size;
};
static int addr_exp_data(struct addr_exp_state *s, const char *text)
{
int value;
if (!s->last_operator || s->last_operator == ')') {
fprintf(stderr, "syntax error at token %s\n", text);
return -1;
}
/* Hex value */
if (*text == '0' && text[1] == 'x')
value = strtoul(text + 2, NULL, 16);
else if (isdigit(*text))
value = atoi(text);
else if (stab_get(text, &value) < 0) {
fprintf(stderr, "can't parse token: %s\n", text);
return -1;
}
if (s->data_stack_size + 1 > ARRAY_LEN(s->data_stack)) {
fprintf(stderr, "data stack overflow at token %s\n", text);
return -1;
}
s->data_stack[s->data_stack_size++] = value;
s->last_operator = 0;
return 0;
}
static int addr_exp_pop(struct addr_exp_state *s)
{
char op = s->op_stack[--s->op_stack_size];
int data1 = s->data_stack[--s->data_stack_size];
int data2 = 0;
int result = 0;
if (op != 'N')
data2 = s->data_stack[--s->data_stack_size];
assert (s->op_stack_size >= 0);
assert (s->data_stack_size >= 0);
switch (op) {
case '+':
result = data2 + data1;
break;
case '-':
result = data2 - data1;
break;
case '*':
result = data2 * data1;
break;
case '/':
if (!data1)
goto divzero;
result = data2 / data1;
break;
case '%':
if (!data1)
goto divzero;
result = data2 % data1;
break;
case 'N':
result = -data1;
break;
}
s->data_stack[s->data_stack_size++] = result;
return 0;
divzero:
fprintf(stderr, "divide by zero\n");
return -1;
}
static int can_push(struct addr_exp_state *s, char op)
{
char top;
if (!s->op_stack_size || op == '(')
return 1;
top = s->op_stack[s->op_stack_size - 1];
if (top == '(')
return 1;
switch (op) {
case 'N':
return 1;
case '*':
case '%':
case '/':
return top == '+' || top == '-';
default:
break;
}
return 0;
}
static int addr_exp_op(struct addr_exp_state *s, char op)
{
if (op == '(') {
if (!s->last_operator || s->last_operator == ')')
goto syntax_error;
} else if (op == '-') {
if (s->last_operator && s->last_operator != ')')
op = 'N';
} else {
if (s->last_operator && s->last_operator != ')')
goto syntax_error;
}
if (op == ')') {
/* ) collapses the stack to the last matching ( */
while (s->op_stack_size &&
s->op_stack[s->op_stack_size - 1] != '(')
if (addr_exp_pop(s) < 0)
return -1;
if (!s->op_stack_size) {
fprintf(stderr, "parenthesis mismatch: )\n");
return -1;
}
s->op_stack_size--;
} else {
while (!can_push(s, op))
if (addr_exp_pop(s) < 0)
return -1;
if (s->op_stack_size + 1 > ARRAY_LEN(s->op_stack)) {
fprintf(stderr, "operator stack overflow: %c\n", op);
return -1;
}
s->op_stack[s->op_stack_size++] = op;
}
s->last_operator = op;
return 0;
syntax_error:
fprintf(stderr, "syntax error at operator %c\n", op);
return -1;
}
static int addr_exp_finish(struct addr_exp_state *s, int *ret)
{
if (s->last_operator && s->last_operator != ')') {
fprintf(stderr, "syntax error at end of expression\n");
return -1;
}
while (s->op_stack_size) {
if (s->op_stack[s->op_stack_size - 1] == '(') {
fprintf(stderr, "parenthesis mismatch: (\n");
return -1;
}
if (addr_exp_pop(s) < 0)
return -1;
}
if (s->data_stack_size != 1) {
fprintf(stderr, "no data: stack size is %d\n",
s->data_stack_size);
return -1;
}
if (ret)
*ret = s->data_stack[0];
return 0;
}
int stab_exp(const char *text, int *addr)
{
const char *text_save = text;
int last_cc = 1;
char token_buf[64];
int token_len = 0;
struct addr_exp_state s = {0};
s.last_operator = '(';
for (;;) {
int cc;
/* Figure out what class this character is */
if (*text == '+' || *text == '-' ||
*text == '*' || *text == '/' ||
*text == '%' || *text == '(' ||
*text == ')')
cc = 1;
else if (!*text || isspace(*text))
cc = 2;
else if (isalnum(*text) || *text == '.' || *text == '_' ||
*text == '$' || *text == ':')
cc = 3;
else {
fprintf(stderr, "illegal character in expression: %c\n",
*text);
return -1;
}
/* Accumulate and process token text */
if (cc == 3) {
if (token_len + 1 < sizeof(token_buf))
token_buf[token_len++] = *text;
} else if (token_len) {
token_buf[token_len] = 0;
token_len = 0;
if (addr_exp_data(&s, token_buf) < 0)
goto fail;
}
/* Process operators */
if (cc == 1) {
if (addr_exp_op(&s, *text) < 0)
goto fail;
}
if (!*text)
break;
last_cc = cc;
text++;
}
if (addr_exp_finish(&s, addr) < 0)
goto fail;
return 0;
fail:
fprintf(stderr, "bad address expression: %s\n", text_save);
return -1;
}

5
stab.h
View File

@ -56,4 +56,9 @@ typedef int (*stab_callback_t)(const char *name, u_int16_t value);
int stab_enum(stab_callback_t cb); int stab_enum(stab_callback_t cb);
/* Parse an address expression, storing the result in the integer
* pointed to. Returns 0 if parsed successfully, -1 if not.
*/
int stab_exp(const char *text, int *value);
#endif #endif

4
sym.c
View File

@ -35,7 +35,7 @@ static int cmd_eval(char **arg)
u_int16_t offset; u_int16_t offset;
char name[64]; char name[64];
if (addr_exp(*arg, &addr) < 0) { if (stab_exp(*arg, &addr) < 0) {
fprintf(stderr, "=: can't parse: %s\n", *arg); fprintf(stderr, "=: can't parse: %s\n", *arg);
return -1; return -1;
} }
@ -321,7 +321,7 @@ static int cmd_sym(char **arg)
return -1; return -1;
} }
if (addr_exp(val_text, &value) < 0) { if (stab_exp(val_text, &value) < 0) {
fprintf(stderr, "sym: can't parse value: %s\n", fprintf(stderr, "sym: can't parse value: %s\n",
val_text); val_text);
return -1; return -1;

10
uif.c
View File

@ -27,10 +27,6 @@
#include "transport.h" #include "transport.h"
#include "util.h" #include "util.h"
#ifdef DEBUG_SERIAL
#include "parse.h"
#endif
static int serial_fd = -1; static int serial_fd = -1;
static int serial_send(const u_int8_t *data, int len) static int serial_send(const u_int8_t *data, int len)
@ -38,8 +34,7 @@ static int serial_send(const u_int8_t *data, int len)
assert (serial_fd >= 0); assert (serial_fd >= 0);
#ifdef DEBUG_SERIAL #ifdef DEBUG_SERIAL
puts("Serial transfer out:"); debug_hexdump("Serial transfer out:", data, len);
hexdump(0, data, len);
#endif #endif
if (write_all(serial_fd, data, len) < 0) { if (write_all(serial_fd, data, len) < 0) {
@ -63,8 +58,7 @@ static int serial_recv(u_int8_t *data, int max_len)
} }
#ifdef DEBUG_SERIAL #ifdef DEBUG_SERIAL
puts("Serial transfer in:"); debug_hexdump("Serial transfer in", data, r);
hexdump(0, data, r);
#endif #endif
return r; return r;
} }

123
util.c
View File

@ -118,3 +118,126 @@ int open_serial(const char *device, int rate)
return fd; return fd;
} }
char *get_arg(char **text)
{
char *start;
char *rewrite;
char *end;
int qstate = 0;
int qval = 0;
if (!text)
return NULL;
start = *text;
while (*start && isspace(*start))
start++;
if (!*start)
return NULL;
/* We've found the start of the argument. Parse it. */
end = start;
rewrite = start;
while (*end) {
switch (qstate) {
case 0: /* Bare */
if (isspace(*end))
goto out;
else if (*end == '"')
qstate = 1;
else
*(rewrite++) = *end;
break;
case 1: /* In quotes */
if (*end == '"')
qstate = 0;
else if (*end == '\\')
qstate = 2;
else
*(rewrite++) = *end;
break;
case 2: /* Backslash */
if (*end == '\\')
*(rewrite++) = '\\';
else if (*end == 'n')
*(rewrite++) = '\n';
else if (*end == 'r')
*(rewrite++) = '\r';
else if (*end == 't')
*(rewrite++) = '\t';
else if (*end >= '0' && *end <= '3') {
qstate = 30;
qval = *end - '0';
} else if (*end == 'x') {
qstate = 40;
qval = 0;
} else
*(rewrite++) = *end;
if (qstate == 2)
qstate = 1;
break;
case 30: /* Octal */
case 31:
if (*end >= '0' && *end <= '7')
qval = (qval << 3) | (*end - '0');
if (qstate == 31) {
*(rewrite++) = qval;
qstate = 1;
} else {
qstate++;
}
break;
case 40: /* Hex */
case 41:
if (isdigit(*end))
qval = (qval << 4) | (*end - '0');
else if (isupper(*end))
qval = (qval << 4) | (*end - 'A' + 10);
else if (islower(*end))
qval = (qval << 4) | (*end - 'a' + 10);
if (qstate == 41) {
*(rewrite++) = qval;
qstate = 1;
} else {
qstate++;
}
break;
}
end++;
}
out:
/* Leave the text pointer at the end of the next argument */
while (*end && isspace(*end))
end++;
*rewrite = 0;
*text = end;
return start;
}
void debug_hexdump(const char *label, const u_int8_t *data, int len)
{
int offset = 0;
printf("%s [0x%x bytes]\n", label, len);
while (offset < len) {
int i;
printf(" ");
for (i = 0; i < 16 && offset + i < len; i++)
printf("%02x ", data[offset + i]);
printf("\n");
offset += i;
}
}

11
util.h
View File

@ -23,12 +23,23 @@
#define ARRAY_LEN(a) (sizeof(a) / sizeof((a)[0])) #define ARRAY_LEN(a) (sizeof(a) / sizeof((a)[0]))
/* Various utility functions for IO */
int open_serial(const char *device, int rate); int open_serial(const char *device, int rate);
int read_with_timeout(int fd, u_int8_t *data, int len); int read_with_timeout(int fd, u_int8_t *data, int len);
int write_all(int fd, const u_int8_t *data, int len); int write_all(int fd, const u_int8_t *data, int len);
/* Check and catch ^C from the user */
void ctrlc_init(void); void ctrlc_init(void);
void ctrlc_reset(void); void ctrlc_reset(void);
int ctrlc_check(void); int ctrlc_check(void);
/* Retrieve the next word from a pointer to the rest of a command
* argument buffer. Returns NULL if no more words.
*/
char *get_arg(char **text);
/* Display hex output for debug purposes */
void debug_hexdump(const char *label,
const u_int8_t *data, int len);
#endif #endif