From 2e242d4f4742643ab637136945c20346d9fb3102 Mon Sep 17 00:00:00 2001 From: "tg(x)" <*@tg-x.net> Date: Mon, 21 Nov 2011 16:00:46 +0100 Subject: [PATCH] added @ op & _table type; number, index & keyword parsing --- include/psyc.h | 4 +- include/psyc/packet.h | 7 ++- include/psyc/parse.h | 102 +++++++++++++++++--------------- src/packet.c | 50 +++++++++++----- src/parse.c | 132 +++++++++++++++++++++--------------------- src/render.c | 2 +- src/variable.c | 3 +- 7 files changed, 165 insertions(+), 135 deletions(-) diff --git a/include/psyc.h b/include/psyc.h index 351de41..e04b030 100644 --- a/include/psyc.h +++ b/include/psyc.h @@ -70,6 +70,7 @@ typedef enum { PSYC_TYPE_UNKNOWN, PSYC_TYPE_AMOUNT, PSYC_TYPE_COLOR, + PSYC_TYPE_COUNTER, PSYC_TYPE_DATE, PSYC_TYPE_DEGREE, PSYC_TYPE_ENTITY, @@ -78,8 +79,9 @@ typedef enum { PSYC_TYPE_LIST, PSYC_TYPE_NICK, PSYC_TYPE_PAGE, - PSYC_TYPE_UNIFORM, + PSYC_TYPE_TABLE, PSYC_TYPE_TIME, + PSYC_TYPE_UNIFORM, } PsycType; /** diff --git a/include/psyc/packet.h b/include/psyc/packet.h index 5c5fb18..24429a0 100644 --- a/include/psyc/packet.h +++ b/include/psyc/packet.h @@ -57,6 +57,7 @@ typedef enum { PSYC_OPERATOR_ASSIGN = '=', PSYC_OPERATOR_AUGMENT = '+', PSYC_OPERATOR_DIMINISH = '-', + PSYC_OPERATOR_UPDATE = '@', PSYC_OPERATOR_QUERY = '?', } PsycOperator; @@ -92,13 +93,13 @@ typedef struct { typedef struct { PsycHeader routing; ///< Routing header. PsycHeader entity; ///< Entity header. - char stateop; ///< State operation. @see PsycStateOp PsycString method; ///< Contains the method. PsycString data; ///< Contains the data. PsycString content; ///< Contains the whole content. - size_t routingLength; ///< Length of routing part. - size_t contentLength; ///< Length of content part. + size_t routinglen; ///< Length of routing part. + size_t contentlen; ///< Length of content part. size_t length; ///< Total length of packet. + PsycStateOp stateop; ///< State operation. @see PsycStateOp PsycPacketFlag flag; ///< Packet flag. } PsycPacket; diff --git a/include/psyc/parse.h b/include/psyc/parse.h index 2572c0e..93f64d3 100644 --- a/include/psyc/parse.h +++ b/include/psyc/parse.h @@ -260,13 +260,13 @@ typedef struct { uint8_t flags; ///< Flags for the parser, see PsycParseFlag. PsycPart part; ///< Part of the packet being parsed currently. - size_t routingLength; ///< Length of routing part parsed so far. - size_t contentParsed; ///< Number of bytes parsed from the content so far. - size_t contentLength; ///< Expected length of the content. - PsycBool contentLengthFound;///< Is there a length given for this packet? - size_t valueParsed; ///< Number of bytes parsed from the value so far. - size_t valueLength; ///< Expected length of the value. - PsycBool valueLengthFound; ///< Is there a length given for this modifier? + size_t routinglen; ///< Length of routing part parsed so far. + size_t content_parsed; ///< Number of bytes parsed from the content so far. + size_t contentlen; ///< Expected length of the content. + PsycBool contentlen_found; ///< Is there a length given for this packet? + size_t value_parsed; ///< Number of bytes parsed from the value so far. + size_t valuelen; ///< Expected length of the value. + PsycBool valuelen_found; ///< Is there a length given for this modifier? } PsycParseState; /** @@ -280,8 +280,8 @@ typedef struct { char term; ///< Terminator character at the end. uint8_t term_set; ///< Look for terminator. - size_t elemParsed; ///< Number of bytes parsed from the elem so far. - size_t elemLength; ///< Expected length of the elem. + size_t elem_parsed; ///< Number of bytes parsed from the elem so far. + size_t elemlen; ///< Expected length of the elem. } PsycParseListState; /** @@ -326,14 +326,14 @@ psyc_parse_state_init (PsycParseState *state, uint8_t flags) * @see PsycString */ static inline void -psyc_parse_buffer_set (PsycParseState *state, const char *buffer, size_t length) +psyc_parse_buffer_set (PsycParseState *state, char *buffer, size_t length) { state->buffer = (PsycString) {length, buffer}; state->cursor = 0; if (state->flags & PSYC_PARSE_START_AT_CONTENT) { - state->contentLength = length; - state->contentLengthFound = PSYC_TRUE; + state->contentlen = length; + state->contentlen_found = PSYC_TRUE; } } @@ -385,25 +385,25 @@ psyc_parse_table_buffer_set (PsycParseTableState *state, char *buffer, size_t le static inline size_t psyc_parse_content_length (PsycParseState *state) { - return state->contentLength; + return state->contentlen; } static inline PsycBool psyc_parse_content_length_found (PsycParseState *state) { - return state->contentLengthFound; + return state->contentlen_found; } static inline size_t psyc_parse_value_length (PsycParseState *state) { - return state->valueLength; + return state->valuelen; } static inline PsycBool psyc_parse_value_length_found (PsycParseState *state) { - return state->valueLengthFound; + return state->valuelen_found; } static inline size_t @@ -473,14 +473,14 @@ psyc_parse_list (PsycParseListState *state, PsycString *elem); PsycParseTableRC psyc_parse_table (PsycParseTableState *state, PsycString *elem); -static inline PsycRC -psyc_parse_number (const char *value, size_t len, int64_t *n) +static inline size_t +psyc_parse_int (const char *value, size_t len, int64_t *n) { size_t c = 0; uint8_t neg = 0; if (!value) - return PSYC_ERROR; + return c; if (value[0] == '-') neg = ++c; @@ -490,61 +490,54 @@ psyc_parse_number (const char *value, size_t len, int64_t *n) *n = 10 * *n + (value[c++] - '0'); if (c != len) - return PSYC_ERROR; + return c; if (neg) *n = 0 - *n; - return PSYC_OK; + return c; } -static inline PsycRC -psyc_parse_number_unsigned (const char *value, size_t len, uint64_t *n) +static inline size_t +psyc_parse_uint (const char *value, size_t len, uint64_t *n) { size_t c = 0; if (!value) - return PSYC_ERROR; + return c; *n = 0; while (c < len && value[c] >= '0' && value[c] <= '9') *n = 10 * *n + (value[c++] - '0'); - return c == len ? PSYC_OK : PSYC_ERROR; + return c; } -static inline PsycRC -psyc_parse_time (const char *value, size_t len, time_t *t) +static inline size_t +psyc_parse_index (const char *value, size_t len, int64_t *n) { - return psyc_parse_number(value, len, t); -} - -static inline PsycRC -psyc_parse_date (const char *value, size_t len, time_t *t) -{ - if (psyc_parse_number(value, len, t)) { - *t += PSYC_EPOCH; - return PSYC_OK; - } - return PSYC_ERROR; + if (!value || len == 0 || value[0] != '#') + return 0; + return psyc_parse_int(value + 1, len, n) + 1; } /** * Determines if the argument is a glyph. * Glyphs are: : = + - ? ! */ -static inline char -psyc_is_glyph (uint8_t g) +static inline PsycBool +psyc_is_glyph (char g) { switch (g) { case ':': case '=': case '+': case '-': + case '@': case '?': case '!': - return 1; + return PSYC_TRUE; default: - return 0; + return PSYC_FALSE; } } @@ -552,7 +545,7 @@ psyc_is_glyph (uint8_t g) * Determines if the argument is numeric. */ static inline char -psyc_is_numeric (uint8_t c) +psyc_is_numeric (char c) { return c >= '0' && c <= '9'; } @@ -561,7 +554,7 @@ psyc_is_numeric (uint8_t c) * Determines if the argument is alphabetic. */ static inline char -psyc_is_alpha (uint8_t c) +psyc_is_alpha (char c) { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); } @@ -570,7 +563,7 @@ psyc_is_alpha (uint8_t c) * Determines if the argument is alphanumeric. */ static inline char -psyc_is_alpha_numeric (uint8_t c) +psyc_is_alpha_numeric (char c) { return psyc_is_alpha(c) || psyc_is_numeric(c); } @@ -580,7 +573,7 @@ psyc_is_alpha_numeric (uint8_t c) * Keyword characters are: alphanumeric and _ */ static inline char -psyc_is_kw_char (uint8_t c) +psyc_is_kw_char (char c) { return psyc_is_alpha_numeric(c) || c == '_'; } @@ -590,7 +583,7 @@ psyc_is_kw_char (uint8_t c) * Name characters are: see opaque_part in RFC 2396 */ static inline char -psyc_is_name_char (uint8_t c) +psyc_is_name_char (char c) { return psyc_is_alpha(c) || (c >= '$' && c <= ';') || c == '_' || c == '!' || c == '?' || c == '=' || c == '@' || c == '~'; @@ -601,11 +594,24 @@ psyc_is_name_char (uint8_t c) * Hostname characters are: alphanumeric and - */ static inline char -psyc_is_host_char (uint8_t c) +psyc_is_host_char (char c) { return psyc_is_alpha_numeric(c) || c == '.' || c == '-'; } +/** + * Parse variable name or method name. + * It should contain one or more keyword characters. + * @return Number of characters parsed. + */ +static inline size_t +psyc_parse_keyword (const char *data, size_t len) +{ + size_t c = 0; + while (c < len && psyc_is_kw_char(data[c++])); + return c > 0 ? c - 1 : 0; +} + /** @} */ // end of parse group #endif diff --git a/src/packet.c b/src/packet.c index d637e70..6626812 100644 --- a/src/packet.c +++ b/src/packet.c @@ -95,39 +95,39 @@ inline size_t psyc_packet_length_set (PsycPacket * p) { size_t i; - p->routingLength = 0; - p->contentLength = 0; + p->routinglen = 0; + p->contentlen = 0; // add routing header length for (i = 0; i < p->routing.lines; i++) - p->routingLength += psyc_modifier_length(&(p->routing.modifiers[i])); + p->routinglen += psyc_modifier_length(&(p->routing.modifiers[i])); if (p->content.length) - p->contentLength = p->content.length; + p->contentlen = p->content.length; else { // add state operation if (p->stateop != PSYC_STATE_NOOP) - p->contentLength += 2; // op\n + p->contentlen += 2; // op\n // add entity header length for (i = 0; i < p->entity.lines; i++) - p->contentLength += psyc_modifier_length(&(p->entity.modifiers[i])); + p->contentlen += psyc_modifier_length(&(p->entity.modifiers[i])); // add length of method, data & delimiter if (p->method.length) - p->contentLength += p->method.length + 1; // method\n + p->contentlen += p->method.length + 1; // method\n if (p->data.length) - p->contentLength += p->data.length + 1; // data\n + p->contentlen += p->data.length + 1; // data\n } // set total length: routing-header content |\n - p->length = p->routingLength + p->contentLength + 2; + p->length = p->routinglen + p->contentlen + 2; - if (p->contentLength > 0 || p->flag == PSYC_PACKET_NEED_LENGTH) + if (p->contentlen > 0 || p->flag == PSYC_PACKET_NEED_LENGTH) p->length++; // add \n at the start of the content part if (p->flag == PSYC_PACKET_NEED_LENGTH) // add length of length if needed - p->length += psyc_num_length(p->contentLength); + p->length += psyc_num_length(p->contentlen); return p->length; } @@ -140,8 +140,18 @@ psyc_packet_init (PsycPacket * p, char *data, size_t datalen, char stateop, PsycPacketFlag flag) { - *p = (PsycPacket) {{routinglen, routing}, {entitylen, entity}, stateop, - {methodlen, method}, {datalen, data}, {0, 0}, 0, 0, flag}; + *p = (PsycPacket) { + .routing = {routinglen, routing}, + .entity = {entitylen, entity}, + .method = {methodlen, method}, + .data = {datalen, data}, + .content = {0, 0}, + .routinglen = 0, + .contentlen = 0, + .length = 0, + .stateop = stateop, + .flag = flag, + }; if (flag == PSYC_PACKET_CHECK_LENGTH) // find out if it needs length p->flag = psyc_packet_length_check(p); @@ -155,8 +165,18 @@ psyc_packet_init_raw (PsycPacket * p, char *content, size_t contentlen, PsycPacketFlag flag) { - *p = (PsycPacket) {{routinglen, routing}, {0, 0}, 0, {0, 0}, {0, 0}, - {contentlen, content}, 0, 0, flag}; + *p = (PsycPacket) { + .routing = {routinglen, routing}, + .entity = {0, 0}, + .method = {0, 0}, + .data = {0, 0}, + .content = {contentlen, content}, + .routinglen = 0, + .contentlen = 0, + .length = 0, + .stateop = 0, + .flag = flag, + }; if (flag == PSYC_PACKET_CHECK_LENGTH) // find out if it needs length p->flag = psyc_packet_length_check(p); diff --git a/src/parse.c b/src/parse.c index 27af0a5..0ccf9c5 100644 --- a/src/parse.c +++ b/src/parse.c @@ -29,7 +29,7 @@ typedef enum { * @return PARSE_ERROR or PARSE_SUCCESS */ static inline ParseRC -psyc_parse_keyword (PsycParseState *state, PsycString *name) +parse_keyword (PsycParseState *state, PsycString *name) { name->data = state->buffer.data + state->cursor; name->length = 0; @@ -86,7 +86,7 @@ psyc_parse_modifier (PsycParseState *state, char *oper, *oper = *(state->buffer.data + state->cursor); ADVANCE_CURSOR_OR_RETURN(PSYC_PARSE_INSUFFICIENT); - ParseRC ret = psyc_parse_keyword(state, name); + ParseRC ret = parse_keyword(state, name); if (ret == PARSE_ERROR) return PSYC_PARSE_ERROR_MOD_NAME; else if (ret != PARSE_SUCCESS) @@ -94,9 +94,9 @@ psyc_parse_modifier (PsycParseState *state, char *oper, size_t length = 0; value->length = 0; - state->valueLength = 0; - state->valueLengthFound = 0; - state->valueParsed = 0; + state->valuelen = 0; + state->valuelen_found = 0; + state->value_parsed = 0; // Parse the value. // If we're in the content part check if it's a binary var. @@ -106,13 +106,13 @@ psyc_parse_modifier (PsycParseState *state, char *oper, ADVANCE_CURSOR_OR_RETURN(PSYC_PARSE_INSUFFICIENT); if (psyc_is_numeric(state->buffer.data[state->cursor])) { - state->valueLengthFound = 1; + state->valuelen_found = 1; do { length = 10 * length + state->buffer.data[state->cursor] - '0'; ADVANCE_CURSOR_OR_RETURN(PSYC_PARSE_INSUFFICIENT); } while (psyc_is_numeric(state->buffer.data[state->cursor])); - state->valueLength = length; + state->valuelen = length; } else return PSYC_PARSE_ERROR_MOD_LEN; @@ -124,8 +124,8 @@ psyc_parse_modifier (PsycParseState *state, char *oper, return length ? PARSE_INCOMPLETE : PARSE_SUCCESS; // if length=0 we're done ret = - psyc_parse_binary_value(state, value, &(state->valueLength), - &(state->valueParsed)); + psyc_parse_binary_value(state, value, &(state->valuelen), + &(state->value_parsed)); if (ret == PARSE_INCOMPLETE) return ret; @@ -170,18 +170,18 @@ psyc_parse (PsycParseState *state, char *oper, switch (state->part) { case PSYC_PART_RESET: // New packet starts here, reset state. - state->valueParsed = 0; - state->valueLength = 0; - state->valueLengthFound = 0; - state->routingLength = 0; - state->contentParsed = 0; - state->contentLength = 0; - state->contentLengthFound = 0; + state->value_parsed = 0; + state->valuelen = 0; + state->valuelen_found = 0; + state->routinglen = 0; + state->content_parsed = 0; + state->contentlen = 0; + state->contentlen_found = 0; state->part = PSYC_PART_ROUTING; // fall thru case PSYC_PART_ROUTING: - if (state->routingLength > 0) { + if (state->routinglen > 0) { if (state->buffer.data[state->cursor] != '\n') return PSYC_PARSE_ERROR_MOD_NL; ADVANCE_CURSOR_OR_RETURN(PSYC_PARSE_INSUFFICIENT); @@ -192,7 +192,7 @@ psyc_parse (PsycParseState *state, char *oper, if (psyc_is_glyph(state->buffer.data[state->cursor])) { // it is a glyph, so a variable starts here ret = psyc_parse_modifier(state, oper, name, value); - state->routingLength += state->cursor - pos; + state->routinglen += state->cursor - pos; return ret == PARSE_SUCCESS ? PSYC_PARSE_ROUTING : ret; } else { // not a glyph state->part = PSYC_PART_LENGTH; @@ -203,12 +203,12 @@ psyc_parse (PsycParseState *state, char *oper, case PSYC_PART_LENGTH: // End of header, content starts with an optional length then a NL if (psyc_is_numeric(state->buffer.data[state->cursor])) { - state->contentLengthFound = 1; - state->contentLength = 0; + state->contentlen_found = 1; + state->contentlen = 0; do { - state->contentLength = - 10 * state->contentLength + + state->contentlen = + 10 * state->contentlen + state->buffer.data[state->cursor] - '0'; ADVANCE_CURSOR_OR_RETURN(PSYC_PARSE_INSUFFICIENT); } while (psyc_is_numeric(state->buffer.data[state->cursor])); @@ -226,7 +226,7 @@ psyc_parse (PsycParseState *state, char *oper, state->part = PSYC_PART_CONTENT; } else { // Not start of content, this must be the end. // If we have a length then it should've been followed by a \n - if (state->contentLengthFound) + if (state->contentlen_found) return PSYC_PARSE_ERROR_LENGTH; state->part = PSYC_PART_END; @@ -239,10 +239,10 @@ psyc_parse (PsycParseState *state, char *oper, case PSYC_PART_CONTENT: // In case of an incomplete binary variable resume parsing it. - if (state->valueParsed < state->valueLength) { - ret = psyc_parse_binary_value(state, value, &(state->valueLength), - &(state->valueParsed)); - state->contentParsed += value->length; + if (state->value_parsed < state->valuelen) { + ret = psyc_parse_binary_value(state, value, &(state->valuelen), + &(state->value_parsed)); + state->content_parsed += value->length; if (ret == PARSE_INCOMPLETE) return PSYC_PARSE_ENTITY_CONT; @@ -252,7 +252,7 @@ psyc_parse (PsycParseState *state, char *oper, pos = state->cursor; - if (state->contentParsed > 0) { + if (state->content_parsed > 0) { if (state->buffer.data[state->cursor] != '\n') return PSYC_PARSE_ERROR_MOD_NL; ADVANCE_CURSOR_OR_RETURN(PSYC_PARSE_INSUFFICIENT); @@ -264,15 +264,15 @@ psyc_parse (PsycParseState *state, char *oper, // method does not start with a glyph. if (psyc_is_glyph(state->buffer.data[state->cursor])) { ADVANCE_CURSOR_OR_RETURN(PSYC_PARSE_INSUFFICIENT); - if (state->contentParsed == 0 + if (state->content_parsed == 0 && state->buffer.data[state->cursor] == '\n') { *oper = *(state->buffer.data + state->cursor - 1); switch (*oper) { case PSYC_STATE_RESYNC: - state->contentParsed += 2; + state->content_parsed += 2; return PSYC_PARSE_STATE_RESYNC; case PSYC_STATE_RESET: - state->contentParsed += 2; + state->content_parsed += 2; return PSYC_PARSE_STATE_RESET; default: return PSYC_PARSE_ERROR_MOD_NAME; @@ -281,7 +281,7 @@ psyc_parse (PsycParseState *state, char *oper, state->cursor--; ret = psyc_parse_modifier(state, oper, name, value); - state->contentParsed += state->cursor - pos; + state->content_parsed += state->cursor - pos; if (ret == PARSE_INCOMPLETE) return PSYC_PARSE_ENTITY_START; @@ -290,7 +290,7 @@ psyc_parse (PsycParseState *state, char *oper, return ret; } else { - state->contentParsed += state->cursor - pos; + state->content_parsed += state->cursor - pos; state->startc = state->cursor; state->part = PSYC_PART_METHOD; // fall thru @@ -298,7 +298,7 @@ psyc_parse (PsycParseState *state, char *oper, case PSYC_PART_METHOD: pos = state->cursor; - ret = psyc_parse_keyword(state, name); + ret = parse_keyword(state, name); if (ret == PARSE_INSUFFICIENT) return ret; @@ -307,15 +307,15 @@ psyc_parse (PsycParseState *state, char *oper, if (state->buffer.data[state->cursor] != '\n') return PSYC_PARSE_ERROR_METHOD; - state->valueLengthFound = 0; - state->valueParsed = 0; - state->valueLength = 0; + state->valuelen_found = 0; + state->value_parsed = 0; + state->valuelen = 0; - if (state->contentLengthFound) { - // Length found, set start position to the beginning of data. + if (state->contentlen_found) { + // len found, set start position to the beginning of data. state->cursor++; state->startc = state->cursor; - state->contentParsed += state->cursor - pos; + state->content_parsed += state->cursor - pos; state->part = PSYC_PART_DATA; } else { // Otherwise keep it at the beginning of method. ADVANCE_CURSOR_OR_RETURN(PSYC_PARSE_INSUFFICIENT); @@ -332,25 +332,25 @@ psyc_parse (PsycParseState *state, char *oper, value->data = state->buffer.data + state->cursor; value->length = 0; - if (state->contentLengthFound) { // We know the length of the packet. - if (!state->valueLengthFound) { // start of data - state->valueLengthFound = 1; - state->valueLength = state->contentLength - state->contentParsed; - if (state->valueLength && !(state->flags & PSYC_PARSE_ROUTING_ONLY)) - state->valueLength--; // \n at the end is not part of data + if (state->contentlen_found) { // We know the length of the packet. + if (!state->valuelen_found) { // start of data + state->valuelen_found = 1; + state->valuelen = state->contentlen - state->content_parsed; + if (state->valuelen && !(state->flags & PSYC_PARSE_ROUTING_ONLY)) + state->valuelen--; // \n at the end is not part of data } - if (state->valueParsed < state->valueLength) { - ret = psyc_parse_binary_value(state, value, &(state->valueLength), - &(state->valueParsed)); - state->contentParsed += value->length; + if (state->value_parsed < state->valuelen) { + ret = psyc_parse_binary_value(state, value, &(state->valuelen), + &(state->value_parsed)); + state->content_parsed += value->length; if (ret == PARSE_INCOMPLETE) - return state->valueParsed == value->length + return state->value_parsed == value->length ? PSYC_PARSE_BODY_START : PSYC_PARSE_BODY_CONT; } state->part = PSYC_PART_END; - return state->valueLength == value->length ? + return state->valuelen == value->length ? PSYC_PARSE_BODY : PSYC_PARSE_BODY_END; } else { // Search for the terminator. size_t datac = state->cursor; // start of data @@ -373,7 +373,7 @@ psyc_parse (PsycParseState *state, char *oper, if (state->flags & PSYC_PARSE_ROUTING_ONLY) value->length++; - state->contentParsed += state->cursor - pos; + state->content_parsed += state->cursor - pos; state->cursor += nl; state->part = PSYC_PART_END; return PSYC_PARSE_BODY; @@ -387,15 +387,15 @@ psyc_parse (PsycParseState *state, char *oper, case PSYC_PART_END: PSYC_PART_END: // if data was not empty next is the \n at the end of data - if (state->contentLengthFound && state->valueLengthFound - && state->valueLength && !(state->flags & PSYC_PARSE_ROUTING_ONLY)) { - state->valueLength = 0; - state->valueLengthFound = 0; + if (state->contentlen_found && state->valuelen_found + && state->valuelen && !(state->flags & PSYC_PARSE_ROUTING_ONLY)) { + state->valuelen = 0; + state->valuelen_found = 0; if (state->buffer.data[state->cursor] != '\n') return PSYC_PARSE_ERROR_END; - state->contentParsed++; + state->content_parsed++; state->cursor++; } // End of packet, at this point we have already passed a \n @@ -465,12 +465,12 @@ psyc_parse_list (PsycParseListState *state, PsycString *elem) state->cursor++; return PSYC_PARSE_LIST_ELEM; } else { // binary list - if (!(state->elemParsed < state->elemLength)) { + if (!(state->elem_parsed < state->elemlen)) { // Element starts with a number. if (psyc_is_numeric(state->buffer.data[state->cursor])) { do { - state->elemLength = - 10 * state->elemLength + + state->elemlen = + 10 * state->elemlen + state->buffer.data[state->cursor] - '0'; ADVANCE_CURSOR_OR_RETURN(PSYC_PARSE_LIST_INCOMPLETE); } while (psyc_is_numeric(state->buffer.data[state->cursor])); @@ -483,16 +483,16 @@ psyc_parse_list (PsycParseListState *state, PsycString *elem) state->cursor++; elem->data = state->buffer.data + state->cursor; elem->length = 0; - state->elemParsed = 0; + state->elem_parsed = 0; } // Start or resume parsing the binary data - if (state->elemParsed < state->elemLength) { + if (state->elem_parsed < state->elemlen) { if (PARSE_INCOMPLETE == psyc_parse_binary_value((PsycParseState*)state, - elem, &state->elemLength, - &state->elemParsed)) + elem, &state->elemlen, + &state->elem_parsed)) return PSYC_PARSE_LIST_INCOMPLETE; - state->elemLength = 0; + state->elemlen = 0; if (state->cursor >= state->buffer.length) return PSYC_PARSE_LIST_END; diff --git a/src/render.c b/src/render.c index 5fefbb0..72508cc 100644 --- a/src/render.c +++ b/src/render.c @@ -84,7 +84,7 @@ psyc_render (PsycPacket * packet, char *buffer, size_t buflen) // add length if needed if (packet->flag == PSYC_PACKET_NEED_LENGTH) - cur += itoa(packet->contentLength, buffer + cur, 10); + cur += itoa(packet->contentlen, buffer + cur, 10); if (packet->flag == PSYC_PACKET_NEED_LENGTH || packet->content.length || packet->stateop || packet->entity.lines diff --git a/src/variable.c b/src/variable.c index 3d0833d..e762b74 100644 --- a/src/variable.c +++ b/src/variable.c @@ -38,8 +38,9 @@ const PsycDictInt psyc_var_types[] = { {PSYC_C2STRI("_list"), PSYC_TYPE_LIST}, {PSYC_C2STRI("_nick"), PSYC_TYPE_NICK}, {PSYC_C2STRI("_page"), PSYC_TYPE_PAGE}, - {PSYC_C2STRI("_uniform"), PSYC_TYPE_UNIFORM}, + {PSYC_C2STRI("_table"), PSYC_TYPE_TABLE}, {PSYC_C2STRI("_time"), PSYC_TYPE_TIME}, + {PSYC_C2STRI("_uniform"), PSYC_TYPE_UNIFORM}, }; const size_t psyc_routing_vars_num = PSYC_NUM_ELEM(psyc_routing_vars);