Commit b852caf3 authored by Pieter Noordhuis's avatar Pieter Noordhuis
Browse files

Abbreviate errors http-parser.c style

parent e791703f
......@@ -5,7 +5,7 @@
#include <assert.h>
#include "parser.h"
#define ERRNO(code) REDIS_PARSER_##code
#define ERRNO(code) RPE_##code
#define SET_ERRNO(code) do { \
parser->err = ERRNO(code); \
} while(0)
......@@ -15,7 +15,7 @@
#define CALLBACK(X, ...) do { \
if (callbacks && callbacks->on_##X) { \
if (callbacks->on_##X(parser, __VA_ARGS__) != 0) { \
SET_ERRNO(ERR_CALLBACK); \
SET_ERRNO(CALLBACK); \
goto error; \
} \
} \
......@@ -57,7 +57,7 @@ enum state {
#define _GEN(code, description) description,
static const char *strerror_map[] = {
REDIS_PARSER_ERRORS(_GEN)
REDIS_PARSER_ERRNO_MAP(_GEN)
};
#undef _GEN
......@@ -205,7 +205,7 @@ size_t redis_parser_execute(redis_parser_t *parser, redis_protocol_t **dst, cons
ADVANCE_AND_MOVE(line);
}
SET_ERRNO(ERR_INVALID_TYPE);
SET_ERRNO(INVALID_TYPE);
goto error;
}
......@@ -235,7 +235,7 @@ size_t redis_parser_execute(redis_parser_t *parser, redis_protocol_t **dst, cons
ADVANCE_AND_MOVE(integer_cr);
}
SET_ERRNO(ERR_INVALID_INT);
SET_ERRNO(INVALID_INT);
goto error;
}
......@@ -247,7 +247,7 @@ size_t redis_parser_execute(redis_parser_t *parser, redis_protocol_t **dst, cons
ADVANCE_AND_MOVE(integer_pos_09);
}
SET_ERRNO(ERR_INVALID_INT);
SET_ERRNO(INVALID_INT);
goto error;
}
......@@ -256,12 +256,12 @@ size_t redis_parser_execute(redis_parser_t *parser, redis_protocol_t **dst, cons
if (ch >= '0' && ch <= '9') {
if (i64.ui64 > ((uint64_t)INT64_MAX / 10)) { /* Overflow */
SET_ERRNO(ERR_OVERFLOW);
SET_ERRNO(OVERFLOW);
goto error;
}
i64.ui64 *= 10;
if (i64.ui64 > ((uint64_t)INT64_MAX - (ch - '0'))) { /* Overflow */
SET_ERRNO(ERR_OVERFLOW);
SET_ERRNO(OVERFLOW);
goto error;
}
i64.ui64 += ch - '0';
......@@ -271,7 +271,7 @@ size_t redis_parser_execute(redis_parser_t *parser, redis_protocol_t **dst, cons
ADVANCE_AND_MOVE(integer_lf);
}
SET_ERRNO(ERR_INVALID_INT);
SET_ERRNO(INVALID_INT);
goto error;
}
......@@ -283,7 +283,7 @@ size_t redis_parser_execute(redis_parser_t *parser, redis_protocol_t **dst, cons
ADVANCE_AND_MOVE(integer_neg_09);
}
SET_ERRNO(ERR_INVALID_INT);
SET_ERRNO(INVALID_INT);
goto error;
}
......@@ -292,12 +292,12 @@ size_t redis_parser_execute(redis_parser_t *parser, redis_protocol_t **dst, cons
if (ch >= '0' && ch <= '9') {
if (i64.ui64 > (((uint64_t)-(INT64_MIN+1)+1) / 10)) { /* Overflow */
SET_ERRNO(ERR_OVERFLOW);
SET_ERRNO(OVERFLOW);
goto error;
}
i64.ui64 *= 10;
if (i64.ui64 > (((uint64_t)-(INT64_MIN+1)+1) - (ch - '0'))) { /* Overflow */
SET_ERRNO(ERR_OVERFLOW);
SET_ERRNO(OVERFLOW);
goto error;
}
i64.ui64 += ch - '0';
......@@ -307,7 +307,7 @@ size_t redis_parser_execute(redis_parser_t *parser, redis_protocol_t **dst, cons
ADVANCE_AND_MOVE(integer_lf);
}
SET_ERRNO(ERR_INVALID_INT);
SET_ERRNO(INVALID_INT);
goto error;
}
......@@ -316,13 +316,13 @@ size_t redis_parser_execute(redis_parser_t *parser, redis_protocol_t **dst, cons
ADVANCE_AND_MOVE(integer_lf);
}
SET_ERRNO(ERR_EXPECTED_CR);
SET_ERRNO(EXPECTED_CR);
goto error;
}
STATE(integer_lf) {
if (*pos != '\n') {
SET_ERRNO(ERR_EXPECTED_LF);
SET_ERRNO(EXPECTED_LF);
goto error;
}
......@@ -398,7 +398,7 @@ size_t redis_parser_execute(redis_parser_t *parser, redis_protocol_t **dst, cons
ADVANCE_AND_MOVE(bulk_lf);
}
SET_ERRNO(ERR_EXPECTED_CR);
SET_ERRNO(EXPECTED_CR);
goto error;
}
......@@ -407,7 +407,7 @@ size_t redis_parser_execute(redis_parser_t *parser, redis_protocol_t **dst, cons
goto done;
}
SET_ERRNO(ERR_EXPECTED_LF);
SET_ERRNO(EXPECTED_LF);
goto error;
}
......@@ -441,7 +441,7 @@ size_t redis_parser_execute(redis_parser_t *parser, redis_protocol_t **dst, cons
goto done;
}
SET_ERRNO(ERR_EXPECTED_LF);
SET_ERRNO(EXPECTED_LF);
goto error;
}
}
......@@ -490,7 +490,7 @@ finalize:
error:
if (parser->err == ERRNO(OK)) {
SET_ERRNO(ERR_UNKNOWN);
SET_ERRNO(UNKNOWN);
}
return pos-buf;
......@@ -500,11 +500,11 @@ redis_protocol_t *redis_parser_root(redis_parser_t *parser) {
return &parser->stack[0];
}
redis_parser_err_t redis_parser_err(redis_parser_t *parser) {
enum redis_parser_errno redis_parser_err(redis_parser_t *parser) {
return parser->err;
}
const char *redis_parser_strerror(redis_parser_err_t err) {
const char *redis_parser_strerror(enum redis_parser_errno err) {
if (err < (sizeof(strerror_map)/sizeof(strerror_map[0])))
return strerror_map[err];
return NULL;
......
......@@ -34,21 +34,21 @@ struct redis_parser_callbacks_s {
redis_nil_cb on_nil;
};
#define REDIS_PARSER_ERRORS(_X) \
#define REDIS_PARSER_ERRNO_MAP(_X) \
_X(OK, NULL) /* = 0 in enum */ \
_X(ERR_UNKNOWN, "unknown") \
_X(ERR_CALLBACK, "callback failed") \
_X(ERR_INVALID_TYPE, "invalid type character") \
_X(ERR_INVALID_INT, "invalid integer character") \
_X(ERR_OVERFLOW, "overflow") \
_X(ERR_EXPECTED_CR, "expected \\r") \
_X(ERR_EXPECTED_LF, "expected \\n") \
#define _REDIS_PARSER_ERRNO_ENUM_GEN(code, description) REDIS_PARSER_##code,
typedef enum redis_parser_err_e {
REDIS_PARSER_ERRORS(_REDIS_PARSER_ERRNO_ENUM_GEN)
} redis_parser_err_t;
#undef _REDIS_PARSER_ERRNO_ENUM_GEN
_X(UNKNOWN, "unknown") \
_X(CALLBACK, "callback failed") \
_X(INVALID_TYPE, "invalid type character") \
_X(INVALID_INT, "invalid integer character") \
_X(OVERFLOW, "overflow") \
_X(EXPECTED_CR, "expected \\r") \
_X(EXPECTED_LF, "expected \\n") \
#define _REDIS_PARSER_ERRNO_GEN(code, description) RPE_##code,
enum redis_parser_errno {
REDIS_PARSER_ERRNO_MAP(_REDIS_PARSER_ERRNO_GEN)
};
#undef _REDIS_PARSER_ERRNO_GEN
struct redis_protocol_s {
unsigned char type; /* payload type */
......@@ -75,7 +75,7 @@ struct redis_parser_s {
/* private: parser state */
unsigned char state;
redis_parser_err_t err;
enum redis_parser_errno err;
/* private: temporary integer (integer reply, bulk length) */
struct redis_parser_int64_s {
......@@ -87,7 +87,7 @@ struct redis_parser_s {
void redis_parser_init(redis_parser_t *parser, const redis_parser_callbacks_t *callbacks);
size_t redis_parser_execute(redis_parser_t *parser, redis_protocol_t **dst, const char *buf, size_t len);
redis_protocol_t *redis_parser_root(redis_parser_t *parser);
redis_parser_err_t redis_parser_err(redis_parser_t *parser);
const char *redis_parser_strerror(redis_parser_err_t err);
enum redis_parser_errno redis_parser_err(redis_parser_t *parser);
const char *redis_parser_strerror(enum redis_parser_errno err);
#endif // _REDIS_PARSER_H
......@@ -400,42 +400,42 @@ void test_integer(redis_parser_t *p) {
RESET_PARSER_T(p);
assert_equal_size_t(redis_parser_execute(p, &res, buf, strlen(buf)), 2);
assert(res == NULL);
assert(redis_parser_err(p) == REDIS_PARSER_ERR_INVALID_INT);
assert(redis_parser_err(p) == RPE_INVALID_INT);
/* Signed zero, negative */
buf = ":-0\r\n";
RESET_PARSER_T(p);
assert_equal_size_t(redis_parser_execute(p, &res, buf, strlen(buf)), 2);
assert(res == NULL);
assert(redis_parser_err(p) == REDIS_PARSER_ERR_INVALID_INT);
assert(redis_parser_err(p) == RPE_INVALID_INT);
/* Start with 0 */
buf = ":0123\r\n";
RESET_PARSER_T(p);
assert_equal_size_t(redis_parser_execute(p, &res, buf, strlen(buf)), 2);
assert(res == NULL);
assert(redis_parser_err(p) == REDIS_PARSER_ERR_EXPECTED_CR);
assert(redis_parser_err(p) == RPE_EXPECTED_CR);
/* Start with non-digit */
buf = ":x123\r\n";
RESET_PARSER_T(p);
assert_equal_size_t(redis_parser_execute(p, &res, buf, strlen(buf)), 1);
assert(res == NULL);
assert(redis_parser_err(p) == REDIS_PARSER_ERR_INVALID_INT);
assert(redis_parser_err(p) == RPE_INVALID_INT);
/* Non-digit in the middle */
buf = ":12x3\r\n";
RESET_PARSER_T(p);
assert_equal_size_t(redis_parser_execute(p, &res, buf, strlen(buf)), 3);
assert(res == NULL);
assert(redis_parser_err(p) == REDIS_PARSER_ERR_INVALID_INT);
assert(redis_parser_err(p) == RPE_INVALID_INT);
/* Non-digit at the end */
buf = ":123x\r\n";
RESET_PARSER_T(p);
assert_equal_size_t(redis_parser_execute(p, &res, buf, strlen(buf)), 4);
assert(res == NULL);
assert(redis_parser_err(p) == REDIS_PARSER_ERR_INVALID_INT);
assert(redis_parser_err(p) == RPE_INVALID_INT);
/* Signed 64-bit maximum */
buf = ":9223372036854775807\r\n";
......@@ -451,7 +451,7 @@ void test_integer(redis_parser_t *p) {
RESET_PARSER_T(p);
assert_equal_size_t(redis_parser_execute(p, &res, buf, strlen(buf)), strlen(buf)-3);
assert(res == NULL);
assert(redis_parser_err(p) == REDIS_PARSER_ERR_OVERFLOW);
assert(redis_parser_err(p) == RPE_OVERFLOW);
/* Signed 64-bit minimum */
buf = ":-9223372036854775808\r\n";
......@@ -467,7 +467,7 @@ void test_integer(redis_parser_t *p) {
RESET_PARSER_T(p);
assert_equal_size_t(redis_parser_execute(p, &res, buf, strlen(buf)), strlen(buf)-3);
assert(res == NULL);
assert(redis_parser_err(p) == REDIS_PARSER_ERR_OVERFLOW);
assert(redis_parser_err(p) == RPE_OVERFLOW);
}
void test_nil(redis_parser_t *p) {
......@@ -535,7 +535,7 @@ void test_error(redis_parser_t *p) {
void test_abort_after_error(redis_parser_t *p) {
redis_protocol_t *res;
redis_parser_err_t err;
enum redis_parser_errno err;
assert_equal_size_t(redis_parser_execute(p, &res, "+ok\r", 4), 4);
assert(res == NULL);
......@@ -544,7 +544,7 @@ void test_abort_after_error(redis_parser_t *p) {
/* Test if the error matches what we expect */
err = redis_parser_err(p);
assert(err == REDIS_PARSER_ERR_EXPECTED_LF);
assert(err == RPE_EXPECTED_LF);
assert(strcmp("expected \\n", redis_parser_strerror(err)) == 0);
/* Test that the parser doesn't continue after an error */
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment