From 260bba0c461528c61f6c11f708c7402d5b6f4955 Mon Sep 17 00:00:00 2001 From: "tg(x)" <*@tg-x.net> Date: Mon, 31 Oct 2011 20:04:16 +0100 Subject: [PATCH] refactoring - renamed functions --- .gitignore | 25 ++-- d/include/psyc/common.d | 8 +- d/include/psyc/packet.d | 43 ++---- d/include/psyc/parse.d | 2 +- d/include/psyc/render.d | 14 +- doc/renames | 66 +++++++++ include/psyc.h | 82 +++-------- include/psyc/packet.h | 79 +++++------ include/psyc/parse.h | 144 ++++++-------------- include/psyc/render.h | 14 +- include/psyc/text.h | 38 ++---- include/psyc/uniform.h | 4 +- include/psyc/variable.h | 37 +++++ pike/psyc.cmod | 52 +++---- src/lib.h | 2 - src/match.c | 64 ++++++++- src/packet.c | 89 ++++-------- src/parse.c | 44 +++--- src/psyc_parser_cb.h | 4 +- src/render.c | 8 +- src/uniform.c | 17 +-- src/variable.c | 134 +++--------------- test/Makefile | 72 +++++----- test/getVarType.c | 21 --- test/isRoutingVar.c | 39 ------ test/{testJson.c => test_json.c} | 0 test/{testJsonGlib.c => test_json_glib.c} | 0 test/{testMatch.c => test_match.c} | 0 test/{testParser.c => test_parser.c} | 17 +-- test/{testPsyc.c => test_psyc.c} | 32 ++--- test/{testPsycSpeed.c => test_psyc_speed.c} | 8 +- test/{testRender.c => test_render.c} | 26 ++-- test/{testStrlen.c => test_strlen.c} | 0 test/{testText.c => test_text.c} | 6 +- test/{parseUniform.c => uniform_parse.c} | 10 +- test/var_is_routing.c | 39 ++++++ test/var_type.c | 21 +++ 37 files changed, 570 insertions(+), 691 deletions(-) create mode 100644 doc/renames create mode 100644 include/psyc/variable.h delete mode 100644 test/getVarType.c delete mode 100644 test/isRoutingVar.c rename test/{testJson.c => test_json.c} (100%) rename test/{testJsonGlib.c => test_json_glib.c} (100%) rename test/{testMatch.c => test_match.c} (100%) rename test/{testParser.c => test_parser.c} (84%) rename test/{testPsyc.c => test_psyc.c} (90%) rename test/{testPsycSpeed.c => test_psyc_speed.c} (88%) rename test/{testRender.c => test_render.c} (76%) rename test/{testStrlen.c => test_strlen.c} (100%) rename test/{testText.c => test_text.c} (92%) rename test/{parseUniform.c => uniform_parse.c} (86%) create mode 100644 test/var_is_routing.c create mode 100644 test/var_type.c diff --git a/.gitignore b/.gitignore index 3459b4b..d3efafe 100644 --- a/.gitignore +++ b/.gitignore @@ -7,18 +7,19 @@ d/doc/html d/doc/latex d/doc/man src/match -test/testMatch -test/testParser -test/testRender -test/testPsyc -test/testPsycSpeed -test/testJson -test/testJsonGlib -test/testStrlen -test/testText -test/isRoutingVar -test/getVarType -test/parseUniform +test/test_list +test/test_match +test/test_parser +test/test_render +test/test_psyc +test/test_psyc_speed +test/test_json +test/test_json_glib +test/test_strlen +test/test_text +test/var_is_routing +test/var_type +test/uniform_parse perl/*.c perl/*.so diff --git a/d/include/psyc/common.d b/d/include/psyc/common.d index ecaba77..21938f9 100644 --- a/d/include/psyc/common.d +++ b/d/include/psyc/common.d @@ -97,19 +97,19 @@ extern (C) MatchVar varTypes[]; /** * Get the type of variable name. */ -Bool psyc_isRoutingVar (char[]* name); +Bool psyc_var_is_routing (char* name, size_t len); bool isRoutingVar (char[] name) { - return psyc_isRoutingVar(&name); + return psyc_var_is_routing(name.ptr, name.length); //FIXME } /** * Get the type of variable name. */ -Type psyc_getVarType(char *name, size_t len); +Type psyc_var_type(char *name, size_t len); -alias psyc_getVarType getVarType; +alias psyc_var_type getVarType; /** * Checks if long keyword string inherits from short keyword string. diff --git a/d/include/psyc/packet.d b/d/include/psyc/packet.d index 3846b3f..da544e0 100644 --- a/d/include/psyc/packet.d +++ b/d/include/psyc/packet.d @@ -96,7 +96,7 @@ struct Modifier size_t length ( ) { - return psyc_getModifierLength (this); + return psyc_modifier_length (this); } private ModifierFlag checkLength ( ubyte[] value ) @@ -142,24 +142,24 @@ struct Packet char[] method, ubyte[] data, PacketFlag flag = PacketFlag.CHECK_LENGTH) { - return psyc_newPacket (&routing, &entity, cast(ubyte[]*)&method, &data, flag); + return psyc_packet_new(&routing, &entity, cast(ubyte[]*)&method, &data, flag); // FIXME } static Packet opCall (Modifier[] routing, ubyte[] content, PacketFlag flag = PacketFlag.CHECK_LENGTH) { - return psyc_newRawPacket (&routing, &content, flag); + return psyc_packet_new_raw(&routing, &content, flag); // FIXME } size_t length ( ) { - psyc_setPacketLength(this); + psyc_packet_length_set(this); return this._length; } ubyte[] render ( ubyte[] buffer ) { - psyc_setPacketLength(this); + psyc_packet_length_set(this); with (RenderRC) switch (psyc_render(this, buffer.ptr, buffer.length)) @@ -189,56 +189,43 @@ struct Packet /** * \internal */ -private size_t psyc_getModifierLength (Modifier *m); +private size_t psyc_modifier_length (Modifier *m); /** * \internal * Check if a list needs length. */ -ListFlag psyc_checkListLength (List *list); +ListFlag psyc_list_length_check (List *list); /** * \internal * Get the total length of a list when rendered. */ -ListFlag psyc_getListLength (List *list); +ListFlag psyc_list_length (List *list); /** * \internal * Check if a packet needs length. */ -PacketFlag psyc_checkPacketLength (Packet *p); +PacketFlag psyc_packet_length_check (Packet *p); /** * Calculate and set the rendered length of packet parts and total packet length. */ -private size_t psyc_setPacketLength (Packet *p); +private size_t psyc_packet_length_set (Packet *p); /** Create new list. */ -List psyc_newList (String *elems, size_t num_elems, ListFlag flag); +List psyc_list_new (String *elems, size_t num_elems, ListFlag flag); /** Create new packet. */ -private Packet psyc_newPacket (Modifier[]* routing, - Modifier[]* entity, - String *method, String *data, - PacketFlag flag); - - - - -/** Create new packet. */ -Packet psyc_newPacket2 (Modifier *routing, size_t routinglen, +Packet psyc_packet_new (Modifier *routing, size_t routinglen, Modifier *entity, size_t entitylen, char *method, size_t methodlen, char *data, size_t datalen, PacketFlag flag); /** Create new packet with raw content. */ -Packet psyc_newRawPacket (Modifier[] *routing, ubyte[] *content, - PacketFlag flag); - -/** Create new packet with raw content. */ -Packet psyc_newRawPacket2 (Modifier *routing, size_t routinglen, - char *content, size_t contentlen, - PacketFlag flag); +Packet psyc_packet_new_raw (Modifier *routing, size_t routinglen, + char *content, size_t contentlen, + PacketFlag flag); diff --git a/d/include/psyc/parse.d b/d/include/psyc/parse.d index ac5be77..7d21714 100644 --- a/d/include/psyc/parse.d +++ b/d/include/psyc/parse.d @@ -316,6 +316,6 @@ ParseRC psyc_parse(ParseState* state, char* oper, String* name, String* value); /** * List value parser. */ -ParseListRC psyc_parseList(ParseListState* state, String *name, String* value, String* elem); +ParseListRC psyc_parse_list(ParseListState* state, String *name, String* value, String* elem); /** @} */ // end of parsing group diff --git a/d/include/psyc/render.d b/d/include/psyc/render.d index c9e248a..d1dd0e4 100644 --- a/d/include/psyc/render.d +++ b/d/include/psyc/render.d @@ -25,7 +25,7 @@ enum RenderRC } ; /** - * Return codes for psyc_renderList. + * Return codes for psyc_render_list. */ enum RenderListRC { @@ -41,20 +41,18 @@ enum RenderListRC * The packet structure should contain the packet parts, either routing, entity, * method & data, or routing & content when rendering raw content. * It should also contain the contentLength & total length of the packet, - * you can use psyc_setPacketLength() for calculating & setting these values. + * you can use psyc_packet_length_set() for calculating & setting these values. * This function renders packet->length bytes to the buffer, * if buflen is less than that an error is returned. * - * @see psyc_newPacket - * @see psyc_newPacket2 - * @see psyc_newRawPacket - * @see psyc_newRawPacket2 - * @see psyc_setPacketLength + * @see psyc_packet_new + * @see psyc_packet_new_raw + * @see psyc_packet_length_set */ RenderRC psyc_render (Packet *packet, ubyte *buffer, size_t buflen); /** * Render a PSYC list into a buffer. */ -RenderListRC psyc_renderList (List *list, ubyte *buffer, size_t buflen); +RenderListRC psyc_render_list (List *list, ubyte *buffer, size_t buflen); diff --git a/doc/renames b/doc/renames new file mode 100644 index 0000000..c2ed1da --- /dev/null +++ b/doc/renames @@ -0,0 +1,66 @@ +psyc_newString psyc_string_new +psyc_routingVars psyc_routing_vars +psyc_routingVarsNum psyc_routing_vars_num +psyc_varTypes psyc_var_types +psyc_varTypesNum psyc_var_types_num +psyc_isRoutingVar - +psyc_isRoutingVar2 psyc_var_is_routing +psyc_isListVar - +psyc_isListVar2 psyc_var_is_list +psyc_getVarType - +psyc_getVarType2 psyc_var_type + +psyc_newModifier - +psyc_newModifier2 psyc_modifier_new +psyc_getModifierLength psyc_modifier_length +psyc_checkModifierLength psyc_modifier_length_check +psyc_getListLength psyc_list_length +psyc_checkListLength psyc_list_length_check +psyc_getNumLength psyc_num_length +psyc_newPacket - +psyc_newPacket2 psyc_packet_new +psyc_newRawPacket - +psyc_newRawPacket2 psyc_packet_new_raw +psyc_checkPacketLength psyc_packet_length_check +psyc_setPacketLength psyc_packet_length_set + +psyc_parseUniform - +psyc_parseUniform2 psyc_uniform_parse + +psyc_initTextState psyc_text_state_init +psyc_initTextState2 psyc_text_state_init_custom +psyc_setTextBuffer - +psyc_setTextBuffer2 psyc_text_buffer_set +psyc_getTextBytesWritten psyc_text_bytes_written + +psyc_parseList psyc_parse_list +psyc_parseNumber - +psyc_parseNumber2 psyc_parse_number +psyc_parseTime - +psyc_parseTime2 psyc_parse_time +psyc_parseDate - +psyc_parseDate2 psyc_parse_date +psyc_initParseState - +psyc_initParseState2 psyc_parse_state_init +psyc_setParseBuffer - +psyc_setParseBuffer2 psyc_parse_buffer_set +psyc_initParseListState psyc_parse_list_state_init +psyc_setParseListBuffer - +psyc_setParseListBuffer2 psyc_parse_list_buffer_set +psyc_getParseContentLength psyc_parse_content_length +psyc_isParseContentLengthFound psyc_parse_content_length_found +psyc_getParseValueLength psyc_parse_value_length +psyc_isParseValueLengthFound psyc_parse_value_length_found +psyc_getParseCursor psyc_parse_cursor +psyc_getParseBufferLength psyc_parse_buffer_length +psyc_getParseRemainingLength psyc_parse_remaining_length +psyc_getParseRemainingBuffer psyc_parse_remaining_buffer + +psyc_isGlyph psyc_is_glyph +psyc_isAlpha psyc_is_alpha +psyc_isAlphaNumeric psyc_is_alpha_numeric +psyc_isKwChar psyc_is_kw_char +psyc_isNameChar psyc_is_name_char +psyc_isHostChar psyc_is_host_char + +psyc_renderList psyc_render_list diff --git a/include/psyc.h b/include/psyc.h index 192c6ed..58e4aa2 100644 --- a/include/psyc.h +++ b/include/psyc.h @@ -27,6 +27,8 @@ #define PSYC_S2ARG(str) (str).ptr, (str).length #define PSYC_S2ARG2(str) (str).length, (str).ptr +#define PSYC_NUM_ELEM(a) (sizeof(a) / sizeof(*(a))) + typedef enum { PSYC_FALSE = 0, @@ -99,22 +101,22 @@ typedef struct typedef struct { - psycString name; + psycString key; int value; } psycMatchVar; /** * Shortcut for creating a psycString. * - * @param memory Pointer to the buffer. - * @param length Length of that buffer. + * @param str Pointer to the buffer. + * @param len Length of that buffer. * * @return An instance of the psycString struct. */ static inline -psycString psyc_newString (const char *str, size_t slen) +psycString psyc_string_new (char *str, size_t len) { - psycString s = {slen, str}; + psycString s = {len, str}; return s; } @@ -124,81 +126,39 @@ unsigned int psyc_version () return 1; } -/// Routing variables in alphabetical order. -extern const psycString psyc_routingVars[]; - -// Variable types in alphabetical order. -extern const psycMatchVar psyc_varTypes[]; - -extern const size_t psyc_routingVarsNum; -extern const size_t psyc_varTypesNum; /** - * Is this a routing variable name? + * Checks if long keyword string inherits from short keyword string. */ -psycBool psyc_isRoutingVar(psycString *name); -/** - * Is this a routing variable name? - */ -psycBool psyc_isRoutingVar2(const char *name, size_t len); +int psyc_inherits (char *sho, size_t slen, + char *lon, size_t llen); /** - * Get the type of variable name. + * Checks if short keyword string matches long keyword string. */ -psycType psyc_getVarType(psycString *name); -/** - * Get the type of variable name. - */ -psycType psyc_getVarType2(const char *name, size_t len); +int psyc_matches (char *sho, size_t slen, + char *lon, size_t llen); /** - * Search for a variable name in an array. + * Check if keyword is in array. * * @param array The array to search, should be ordered alphabetically. * @param size Size of array. - * @param name Name of variable to look for. - * @param namelen Length of name. - * @param startswith If true, look for any variable starting with name, + * @param kw Keyword to look for. + * @param kwlen Length of keyword. + * @param inherit If true, also look for anything inheriting from kw, otherwise only exact matches are returned. * @param matching A temporary array used for keeping track of results. * Should be the same size as the array we're searching. * * @return The value of the matched variable in the array. */ -int psyc_findVar(const psycMatchVar *array, size_t size, - const char *name, size_t namelen, - uint8_t startswith, int8_t *matching); -/** - * Is this a list variable name? - */ -static inline -psycBool psyc_isListVar2(const char *name, size_t len) -{ - return len < 5 || memcmp(name, "_list", 5) != 0 || - (len > 5 && name[5] != '_') ? PSYC_FALSE : PSYC_TRUE; -} +int psyc_in_array (const psycMatchVar *array, size_t size, + const char *kw, size_t kwlen, + psycBool inherit, int8_t *matching); -/** - * Is this a list variable name? - */ -static inline -psycBool psyc_isListVar(psycString *name) -{ - return psyc_isListVar2(name->ptr, name->length); -} - -/** - * Checks if long keyword string inherits from short keyword string. - */ -int psyc_inherits(char *sho, size_t slen, - char *lon, size_t llen); - -/** - * Checks if short keyword string matches long keyword string. - */ -int psyc_matches(char *sho, size_t slen, - char *lon, size_t llen); +#include "psyc/variable.h" #define PSYC_H #endif diff --git a/include/psyc/packet.h b/include/psyc/packet.h index 5407ba2..0080cc1 100644 --- a/include/psyc/packet.h +++ b/include/psyc/packet.h @@ -17,6 +17,7 @@ #include #include +#include /** Modifier flags. */ typedef enum @@ -78,7 +79,7 @@ typedef struct psycListFlag flag; } psycList; -/** intermediate struct for a PSYC packet */ +/** Intermediate struct for a PSYC packet */ typedef struct { psycHeader routing; ///< Routing header. @@ -92,12 +93,21 @@ typedef struct psycPacketFlag flag; ///< Packet flag. } psycPacket; +/** + * Return the number of digits a number has in its base 10 representation. + */ +static inline +size_t psyc_num_length (size_t n) +{ + return n < 10 ? 1 : log10(n) + 1; +} + /** * \internal * Check if a modifier needs length. */ static inline -psycModifierFlag psyc_checkModifierLength (psycModifier *m) +psycModifierFlag psyc_modifier_length_check (psycModifier *m) { psycModifierFlag flag; @@ -111,85 +121,64 @@ psycModifierFlag psyc_checkModifierLength (psycModifier *m) return flag; } -/** Create new modifier. */ -static inline -psycModifier psyc_newModifier (char oper, psycString *name, psycString *value, - psycModifierFlag flag) -{ - psycModifier m = {oper, *name, *value, flag}; - - if (flag == PSYC_MODIFIER_CHECK_LENGTH) // find out if it needs a length - m.flag = psyc_checkModifierLength(&m); - - return m; -} - /** Create new modifier */ static inline -psycModifier psyc_newModifier2 (char oper, - const char *name, size_t namelen, - const char *value, size_t valuelen, - psycModifierFlag flag) -{ - psycString n = {namelen, name}; - psycString v = {valuelen, value}; +psycModifier psyc_modifier_new (char oper, + char *name, size_t namelen, + char *value, size_t valuelen, + psycModifierFlag flag){ - return psyc_newModifier(oper, &n, &v, flag); + psycModifier m = {oper, {namelen, name}, {valuelen, value}, flag}; + + if (flag == PSYC_MODIFIER_CHECK_LENGTH) // find out if it needs a length + m.flag = psyc_modifier_length_check(&m); + + return m; } /** * \internal * Get the total length of a modifier when rendered. */ -size_t psyc_getModifierLength (psycModifier *m); +size_t psyc_modifier_length (psycModifier *m); /** * \internal * Check if a list needs length. */ -psycListFlag psyc_checkListLength (psycList *list); +psycListFlag psyc_list_length_check (psycList *list); /** * \internal * Get the total length of a list when rendered. */ -psycListFlag psyc_getListLength (psycList *list); +psycListFlag psyc_list_length (psycList *list); /** * \internal * Check if a packet needs length. */ -psycPacketFlag psyc_checkPacketLength (psycPacket *p); +psycPacketFlag psyc_packet_length_check (psycPacket *p); /** * Calculate and set the rendered length of packet parts and total packet length. */ -size_t psyc_setPacketLength (psycPacket *p); +size_t psyc_packet_length_set (psycPacket *p); /** Create new list. */ -psycList psyc_newList (psycString *elems, size_t num_elems, psycListFlag flag); +psycList psyc_list_new (psycString *elems, size_t num_elems, psycListFlag flag); /** Create new packet. */ -psycPacket psyc_newPacket (psycHeader *routing, - psycHeader *entity, - psycString *method, psycString *data, - psycPacketFlag flag); - -/** Create new packet. */ -psycPacket psyc_newPacket2 (psycModifier *routing, size_t routinglen, +psycPacket psyc_packet_new (psycModifier *routing, size_t routinglen, psycModifier *entity, size_t entitylen, - const char *method, size_t methodlen, - const char *data, size_t datalen, + char *method, size_t methodlen, + char *data, size_t datalen, psycPacketFlag flag); /** Create new packet with raw content. */ -psycPacket psyc_newRawPacket (psycHeader *routing, psycString *content, - psycPacketFlag flag); - -/** Create new packet with raw content. */ -psycPacket psyc_newRawPacket2 (psycModifier *routing, size_t routinglen, - const char *content, size_t contentlen, - psycPacketFlag flag); +psycPacket psyc_packet_new_raw (psycModifier *routing, size_t routinglen, + char *content, size_t contentlen, + psycPacketFlag flag); /** @} */ // end of packet group diff --git a/include/psyc/parse.h b/include/psyc/parse.h index d0b22d5..cf86340 100644 --- a/include/psyc/parse.h +++ b/include/psyc/parse.h @@ -11,8 +11,8 @@ * @defgroup parse Parsing Functions * * This module contains packet and list parsing functions. - * The parser adheres to the definition of a packet found at - * + * The parser adheres to the definition of a packet found at + * * http://about.psyc.eu/Spec:Packet * * and the according terms are used throughout this documentation and in the @@ -25,11 +25,10 @@ * * @code * psycParseState state; - * - * psyc_initParseState(&state); + * psyc_parse_state_init(&state, flags); * @endcode * - * Note that there is also psyc_initParseState2 if you want to fine-tune what + * With the flags parameter you can fine-tune what * part of the packet should be parsed. @see psycParseFlag * * Next, you have to tell the parser what it should parse. Assuming the variable @@ -40,7 +39,7 @@ * char* raw_data; // points to our (possibly incomplete) packet * size_t raw_len; // how many bytes of data * - * psyc_setParseBuffer(&state, raw_data, raw_len); // state is our initialized state from before + * psyc_parse_buffer_set(&state, raw_data, raw_len); // state is our initialized state from before * @endcode * * Now the the variables that will save the output of the parser need to be @@ -77,7 +76,7 @@ * case PSYC_PARSE_ENTITY: // it is a entity variable * // Name, value and operator of the variable can now be found in the * // respective variables: - * printf("Variable: %.*s Value: %.*s Operator: %c\n", + * printf("Variable: %.*s Value: %.*s Operator: %c\n", * name.length, name.ptr, * value.length, value.ptr, * oper); @@ -86,7 +85,7 @@ * // before passing it to the parser or you copy each variable now. * break; * case PSYC_PARSE_BODY: // it is the method and the body of the packet. - * printf("Method Name: %.*s Body: %.*s\n", + * printf("Method Name: %.*s Body: %.*s\n", * name.length, name.ptr, // name of the method * value.length, value.ptr); // value of the body * break; @@ -94,11 +93,11 @@ * // You can simply continue parsing till you get the * // PSYC_PARSE_INSUFFICIENT code which means the line is incomplete. * continue; - * default: // + * default: // * perror("Error %i happened :(\n", res); * return res; * } - * } + * } * while (ret > 0) * @endcode * @@ -193,7 +192,7 @@ typedef enum { /** * The return value definitions for the list parsing function. - * @see psyc_parseList() + * @see psyc_parse_list() */ typedef enum { PSYC_PARSE_LIST_ERROR_DELIM = -4, @@ -244,24 +243,11 @@ typedef struct { * Initializes the state struct. * * @param state Pointer to the state struct that should be initialized. - * @see psyc_initParseState2 - */ -static inline -void psyc_initParseState (psycParseState *state) -{ - memset(state, 0, sizeof(psycParseState)); -} - -/** - * Initializes the state struct with flags. - * - * @param state Pointer to the state struct that should be initialized. * @param flags Flags to be set for the parser, see psycParseFlag. - * @see psyc_initParseState * @see psycParseFlag */ static inline -void psyc_initParseState2 (psycParseState *state, uint8_t flags) +void psyc_parse_state_init (psycParseState *state, uint8_t flags) { memset(state, 0, sizeof(psycParseState)); state->flags = flags; @@ -277,46 +263,29 @@ void psyc_initParseState2 (psycParseState *state, uint8_t flags) * at the memory pointed to by buffer. * * @param state Pointer to the initialized state of the parser - * @param buffer the buffer that should be parsed now + * @param buffer pointer to the data that should be parsed + * @param length length of the data in bytes * @see psycString */ static inline -void psyc_setParseBuffer (psycParseState *state, psycString buffer) +void psyc_parse_buffer_set (psycParseState *state, char *buffer, size_t length) { - state->buffer = buffer; + state->buffer = (psycString) {length, buffer}; state->cursor = 0; if (state->flags & PSYC_PARSE_START_AT_CONTENT) { - state->contentLength = buffer.length; + state->contentLength = length; state->contentLengthFound = PSYC_TRUE; } } -/** - * Sets a new buffer in the parser state struct with data to be parsed. - * - * This function does NOT copy the buffer. It will parse whatever is - * at the memory pointed to by buffer. - * - * @param state Pointer to the initialized state of the parser - * @param buffer pointer to the data that should be parsed - * @param length length of the data in bytes - * @see psycString - */ -static inline -void psyc_setParseBuffer2 (psycParseState *state, const char *buffer, size_t length) -{ - psycString buf = {length, buffer}; - psyc_setParseBuffer(state, buf); -} - /** * Initializes the list state struct. * * @param state Pointer to the list state struct that should be initialized. */ static inline -void psyc_initParseListState (psycParseListState *state) +void psyc_parse_list_state_init (psycParseListState *state) { memset(state, 0, sizeof(psycParseListState)); } @@ -325,63 +294,56 @@ void psyc_initParseListState (psycParseListState *state) * Sets a new buffer in the list parser state struct with data to be parsed. */ static inline -void psyc_setParseListBuffer (psycParseListState *state, psycString buffer) +void psyc_parse_list_buffer_set (psycParseListState *state, char *buffer, size_t length) { - state->buffer = buffer; + state->buffer = (psycString) {length, buffer}; state->cursor = 0; } static inline -void psyc_setParseListBuffer2 (psycParseListState *state, const char *buffer, size_t length) -{ - psycString buf = {length, buffer}; - psyc_setParseListBuffer(state, buf); -} - -static inline -size_t psyc_getParseContentLength (psycParseState *state) +size_t psyc_parse_content_length (psycParseState *state) { return state->contentLength; } static inline -psycBool psyc_isParseContentLengthFound (psycParseState *state) +psycBool psyc_parse_content_length_found (psycParseState *state) { return state->contentLengthFound; } static inline -size_t psyc_getParseValueLength (psycParseState *state) +size_t psyc_parse_value_length (psycParseState *state) { return state->valueLength; } static inline -psycBool psyc_isParseValueLengthFound (psycParseState *state) +psycBool psyc_parse_value_length_found (psycParseState *state) { return state->valueLengthFound; } static inline -size_t psyc_getParseCursor (psycParseState *state) +size_t psyc_parse_cursor (psycParseState *state) { return state->cursor; } static inline -size_t psyc_getParseBufferLength (psycParseState *state) +size_t psyc_parse_buffer_length (psycParseState *state) { return state->buffer.length; } static inline -size_t psyc_getParseRemainingLength (psycParseState *state) +size_t psyc_parse_remaining_length (psycParseState *state) { return state->buffer.length - state->cursor; } static inline -const char * psyc_getParseRemainingBuffer (psycParseState *state) +const char * psyc_parse_remaining_buffer (psycParseState *state) { return state->buffer.ptr + state->cursor; } @@ -422,10 +384,10 @@ psycParseRC psyc_parse (psycParseState *state, char *oper, #ifdef __INLINE_PSYC_PARSE static inline #endif -psycParseListRC psyc_parseList (psycParseListState *state, psycString *elem); +psycParseListRC psyc_parse_list (psycParseListState *state, psycString *elem); static inline -psycBool psyc_parseNumber2 (const char *value, size_t len, ssize_t *n) +psycBool psyc_parse_number (const char *value, size_t len, ssize_t *n) { size_t c = 0; uint8_t neg = 0; @@ -450,45 +412,27 @@ psycBool psyc_parseNumber2 (const char *value, size_t len, ssize_t *n) } static inline -psycBool psyc_parseNumber (psycString *value, ssize_t *n) +psycBool psyc_parse_time (const char *value, size_t len, time_t *t) { - return psyc_parseNumber2(value->ptr, value->length, n); + return psyc_parse_number(value, len, t); } static inline -psycBool psyc_parseTime2 (const char *value, size_t len, time_t *t) +psycBool psyc_parse_date (const char *value, size_t len, time_t *t) { - return psyc_parseNumber2(value, len, t); -} - -static inline -psycBool psyc_parseTime (psycString *value, time_t *t) -{ - return psyc_parseNumber2(value->ptr, value->length, t); -} - -static inline -psycBool psyc_parseDate2 (const char *value, size_t len, time_t *t) -{ - if (psyc_parseNumber2(value, len, t)) { + if (psyc_parse_number(value, len, t)) { *t += PSYC_EPOCH; return PSYC_TRUE; } return PSYC_FALSE; } -static inline -psycBool psyc_parseDate (psycString *value, time_t *t) -{ - return psyc_parseDate2(value->ptr, value->length, t); -} - /** * Determines if the argument is a glyph. * Glyphs are: : = + - ? ! */ static inline -char psyc_isGlyph (uint8_t g) +char psyc_is_glyph (uint8_t g) { switch(g) { case ':': @@ -507,7 +451,7 @@ char psyc_isGlyph (uint8_t g) * Determines if the argument is numeric. */ static inline -char psyc_isNumeric (uint8_t c) +char psyc_is_numeric (uint8_t c) { return c >= '0' && c <= '9'; } @@ -516,7 +460,7 @@ char psyc_isNumeric (uint8_t c) * Determines if the argument is alphabetic. */ static inline -char psyc_isAlpha (uint8_t c) +char psyc_is_alpha (uint8_t c) { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); } @@ -525,9 +469,9 @@ char psyc_isAlpha (uint8_t c) * Determines if the argument is alphanumeric. */ static inline -char psyc_isAlphaNumeric (uint8_t c) +char psyc_is_alpha_numeric (uint8_t c) { - return psyc_isAlpha(c) || psyc_isNumeric(c); + return psyc_is_alpha(c) || psyc_is_numeric(c); } /** @@ -535,9 +479,9 @@ char psyc_isAlphaNumeric (uint8_t c) * Keyword characters are: alphanumeric and _ */ static inline -char psyc_isKwChar (uint8_t c) +char psyc_is_kw_char (uint8_t c) { - return psyc_isAlphaNumeric(c) || c == '_'; + return psyc_is_alpha_numeric(c) || c == '_'; } /** @@ -545,9 +489,9 @@ char psyc_isKwChar (uint8_t c) * Name characters are: see opaque_part in RFC 2396 */ static inline -char psyc_isNameChar (uint8_t c) +char psyc_is_name_char (uint8_t c) { - return psyc_isAlpha(c) || (c >= '$' && c <= ';') || + return psyc_is_alpha(c) || (c >= '$' && c <= ';') || c == '_' || c == '!' || c == '?' || c == '=' || c == '@' || c == '~'; } @@ -556,9 +500,9 @@ char psyc_isNameChar (uint8_t c) * Hostname characters are: alphanumeric and - */ static inline -char psyc_isHostChar (uint8_t c) +char psyc_is_host_char (uint8_t c) { - return psyc_isAlphaNumeric(c) || c == '.' || c == '-'; + return psyc_is_alpha_numeric(c) || c == '.' || c == '-'; } /** @} */ // end of parse group diff --git a/include/psyc/render.h b/include/psyc/render.h index 2f13793..e4cd8f2 100644 --- a/include/psyc/render.h +++ b/include/psyc/render.h @@ -32,7 +32,7 @@ typedef enum } psycRenderRC; /** - * Return codes for psyc_renderList. + * Return codes for psyc_render_list. */ typedef enum { @@ -48,15 +48,13 @@ typedef enum * The packet structure should contain the packet parts, either routing, entity, * method & data, or routing & content when rendering raw content. * It should also contain the contentLength & total length of the packet, - * you can use psyc_setPacketLength() for calculating & setting these values. + * you can use psyc_packet_length_set() for calculating & setting these values. * This function renders packet->length bytes to the buffer, * if buflen is less than that an error is returned. * - * @see psyc_newPacket - * @see psyc_newPacket2 - * @see psyc_newRawPacket - * @see psyc_newRawPacket2 - * @see psyc_setPacketLength + * @see psyc_packet_new + * @see psyc_packet_new_raw + * @see psyc_packet_length_set */ #ifdef __INLINE_PSYC_RENDER static inline @@ -69,7 +67,7 @@ psycRenderRC psyc_render (psycPacket *packet, char *buffer, size_t buflen); #ifdef __INLINE_PSYC_RENDER static inline #endif -psycRenderListRC psyc_renderList (psycList *list, char *buffer, size_t buflen); +psycRenderListRC psyc_render_list (psycList *list, char *buffer, size_t buflen); /** @} */ // end of render group diff --git a/include/psyc/text.h b/include/psyc/text.h index a09d3fb..55f35e5 100644 --- a/include/psyc/text.h +++ b/include/psyc/text.h @@ -76,9 +76,9 @@ typedef psycTextValueRC (*psycTextCB)(const char *name, size_t len, psycString * * @param buflen Length of output buffer. */ static inline -void psyc_initTextState (psycTextState *state, - const char *tmpl, size_t tmplen, - char *buffer, size_t buflen) +void psyc_text_state_init (psycTextState *state, + char *tmpl, size_t tmplen, + char *buffer, size_t buflen) { state->cursor = 0; state->written = 0; @@ -102,11 +102,11 @@ void psyc_initTextState (psycTextState *state, * @param closelen Length of closing brace. */ static inline -void psyc_initTextState2 (psycTextState *state, - const char *tmpl, size_t tmplen, - char *buffer, size_t buflen, - const char *open, size_t openlen, - const char *close, size_t closelen) +void psyc_text_state_init_custom (psycTextState *state, + char *tmpl, size_t tmplen, + char *buffer, size_t buflen, + char *open, size_t openlen, + char *close, size_t closelen) { state->cursor = 0; state->written = 0; @@ -120,25 +120,15 @@ void psyc_initTextState2 (psycTextState *state, * Sets a new output buffer in the PSYC text state struct. */ static inline -void psyc_setTextBuffer (psycTextState *state, psycString buffer) +void psyc_text_buffer_set (psycTextState *state, + char *buffer, size_t length) { - state->buffer = buffer; + state->buffer = (psycString){length, buffer}; state->written = 0; } -/** - * Sets a new buffer in the PSYC text state struct. - */ static inline -void psyc_setTextBuffer2 (psycTextState *state, - char *buffer, size_t length) -{ - psycString buf = {length, buffer}; - psyc_setTextBuffer(state, buf); -} - -static inline -size_t psyc_getTextBytesWritten (psycTextState *state) +size_t psyc_text_bytes_written (psycTextState *state) { return state->written; } @@ -151,10 +141,10 @@ size_t psyc_getTextBytesWritten (psycTextState *state) * string between these braces. Should the callback return * PSYC_TEXT_VALUE_NOT_FOUND, the original template text is copied as is. * - * Before calling this function psyc_initTextState should be called to initialize + * Before calling this function psyc_text_state_init should be called to initialize * the state struct. By default PSYC's "[" and "]" are used but you can provide * any other brace strings such as "${" and "}" or "" if you use - * the psyc_initTextState2 variant. + * the psyc_text_state_init_custom variant. * * @see http://about.psyc.eu/psyctext **/ diff --git a/include/psyc/uniform.h b/include/psyc/uniform.h index 24324cf..7bc86ba 100644 --- a/include/psyc/uniform.h +++ b/include/psyc/uniform.h @@ -73,9 +73,7 @@ typedef enum { PSYC_ENTITY_SERVICE = '$', } psycEntityType; -int psyc_parseUniform2(psycUniform *uni, const char *str, size_t length); - -int psyc_parseUniform(psycUniform *uni, psycString *str); +int psyc_uniform_parse (psycUniform *uni, char *str, size_t length); #define PSYC_UNIFORM_H #endif diff --git a/include/psyc/variable.h b/include/psyc/variable.h new file mode 100644 index 0000000..c4671f6 --- /dev/null +++ b/include/psyc/variable.h @@ -0,0 +1,37 @@ +#ifndef PSYC_VARIABLE_H + +/** + * @file psyc/variable.h + */ + +/// Routing variables in alphabetical order. +extern const psycString psyc_routing_vars[]; + +// Variable types in alphabetical order. +extern const psycMatchVar psyc_var_types[]; + +extern const size_t psyc_routing_vars_num; +extern const size_t psyc_var_types_num; + +/** + * Is this a routing variable name? + */ +psycBool psyc_var_is_routing (const char *name, size_t len); + +/** + * Get the type of variable name. + */ +psycType psyc_var_type (const char *name, size_t len); + +/** + * Is this a list variable name? + */ +static inline +psycBool psyc_var_is_list (const char *name, size_t len) +{ + return len < 5 || memcmp(name, "_list", 5) != 0 || + (len > 5 && name[5] != '_') ? PSYC_FALSE : PSYC_TRUE; +} + +#define PSYC_VARIABLE_H +#endif diff --git a/pike/psyc.cmod b/pike/psyc.cmod index 11ba358..2f31b7d 100644 --- a/pike/psyc.cmod +++ b/pike/psyc.cmod @@ -74,14 +74,14 @@ PIKEFUN string psyc_text(string template, mapping vars) { // FIXME: char buffer[512]; - psyc_initTextState(&state, (char *) STR0(template), template->len, buffer, 512); + psyc_text_state_init(&state, (char *) STR0(template), template->len, buffer, 512); do { ret = psyc_text(&state, lookup_value_mapping, vars); - len += psyc_getTextBytesWritten(&state); + len += psyc_text_bytes_written(&state); switch (ret) { case PSYC_TEXT_INCOMPLETE: // need to realloc buffer - //psyc_setTextBuffer2(&state, buffer + len, BUFSIZE - len); + //psyc_text_buffer_set(&state, buffer + len, BUFSIZE - len); break; case PSYC_TEXT_COMPLETE: // we're done RETURN make_shared_binary_string(buffer, len); @@ -99,7 +99,7 @@ PIKEFUN string psyc_text(string template, mapping vars) { *! 0 otherwise */ PIKEFUN int is_routingvar(string name) { - RETURN psyc_isRoutingVar2((char *) STR0(name), name->len); + RETURN psyc_var_is_routing((char *) STR0(name), name->len); } /*! @decl string render(mapping rvars, mapping evars, string method, string|void body) @@ -130,11 +130,11 @@ PIKEFUN string render(mapping rvars, mapping evars, string method, string|void b if (k->ind.type == PIKE_T_STRING) { switch(k->val.type) { case PIKE_T_STRING: - rheaders.modifiers[rheaders.lines++] = psyc_newModifier2(oper, + rheaders.modifiers[rheaders.lines++] = psyc_modifier_new(oper, (char *)STR0(k->ind.u.string), k->ind.u.string->len, (char *)STR0(k->val.u.string), - k->val.u.string->len, + k->val.u.string->len, PSYC_MODIFIER_ROUTING); break; default: @@ -197,10 +197,10 @@ PIKEFUN string render(mapping rvars, mapping evars, string method, string|void b Pike_error("psyc_render: unsupported data type in list\n"); } } - list = psyc_newList(elems, k->val.u.array->size, PSYC_LIST_CHECK_LENGTH); + list = psyc_list_new(elems, k->val.u.array->size, PSYC_LIST_CHECK_LENGTH); struct pike_string *listbuf = begin_shared_string(list.length); - psyc_renderList(&list, (char *) STR0(listbuf), listbuf->len); + psyc_render_list(&list, (char *) STR0(listbuf), listbuf->len); end_shared_string(listbuf); val = (char *) STR0(listbuf); vallen = listbuf->len; @@ -211,7 +211,7 @@ PIKEFUN string render(mapping rvars, mapping evars, string method, string|void b Pike_error("psyc_render: unsupported value in evars\n"); break; } - eheaders.modifiers[eheaders.lines++] = psyc_newModifier2(oper, + eheaders.modifiers[eheaders.lines++] = psyc_modifier_new(oper, key, keylen, val, vallen, PSYC_MODIFIER_CHECK_LENGTH); @@ -221,19 +221,19 @@ PIKEFUN string render(mapping rvars, mapping evars, string method, string|void b } if (body != NULL) { - packet = psyc_newPacket2(rheaders.modifiers, + packet = psyc_packet_new(rheaders.modifiers, rheaders.lines, eheaders.modifiers, eheaders.lines, - (const char *)STR0(method), method->len, + (const char *)STR0(method), method->len, (const char *)STR0(body), body->len, PSYC_PACKET_CHECK_LENGTH); } else { // body arg was not given - packet = psyc_newPacket2(rheaders.modifiers, + packet = psyc_packet_new(rheaders.modifiers, rheaders.lines, eheaders.modifiers, eheaders.lines, - (const char *)STR0(method), method->len, + (const char *)STR0(method), method->len, NULL, 0, PSYC_PACKET_CHECK_LENGTH); } @@ -260,7 +260,7 @@ PIKECLASS Parser { CVAR struct string_builder incomplete; INIT { - psyc_initParseState(&THIS->parser); + psyc_parse_state_init(&THIS->parser, PSYC_PARSE_ALL); THIS->buffer = NULL; THIS->handle_packet = find_identifier("handle_packet", Pike_fp->current_object->prog); THIS->handle_error = find_identifier("handle_error", Pike_fp->current_object->prog); @@ -296,7 +296,7 @@ PIKECLASS Parser { data = tmp; THIS->buffer = NULL; } - psyc_setParseBuffer2(&THIS->parser, + psyc_parse_buffer_set(&THIS->parser, (char *) STR0(data), data->len); do { ret = psyc_parse(&THIS->parser, &oper, &name, &value); @@ -308,7 +308,7 @@ PIKECLASS Parser { make_shared_binary_string(value.ptr, value.length)); break; case PSYC_PARSE_ENTITY_START: // entity var with length - init_string_builder_alloc(&THIS->incomplete, psyc_getParseValueLength(&THIS->parser), 0); + init_string_builder_alloc(&THIS->incomplete, psyc_parse_value_length(&THIS->parser), 0); // fall thru case PSYC_PARSE_ENTITY_CONT: string_builder_append(&THIS->incomplete, MKPCHARP(value.ptr, 0), value.length); @@ -327,12 +327,12 @@ PIKECLASS Parser { //printf("E %.*s -> %.*s\n", (int)name.length, name.ptr, (int)value.length, value.ptr); do { err = 0; - int type = psyc_getVarType(&name); + int type = psyc_var_type(PSYC_S2ARG(&name)); struct svalue sv; time_t timmy; switch(type) { case PSYC_TYPE_DATE: - if (psyc_parseDate(&value, &timmy)) { + if (psyc_parse_date(&value, &timmy)) { sv.type = PIKE_T_INT; sv.u.integer = timmy; mapping_string_insert(THIS->evars, make_shared_binary_string(name.ptr, name.length), @@ -342,7 +342,7 @@ PIKECLASS Parser { } break; case PSYC_TYPE_TIME: - if (psyc_parseTime(&value, &timmy)) { + if (psyc_parse_time(&value, &timmy)) { sv.type = PIKE_T_INT; sv.u.integer = timmy; mapping_string_insert(THIS->evars, make_shared_binary_string(name.ptr, name.length), @@ -382,10 +382,10 @@ PIKECLASS Parser { psycParseListState listState; psycString elem = (psycString) {0, 0}; - psyc_initParseListState(&listState); - psyc_setParseListBuffer(&listState, value); + psyc_parse_list_state_init(&listState); + psyc_parse_list_buffer_set(&listState, PSYC_S2ARG(value)); do { - retl = psyc_parseList(&listState, &elem); + retl = psyc_parse_list(&listState, &elem); switch(retl) { case PSYC_PARSE_LIST_END: // last element retl = 0; @@ -421,7 +421,7 @@ PIKECLASS Parser { } break; case PSYC_PARSE_BODY_START: // if length was given this is used for body - init_string_builder_alloc(&THIS->incomplete, psyc_getParseValueLength(&THIS->parser), 0); + init_string_builder_alloc(&THIS->incomplete, psyc_parse_value_length(&THIS->parser), 0); case PSYC_PARSE_BODY_CONT: string_builder_append(&THIS->incomplete, MKPCHARP(value.ptr, 0), value.length); break; @@ -460,9 +460,9 @@ PIKECLASS Parser { THIS->body = NULL; break; case PSYC_PARSE_INSUFFICIENT: // not enough data - if (psyc_getParseRemainingBuffer(&THIS->parser) > 0) { - THIS->buffer = make_shared_binary_string(psyc_getParseRemainingBuffer(&THIS->parser), - psyc_getParseRemainingLength(&THIS->parser)); + if (psyc_parse_remaining_buffer(&THIS->parser) > 0) { + THIS->buffer = make_shared_binary_string(psyc_parse_remaining_buffer(&THIS->parser), + psyc_parse_remaining_length(&THIS->parser)); } return; default: // fatal error diff --git a/src/lib.h b/src/lib.h index 637b082..f24beae 100644 --- a/src/lib.h +++ b/src/lib.h @@ -11,8 +11,6 @@ #define unless(COND) if (!(COND)) #define until(COND) while (!(COND)) -#define PSYC_NUM_ELEM(a) (sizeof(a) / sizeof(*(a))) - #if !defined(__USE_GNU) && !(defined(__FBSDID) && defined(__BSD_VISIBLE)) void * memmem(const void *l, size_t l_len, const void *s, size_t s_len); #endif diff --git a/src/match.c b/src/match.c index 7fc3c25..dd68d77 100644 --- a/src/match.c +++ b/src/match.c @@ -1,7 +1,7 @@ #include "lib.h" -int psyc_inherits(char* sho, size_t slen, - char* lon, size_t llen) { +int psyc_inherits (char* sho, size_t slen, + char* lon, size_t llen) { // this allows to pass zero-terminated strings instead of providing // the length.. but we would be faster here if we expected the callee @@ -42,8 +42,8 @@ int psyc_inherits(char* sho, size_t slen, return 1; } -int psyc_matches(char* sho, size_t slen, - char* lon, size_t llen) { +int psyc_matches (char* sho, size_t slen, + char* lon, size_t llen) { char *s, *l, *se, *le; //if (!slen) slen = strlen(sho); @@ -100,6 +100,62 @@ failed: return 1; } +/** + * Check if keyword is in array. + * + * @param array The array to search, should be ordered alphabetically. + * @param size Size of array. + * @param kw Keyword to look for. + * @param kwlen Length of keyword. + * @param inherit If true, look for any keyword inheriting from name, + otherwise only exact matches are returned. + * @param matching A temporary array used for keeping track of results. + * Should be the same size as the array we're searching. + * + * @return The value of the matched variable in the array. + */ +int psyc_in_array (const psycMatchVar *array, size_t size, + const char *kw, size_t kwlen, + psycBool inherit, int8_t *matching) +{ + size_t cursor = 1; + uint8_t i, m = 0; + //memset(&matching, -1, sizeof matching); + + if (kwlen < 2 || kw[0] != '_') + return 0; + + // first find the keywords with matching length + for (i=0; i array[i].key.length && kw[array[i].key.length] == '_')) + matching[m++] = i; + + matching[m] = -1; // mark the end of matching indexes + + while (cursor < kwlen && matching[0] >= 0) { + for (i = m = 0; i < size; i++) { + if (matching[i] < 0) + break; // reached the end of possible matches + if (cursor < array[matching[i]].key.length && + array[matching[i]].key.ptr[cursor] == kw[cursor]) + matching[m++] = matching[i]; // found a match, update matching indexes + else if (cursor == array[matching[i]].key.length && kw[cursor] == '_') + return array[matching[0]].value; // _ after the end of a matching prefix + else if (array[matching[i]].key.ptr[cursor] > kw[cursor]) + break; // passed the possible matches in alphabetical order in the array + } + + if (m < size) + matching[m] = -1; // mark the end of matching indexes + + cursor++; + } + + // return first match if found + return matching[0] >= 0 ? array[matching[0]].value : 0; +} + #ifdef CMDTOOL int main(int argc, char **argv) { if (argc != 3) { diff --git a/src/packet.c b/src/packet.c index fe7c13e..a06bc72 100644 --- a/src/packet.c +++ b/src/packet.c @@ -2,16 +2,8 @@ #include #include -#include - -static inline -size_t psyc_getNumLength(size_t n) -{ - return n < 10 ? 1 : log10(n) + 1; -} - inline -psycListFlag psyc_checkListLength (psycList *list) +psycListFlag psyc_list_length_check (psycList *list) { psycListFlag flag = PSYC_LIST_NO_LENGTH; size_t i, length = 0; @@ -33,7 +25,7 @@ psycListFlag psyc_checkListLength (psycList *list) } inline -psycListFlag psyc_getListLength (psycList *list) +psycListFlag psyc_list_length (psycList *list) { size_t i, length = 0; @@ -43,7 +35,7 @@ psycListFlag psyc_getListLength (psycList *list) { if (i > 0) length++; // | - length += psyc_getNumLength(list->elems[i].length) + 1 + list->elems[i].length; // length SP elem + length += psyc_num_length(list->elems[i].length) + 1 + list->elems[i].length; // length SP elem } } else @@ -56,33 +48,33 @@ psycListFlag psyc_getListLength (psycList *list) } inline -psycList psyc_newList(psycString *elems, size_t num_elems, psycListFlag flag) +psycList psyc_list_new (psycString *elems, size_t num_elems, psycListFlag flag) { psycList list = {num_elems, elems, 0, flag}; if (flag == PSYC_LIST_CHECK_LENGTH) // check if list elements need length - list.flag = psyc_checkListLength(&list); + list.flag = psyc_list_length_check(&list); - list.length = psyc_getListLength(&list); + list.length = psyc_list_length(&list); return list; } inline -size_t psyc_getModifierLength (psycModifier *m) +size_t psyc_modifier_length (psycModifier *m) { size_t length = 1 + // oper m->name.length + 1 + // name\t m->value.length + 1; // value\n if (m->flag == PSYC_MODIFIER_NEED_LENGTH) // add length of length if needed - length += psyc_getNumLength(m->value.length) + 1; // SP length + length += psyc_num_length(m->value.length) + 1; // SP length return length; } inline -psycPacketFlag psyc_checkPacketLength(psycPacket *p) +psycPacketFlag psyc_packet_length_check (psycPacket *p) { if (p->data.length == 1 && p->data.ptr[0] == C_GLYPH_PACKET_DELIMITER) return PSYC_PACKET_NEED_LENGTH; @@ -104,7 +96,7 @@ psycPacketFlag psyc_checkPacketLength(psycPacket *p) } inline -size_t psyc_setPacketLength(psycPacket *p) +size_t psyc_packet_length_set (psycPacket *p) { size_t i; p->routingLength = 0; @@ -112,7 +104,7 @@ size_t psyc_setPacketLength(psycPacket *p) // add routing header length for (i = 0; i < p->routing.lines; i++) - p->routingLength += psyc_getModifierLength(&(p->routing.modifiers[i])); + p->routingLength += psyc_modifier_length(&(p->routing.modifiers[i])); if (p->content.length) p->contentLength = p->content.length; @@ -120,7 +112,7 @@ size_t psyc_setPacketLength(psycPacket *p) { // add entity header length for (i = 0; i < p->entity.lines; i++) - p->contentLength += psyc_getModifierLength(&(p->entity.modifiers[i])); + p->contentLength += psyc_modifier_length(&(p->entity.modifiers[i])); // add length of method, data & delimiter if (p->method.length) @@ -136,60 +128,39 @@ size_t psyc_setPacketLength(psycPacket *p) 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_getNumLength(p->contentLength); + p->length += psyc_num_length(p->contentLength); return p->length; } inline -psycPacket psyc_newPacket (psycHeader *routing, psycHeader *entity, - psycString *method, psycString *data, - psycPacketFlag flag) -{ - psycPacket p = {*routing, *entity, *method, *data, {0,0}, 0, 0, flag}; - - if (flag == PSYC_PACKET_CHECK_LENGTH) // find out if it needs a length - p.flag = psyc_checkPacketLength(&p); - - psyc_setPacketLength(&p); - return p; -} - -inline -psycPacket psyc_newPacket2 (psycModifier *routing, size_t routinglen, +psycPacket psyc_packet_new (psycModifier *routing, size_t routinglen, psycModifier *entity, size_t entitylen, - const char *method, size_t methodlen, - const char *data, size_t datalen, + char *method, size_t methodlen, + char *data, size_t datalen, psycPacketFlag flag) { - psycHeader r = {routinglen, routing}; - psycHeader e = {entitylen, entity}; - psycString m = {methodlen, method}; - psycString d = {datalen, data}; - - return psyc_newPacket(&r, &e, &m, &d, flag); -} - -inline -psycPacket psyc_newRawPacket (psycHeader *routing, psycString *content, - psycPacketFlag flag) -{ - psycPacket p = {*routing, {0,0}, {0,0}, {0,0}, *content, 0, 0, flag}; + psycPacket p = {{routinglen, routing}, {entitylen, entity}, + {methodlen, method}, {datalen, data}, {0,0}, 0, 0, flag}; if (flag == PSYC_PACKET_CHECK_LENGTH) // find out if it needs a length - p.flag = psyc_checkPacketLength(&p); + p.flag = psyc_packet_length_check(&p); - psyc_setPacketLength(&p); + psyc_packet_length_set(&p); return p; } inline -psycPacket psyc_newRawPacket2 (psycModifier *routing, size_t routinglen, - const char *content, size_t contentlen, - psycPacketFlag flag) +psycPacket psyc_packet_new_raw (psycModifier *routing, size_t routinglen, + char *content, size_t contentlen, + psycPacketFlag flag) { - psycHeader r = {routinglen, routing}; - psycString c = {contentlen, content}; + psycPacket p = {{routinglen, routing}, {0,0}, {0,0}, {0,0}, + {contentlen, content}, 0, 0, flag}; - return psyc_newRawPacket(&r, &c, flag); + if (flag == PSYC_PACKET_CHECK_LENGTH) // find out if it needs a length + p.flag = psyc_packet_length_check(&p); + + psyc_packet_length_set(&p); + return p; } diff --git a/src/parse.c b/src/parse.c index eaa85ad..6fdd807 100644 --- a/src/parse.c +++ b/src/parse.c @@ -29,12 +29,12 @@ typedef enum { * @return PARSE_ERROR or PARSE_SUCCESS */ static inline -parseRC psyc_parseKeyword (psycParseState *state, psycString *name) +parseRC psyc_parse_keyword (psycParseState *state, psycString *name) { name->ptr = state->buffer.ptr + state->cursor; name->length = 0; - while (psyc_isKwChar(state->buffer.ptr[state->cursor])) + while (psyc_is_kw_char(state->buffer.ptr[state->cursor])) { name->length++; // was a valid char, increase length ADVANCE_CURSOR_OR_RETURN(PSYC_PARSE_INSUFFICIENT); @@ -54,7 +54,7 @@ parseRC psyc_parseKeyword (psycParseState *state, psycString *name) * @return PARSE_COMPLETE or PARSE_INCOMPLETE */ static inline -parseRC psyc_parseBinaryValue (psycParseState *state, psycString *value, +parseRC psyc_parse_binary_value (psycParseState *state, psycString *value, size_t *length, size_t *parsed) { size_t remaining = *length - *parsed; @@ -81,13 +81,13 @@ parseRC psyc_parseBinaryValue (psycParseState *state, psycString *value, * @return PARSE_ERROR or PARSE_SUCCESS */ static inline -parseRC psyc_parseModifier (psycParseState *state, char *oper, +parseRC psyc_parse_modifier (psycParseState *state, char *oper, psycString *name, psycString *value) { *oper = *(state->buffer.ptr + state->cursor); ADVANCE_CURSOR_OR_RETURN(PSYC_PARSE_INSUFFICIENT); - parseRC ret = psyc_parseKeyword(state, name); + parseRC ret = psyc_parse_keyword(state, name); if (ret == PARSE_ERROR) return PSYC_PARSE_ERROR_MOD_NAME; else if (ret != PARSE_SUCCESS) @@ -105,7 +105,7 @@ parseRC psyc_parseModifier (psycParseState *state, char *oper, { // After SP the length follows. ADVANCE_CURSOR_OR_RETURN(PSYC_PARSE_INSUFFICIENT); - if (psyc_isNumeric(state->buffer.ptr[state->cursor])) + if (psyc_is_numeric(state->buffer.ptr[state->cursor])) { state->valueLengthFound = 1; do @@ -113,7 +113,7 @@ parseRC psyc_parseModifier (psycParseState *state, char *oper, length = 10 * length + state->buffer.ptr[state->cursor] - '0'; ADVANCE_CURSOR_OR_RETURN(PSYC_PARSE_INSUFFICIENT); } - while (psyc_isNumeric(state->buffer.ptr[state->cursor])); + while (psyc_is_numeric(state->buffer.ptr[state->cursor])); state->valueLength = length; } else @@ -126,7 +126,7 @@ parseRC psyc_parseModifier (psycParseState *state, char *oper, if (++(state->cursor) >= state->buffer.length) return length ? PARSE_INCOMPLETE : PARSE_SUCCESS; // if length=0 we're done - ret = psyc_parseBinaryValue(state, value, &(state->valueLength), &(state->valueParsed)); + ret = psyc_parse_binary_value(state, value, &(state->valueLength), &(state->valueParsed)); if (ret == PARSE_INCOMPLETE) return ret; @@ -197,9 +197,9 @@ psycParseRC psyc_parse (psycParseState *state, char *oper, // Each line of the header starts with a glyph, // i.e. :_name, -_name +_name etc, // so just test if the first char is a glyph. - if (psyc_isGlyph(state->buffer.ptr[state->cursor])) // is the first char a glyph? + if (psyc_is_glyph(state->buffer.ptr[state->cursor])) // is the first char a glyph? { // it is a glyph, so a variable starts here - ret = psyc_parseModifier(state, oper, name, value); + ret = psyc_parse_modifier(state, oper, name, value); state->routingLength += state->cursor - pos; return ret == PARSE_SUCCESS ? PSYC_PARSE_ROUTING : ret; } @@ -212,7 +212,7 @@ psycParseRC psyc_parse (psycParseState *state, char *oper, case PSYC_PART_LENGTH: // End of header, content starts with an optional length then a NL - if (psyc_isNumeric(state->buffer.ptr[state->cursor])) + if (psyc_is_numeric(state->buffer.ptr[state->cursor])) { state->contentLengthFound = 1; state->contentLength = 0; @@ -222,7 +222,7 @@ psycParseRC psyc_parse (psycParseState *state, char *oper, state->contentLength = 10 * state->contentLength + state->buffer.ptr[state->cursor] - '0'; ADVANCE_CURSOR_OR_RETURN(PSYC_PARSE_INSUFFICIENT); } - while (psyc_isNumeric(state->buffer.ptr[state->cursor])); + while (psyc_is_numeric(state->buffer.ptr[state->cursor])); } if (state->buffer.ptr[state->cursor] == '\n') // start of content @@ -257,7 +257,7 @@ psycParseRC psyc_parse (psycParseState *state, char *oper, // In case of an incomplete binary variable resume parsing it. if (state->valueParsed < state->valueLength) { - ret = psyc_parseBinaryValue(state, value, &(state->valueLength), &(state->valueParsed)); + ret = psyc_parse_binary_value(state, value, &(state->valueLength), &(state->valueParsed)); state->contentParsed += value->length; if (ret == PARSE_INCOMPLETE) @@ -280,9 +280,9 @@ psycParseRC psyc_parse (psycParseState *state, char *oper, // So just test if the first char is a glyph. // In the body, the same applies, only that the // method does not start with a glyph. - if (psyc_isGlyph(state->buffer.ptr[state->cursor])) + if (psyc_is_glyph(state->buffer.ptr[state->cursor])) { - ret = psyc_parseModifier(state, oper, name, value); + ret = psyc_parse_modifier(state, oper, name, value); state->contentParsed += state->cursor - pos; if (ret == PARSE_INCOMPLETE) @@ -302,7 +302,7 @@ psycParseRC psyc_parse (psycParseState *state, char *oper, case PSYC_PART_METHOD: pos = state->cursor; - ret = psyc_parseKeyword(state, name); + ret = psyc_parse_keyword(state, name); if (ret == PARSE_INSUFFICIENT) return ret; @@ -352,7 +352,7 @@ psycParseRC psyc_parse (psycParseState *state, char *oper, } if (state->valueParsed < state->valueLength) { - ret = psyc_parseBinaryValue(state, value, &(state->valueLength), &(state->valueParsed)); + ret = psyc_parse_binary_value(state, value, &(state->valueLength), &(state->valueParsed)); state->contentParsed += value->length; if (ret == PARSE_INCOMPLETE) @@ -437,7 +437,7 @@ psycParseRC psyc_parse (psycParseState *state, char *oper, #ifdef __INLINE_PSYC_PARSE static inline #endif -psycParseListRC psyc_parseList (psycParseListState *state, psycString *elem) +psycParseListRC psyc_parse_list (psycParseListState *state, psycString *elem) { if (state->cursor >= state->buffer.length) return PSYC_PARSE_LIST_INCOMPLETE; @@ -452,7 +452,7 @@ psycParseListRC psyc_parseList (psycParseListState *state, psycString *elem) state->type = PSYC_LIST_TEXT; state->cursor++; } - else if (psyc_isNumeric(state->buffer.ptr[state->cursor])) + else if (psyc_is_numeric(state->buffer.ptr[state->cursor])) state->type = PSYC_LIST_BINARY; else return PSYC_PARSE_LIST_ERROR_TYPE; @@ -480,14 +480,14 @@ psycParseListRC psyc_parseList (psycParseListState *state, psycString *elem) if (!(state->elemParsed < state->elemLength)) { // Element starts with a number. - if (psyc_isNumeric(state->buffer.ptr[state->cursor])) + if (psyc_is_numeric(state->buffer.ptr[state->cursor])) { do { state->elemLength = 10 * state->elemLength + state->buffer.ptr[state->cursor] - '0'; ADVANCE_CURSOR_OR_RETURN(PSYC_PARSE_LIST_INCOMPLETE); } - while (psyc_isNumeric(state->buffer.ptr[state->cursor])); + while (psyc_is_numeric(state->buffer.ptr[state->cursor])); } else return PSYC_PARSE_LIST_ERROR_LEN; @@ -504,7 +504,7 @@ psycParseListRC psyc_parseList (psycParseListState *state, psycString *elem) // Start or resume parsing the binary data if (state->elemParsed < state->elemLength) { - if (psyc_parseBinaryValue((psycParseState*)state, elem, + if (psyc_parse_binary_value((psycParseState*)state, elem, &(state->elemLength), &(state->elemParsed)) == PARSE_INCOMPLETE) return PSYC_PARSE_LIST_INCOMPLETE; diff --git a/src/psyc_parser_cb.h b/src/psyc_parser_cb.h index 1f38134..ff58491 100644 --- a/src/psyc_parser_cb.h +++ b/src/psyc_parser_cb.h @@ -7,7 +7,7 @@ struct psycParser; * @param pstate pointer to an allocated * psycParser struct. */ -void psyc_initState(struct psycParser* pstate); +void psyc_parse_state_init(struct psycParser* pstate); /** @brief parses a packet @@ -38,7 +38,7 @@ void psyc_initState(struct psycParser* pstate); * raw data that is to be processed. * @param length the amount of bytes to parse * @param pstate pointer to a preallocated - * and initialized (psyc_initState) + * and initialized (psyc_parse_state_init) * instance of the struct state * */ diff --git a/src/render.c b/src/render.c index 449d280..f66a2a8 100644 --- a/src/render.c +++ b/src/render.c @@ -5,7 +5,7 @@ #ifdef __INLINE_PSYC_RENDER static inline #endif -psycRenderListRC psyc_renderList (psycList *list, char *buffer, size_t buflen) +psycRenderListRC psyc_render_list (psycList *list, char *buffer, size_t buflen) { size_t i, cur = 0; psycString *elem; @@ -43,7 +43,7 @@ psycRenderListRC psyc_renderList (psycList *list, char *buffer, size_t buflen) } static inline -size_t psyc_renderModifier (psycModifier *mod, char *buffer) +size_t psyc_render_modifier (psycModifier *mod, char *buffer) { size_t cur = 0; @@ -80,7 +80,7 @@ psycRenderRC psyc_render (psycPacket *packet, char *buffer, size_t buflen) // render routing modifiers for (i = 0; i < packet->routing.lines; i++) { - len = psyc_renderModifier(&packet->routing.modifiers[i], buffer + cur); + len = psyc_render_modifier(&packet->routing.modifiers[i], buffer + cur); cur += len; if (len <= 1) return PSYC_RENDER_ERROR_MODIFIER_NAME_MISSING; @@ -103,7 +103,7 @@ psycRenderRC psyc_render (psycPacket *packet, char *buffer, size_t buflen) { // render entity modifiers for (i = 0; i < packet->entity.lines; i++) - cur += psyc_renderModifier(&packet->entity.modifiers[i], buffer + cur); + cur += psyc_render_modifier(&packet->entity.modifiers[i], buffer + cur); if (packet->method.length) // add method\n { diff --git a/src/uniform.c b/src/uniform.c index 519e5c0..efc36bb 100644 --- a/src/uniform.c +++ b/src/uniform.c @@ -3,7 +3,7 @@ #include "psyc/uniform.h" #include "psyc/parse.h" -int psyc_parseUniform2 (psycUniform *uni, const char *str, size_t length) +int psyc_uniform_parse (psycUniform *uni, char *str, size_t length) { char c; psycString *p; @@ -19,7 +19,7 @@ int psyc_parseUniform2 (psycUniform *uni, const char *str, size_t length) uni->scheme.ptr = str; uni->scheme.length = pos++; break; - } else if (!psyc_isHostChar(c)) + } else if (!psyc_is_host_char(c)) return PSYC_PARSE_UNIFORM_INVALID_SCHEME; pos++; } @@ -52,7 +52,7 @@ int psyc_parseUniform2 (psycUniform *uni, const char *str, size_t length) break; case PSYC_UNIFORM_HOST: - if (psyc_isHostChar(c)) { + if (psyc_is_host_char(c)) { uni->host.length++; break; } @@ -74,7 +74,7 @@ int psyc_parseUniform2 (psycUniform *uni, const char *str, size_t length) break; case PSYC_UNIFORM_PORT: - if (psyc_isNumeric(c)) { + if (psyc_is_numeric(c)) { uni->port.length++; break; } @@ -118,7 +118,7 @@ int psyc_parseUniform2 (psycUniform *uni, const char *str, size_t length) break; case PSYC_UNIFORM_RESOURCE: - if (psyc_isNameChar(c)) { + if (psyc_is_name_char(c)) { uni->resource.length++; break; } else if (c == '#') { @@ -129,7 +129,7 @@ int psyc_parseUniform2 (psycUniform *uni, const char *str, size_t length) } else return PSYC_PARSE_UNIFORM_INVALID_RESOURCE; case PSYC_UNIFORM_CHANNEL: - if (psyc_isNameChar(c)) { + if (psyc_is_name_char(c)) { uni->channel.length++; break; } else return PSYC_PARSE_UNIFORM_INVALID_CHANNEL; @@ -165,8 +165,3 @@ int psyc_parseUniform2 (psycUniform *uni, const char *str, size_t length) uni->valid = 1; return uni->type; } - -int psyc_parseUniform (psycUniform *uni, psycString *str) -{ - return psyc_parseUniform2(uni, str->ptr, str->length); -} diff --git a/src/variable.c b/src/variable.c index b0de9f5..e13614b 100644 --- a/src/variable.c +++ b/src/variable.c @@ -3,7 +3,7 @@ /// Routing variables in alphabetical order. -const psycString psyc_routingVars[] = +const psycString psyc_routing_vars[] = { PSYC_C2STR("_amount_fragments"), PSYC_C2STR("_context"), @@ -27,7 +27,7 @@ const psycString psyc_routingVars[] = }; // Variable types in alphabetical order. -const psycMatchVar psyc_varTypes[] = +const psycMatchVar psyc_var_types[] = { {PSYC_C2STR("_amount"), PSYC_TYPE_AMOUNT}, {PSYC_C2STR("_color"), PSYC_TYPE_COLOR}, @@ -43,43 +43,42 @@ const psycMatchVar psyc_varTypes[] = {PSYC_C2STR("_time"), PSYC_TYPE_TIME}, }; -const size_t psyc_routingVarsNum = PSYC_NUM_ELEM(psyc_routingVars); -const size_t psyc_varTypesNum = PSYC_NUM_ELEM(psyc_varTypes); +const size_t psyc_routing_vars_num = PSYC_NUM_ELEM(psyc_routing_vars); +const size_t psyc_var_types_num = PSYC_NUM_ELEM(psyc_var_types); /** * Get the type of variable name. */ inline -psycBool psyc_isRoutingVar2(const char *name, size_t len) +psycBool psyc_var_is_routing (const char *name, size_t len) { - //return psyc_matchArray(psyc_routingVars, PSYC_NUM_ELEM(psyc_routingVars), name, len, 0); size_t cursor = 1; uint8_t i, m = 0; - int8_t matching[psyc_routingVarsNum]; // indexes of matching vars + int8_t matching[psyc_routing_vars_num]; // indexes of matching vars if (len < 2 || name[0] != '_') return PSYC_FALSE; // first find the vars with matching length - for (i=0; i= 0) { - for (i = m = 0; i < psyc_routingVarsNum; i++) + for (i = m = 0; i < psyc_routing_vars_num; i++) { if (matching[i] < 0) break; // reached the end of possible matches - if (psyc_routingVars[matching[i]].ptr[cursor] == name[cursor]) + if (psyc_routing_vars[matching[i]].ptr[cursor] == name[cursor]) matching[m++] = matching[i]; // found a match, update matching indexes - else if (psyc_routingVars[matching[i]].ptr[cursor] > name[cursor]) + else if (psyc_routing_vars[matching[i]].ptr[cursor] > name[cursor]) break; // passed the possible matches in alphabetical order in the array } - if (m < psyc_routingVarsNum) + if (m < psyc_routing_vars_num) matching[m] = -1; // mark the end of matching indexes cursor++; @@ -88,114 +87,13 @@ psycBool psyc_isRoutingVar2(const char *name, size_t len) return matching[0] >= 0 ? PSYC_TRUE : PSYC_FALSE; } -psycBool psyc_isRoutingVar(psycString *name) -{ - return psyc_isRoutingVar2(name->ptr, name->length); -} - /** * Get the type of variable name. */ inline -psycType psyc_getVarType2(const char *name, size_t len) +psycType psyc_var_type (const char *name, size_t len) { - //return psyc_matchArray(psyc_varTypes, PSYC_NUM_ELEM(psyc_varTypes), name, len, 1); - size_t cursor = 1; - uint8_t i, m = 0; - int8_t matching[psyc_varTypesNum]; // indexes of matching vars - - if (len < 2 || name[0] != '_') - return 0; - - // first find the vars with matching length - for (i=0; i psyc_varTypes[i].name.length && name[psyc_varTypes[i].name.length] == '_')) - matching[m++] = i; - - matching[m] = -1; // mark the end of matching indexes - - while (cursor < len && matching[0] >= 0) - { - for (i = m = 0; i < psyc_varTypesNum; i++) - { - if (matching[i] < 0) - break; // reached the end of possible matches - if (cursor < psyc_varTypes[matching[i]].name.length && - psyc_varTypes[matching[i]].name.ptr[cursor] == name[cursor]) - matching[m++] = matching[i]; // found a match, update matching indexes - else if (cursor == psyc_varTypes[matching[i]].name.length && name[cursor] == '_') - return psyc_varTypes[matching[0]].value; // _ after the end of a matching prefix - else if (psyc_varTypes[matching[i]].name.ptr[cursor] > name[cursor]) - break; // passed the possible matches in alphabetical order in the array - } - - if (m < psyc_varTypesNum) - matching[m] = -1; // mark the end of matching indexes - - cursor++; - } - - // return first match if found - return matching[0] >= 0 ? psyc_varTypes[matching[0]].value : 0; -} - -psycType psyc_getVarType(psycString *name) -{ - return psyc_getVarType2(name->ptr, name->length); -} - -/** - * Search for a variable name in an array. - * - * @param array The array to search, should be ordered alphabetically. - * @param size Size of array. - * @param name Name of variable to look for. - * @param namelen Length of name. - * @param startswith If true, look for any variable starting with name, - otherwise only exact matches are returned. - * @param matching A temporary array used for keeping track of results. - * Should be the same size as the array we're searching. - * - * @return The value of the matched variable in the array. - */ -int psyc_findVar(const psycMatchVar *array, size_t size, - const char *name, size_t namelen, - uint8_t startswith, int8_t *matching) -{ - size_t cursor = 1; - uint8_t i, m = 0; - //memset(&matching, -1, sizeof matching); - - if (namelen < 2 || name[0] != '_') - return 0; - - // first find the vars with matching length - for (i=0; i array[i].name.length && - name[array[i].name.length] == '_')) - matching[m++] = i; - - matching[m] = -1; // mark the end of matching indexes - - while (cursor < namelen && matching[0] >= 0) - { - for (i = m = 0; i < size; i++) - { - if (matching[i] < 0) - break; - if (array[matching[i]].name.ptr[cursor] == name[cursor]) - matching[m++] = matching[i]; // found a match, update matching indexes - else if (array[matching[i]].name.ptr[cursor] > name[cursor]) - break; // passed the possible matches in alphabetical order - } - - if (m < size) - matching[m] = -1; // mark the end of matching indexes - - cursor++; - } - - // return first match if found - return matching[0] >= 0 ? array[matching[0]].value : 0; + int8_t m[psyc_var_types_num]; + return psyc_in_array(psyc_var_types, psyc_var_types_num, + name, len, PSYC_YES, (int8_t*)&m); } diff --git a/test/Makefile b/test/Makefile index ed0de0b..05a41c2 100644 --- a/test/Makefile +++ b/test/Makefile @@ -3,7 +3,7 @@ DEBUG = 2 CFLAGS = -I../include -I../src -Wall -std=c99 ${OPT} LDFLAGS = -L../lib LOADLIBES = -lpsyc -lm -TARGETS = testPsyc testPsycSpeed testParser testMatch testRender testText isRoutingVar getVarType parseUniform +TARGETS = test_psyc test_psyc_speed test_parser test_match test_render test_text var_is_routing var_type uniform_parse O = test.o WRAPPER = DIET = diet @@ -20,16 +20,16 @@ endif all: ${TARGETS} it: all -testPsyc: LOADLIBES := ${LOADLIBES} ${LOADLIBES_NET} -testPsycSpeed: LOADLIBES := ${LOADLIBES} ${LOADLIBES_NET} -#testPsycSpeed: LOADLIBES := ${LOADLIBES_NET} +test_psyc: LOADLIBES := ${LOADLIBES} ${LOADLIBES_NET} +test_psyc_speed: LOADLIBES := ${LOADLIBES} ${LOADLIBES_NET} +#test_psyc_speed: LOADLIBES := ${LOADLIBES_NET} -testJson: LOADLIBES := ${LOADLIBES_NET} -ljson +test_json: LOADLIBES := ${LOADLIBES_NET} -ljson -testJsonGlib: CFLAGS := ${CFLAGS} -I/usr/include/json-glib-1.0 -I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include -testJsonGlib: LOADLIBES := ${LOADLIBES_NET} -ljson-glib-1.0 +test_json_glib: CFLAGS := ${CFLAGS} -I/usr/include/json-glib-1.0 -I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include +test_json_glib: LOADLIBES := ${LOADLIBES_NET} -ljson-glib-1.0 -testStrlen: LOADLIBES := ${LOADLIBES_NET} +test_strlen: LOADLIBES := ${LOADLIBES_NET} diet: WRAPPER = ${DIET} diet: all @@ -42,14 +42,14 @@ clean: rm -f ${TARGETS} $O test: ${TARGETS} - ./testRender - ./testMatch - ./testText - ./isRoutingVar - ./getVarType - ./parseUniform - x=0; for f in packets/[0-9]*; do echo ">> $$f"; ./testPsyc -f $$f | ${DIFF} -u $$f -; x=$$((x+$$?)); done; exit $$x - x=0; for f in packets/[0-9]*; do echo ">> $$f"; ./testPsyc -rf $$f | ${DIFF} -u $$f -; x=$$((x+$$?)); done; exit $$x + ./test_render + ./test_match + ./test_text + ./var_is_routing + ./var_type + ./uniform_parse + x=0; for f in packets/[0-9]*; do echo ">> $$f"; ./test_psyc -f $$f | ${DIFF} -u $$f -; x=$$((x+$$?)); done; exit $$x + x=0; for f in packets/[0-9]*; do echo ">> $$f"; ./test_psyc -rf $$f | ${DIFF} -u $$f -; x=$$((x+$$?)); done; exit $$x .NOTPARALLEL: nettestrun @@ -58,12 +58,12 @@ nettest: nettestfull nettestsplit nettestrun: srvstart pkt srvkill nettestfull: - ${MAKE} nettestrun; x=$$?; pkill -x testPsyc; exit $$x - ${MAKE} nettestrun srv_args=-r; x=$$?; pkill -x testPsyc; exit $$x + ${MAKE} nettestrun; x=$$?; pkill -x test_psyc; exit $$x + ${MAKE} nettestrun srv_args=-r; x=$$?; pkill -x test_psyc; exit $$x split_max = 10 nettestsplit: - x=0; for n in `seq 1 ${split_max}`; do ${MAKE} nettestrun srv_args="-b $$n" && ${MAKE} nettestrun srv_args="-r -b $$n" || break; done; x=$$?; pkill -x testPsyc; exit $$x + x=0; for n in `seq 1 ${split_max}`; do ${MAKE} nettestrun srv_args="-b $$n" && ${MAKE} nettestrun srv_args="-r -b $$n" || break; done; x=$$?; pkill -x test_psyc; exit $$x pkt: x=0; for f in packets/[0-9]*; do echo ">> $$f"; cat $$f | nc localhost ${PORT} | ${DIFF} -u $$f -; x=$$((x+$$?)); done; exit $$x @@ -75,37 +75,37 @@ pkterr: for f in packets/err-*; do echo ">> $$f"; cat $$f | nc localhost ${PORT}; done srvstart: - pkill -x testPsyc; exit 0 - ./testPsyc -p ${PORT} -S ${srv_args} & + pkill -x test_psyc; exit 0 + ./test_psyc -p ${PORT} -S ${srv_args} & srvkill: - pkill -x testPsyc + pkill -x test_psyc bench: bench-genpkts bench-psyc bench-psyc-bin bench-json bench-json-bin bench-xml bench-dir: @mkdir -p ../bench/results -bench-psyc: bench-dir testStrlen testPsycSpeed - for f in ../bench/packets/*.psyc; do bf=`basename $$f`; echo strlen: $$bf; ./testStrlen -sc 1000000 -f $$f | ${TEE} -a ../bench/results/$$bf.strlen; done - for f in ../bench/packets/*.psyc; do bf=`basename $$f`; echo libpsyc: $$f; ./testPsycSpeed -sc 1000000 -f $$f | ${TEE} -a ../bench/results/$$bf; done +bench-psyc: bench-dir test_strlen test_psyc_speed + for f in ../bench/packets/*.psyc; do bf=`basename $$f`; echo strlen: $$bf; ./test_strlen -sc 1000000 -f $$f | ${TEE} -a ../bench/results/$$bf.strlen; done + for f in ../bench/packets/*.psyc; do bf=`basename $$f`; echo libpsyc: $$f; ./test_psyc_speed -sc 1000000 -f $$f | ${TEE} -a ../bench/results/$$bf; done -bench-psyc-bin: bench-dir testStrlen testPsycSpeed - for f in `ls ../bench/packets/binary/*.psyc | sort -r`; do bf=`basename $$f`; echo "libpsyc: $$f * 1000000"; ./testPsycSpeed -sc 1000000 -f $$f | ${TEE} -a ../bench/results/$$bf; done - c=1000000; for f in `ls ../bench/packets/binary/*.psyc | sort -r`; do bf=`basename $$f`; echo "strlen: $$bf * $$c"; ./testStrlen -sc $$c -f $$f | ${TEE} -a ../bench/results/$$bf.strlen; c=$$((c/10)); done +bench-psyc-bin: bench-dir test_strlen test_psyc_speed + for f in `ls ../bench/packets/binary/*.psyc | sort -r`; do bf=`basename $$f`; echo "libpsyc: $$f * 1000000"; ./test_psyc_speed -sc 1000000 -f $$f | ${TEE} -a ../bench/results/$$bf; done + c=1000000; for f in `ls ../bench/packets/binary/*.psyc | sort -r`; do bf=`basename $$f`; echo "strlen: $$bf * $$c"; ./test_strlen -sc $$c -f $$f | ${TEE} -a ../bench/results/$$bf.strlen; c=$$((c/10)); done -bench-json: bench-dir testJson testJsonGlib -# for f in ../bench/packets/*.json; do bf=`basename $$f`; echo strlen: $$bf; ./testStrlen -sc 1000000 -f $$f | ${TEE} -a ../bench/results/$$bf.strlen; done - for f in ../bench/packets/*.json; do bf=`basename $$f`; echo json-c: $$bf; ./testJson -snc 1000000 -f $$f | ${TEE} -a ../bench/results/$$bf; done - for f in ../bench/packets/*.json; do bf=`basename $$f`; echo json-glib: $$bf; ./testJsonGlib -snc 1000000 -f $$f | ${TEE} -a ../bench/results/$$bf-glib; done +bench-json: bench-dir test_json test_json_glib +# for f in ../bench/packets/*.json; do bf=`basename $$f`; echo strlen: $$bf; ./test_strlen -sc 1000000 -f $$f | ${TEE} -a ../bench/results/$$bf.strlen; done + for f in ../bench/packets/*.json; do bf=`basename $$f`; echo json-c: $$bf; ./test_json -snc 1000000 -f $$f | ${TEE} -a ../bench/results/$$bf; done + for f in ../bench/packets/*.json; do bf=`basename $$f`; echo json-glib: $$bf; ./test_json_glib -snc 1000000 -f $$f | ${TEE} -a ../bench/results/$$bf-glib; done -bench-json-bin: bench-dir testJson testJsonGlib - c=1000000; for f in `ls ../bench/packets/binary/*.json | sort -r`; do bf=`basename $$f`; echo "json-c: $$bf * $$c"; ./testJson -snc $$c -f $$f | ${TEE} -a ../bench/results/$$bf; c=$$((c/10)); done - c=1000000; for f in `ls ../bench/packets/binary/*.json | sort -r`; do bf=`basename $$f`; echo "json-glib: $$bf * $$c"; ./testJsonGlib -snc $$c -f $$f | ${TEE} -a ../bench/results/$$bf-glib; c=$$((c/10)); done +bench-json-bin: bench-dir test_json test_json_glib + c=1000000; for f in `ls ../bench/packets/binary/*.json | sort -r`; do bf=`basename $$f`; echo "json-c: $$bf * $$c"; ./test_json -snc $$c -f $$f | ${TEE} -a ../bench/results/$$bf; c=$$((c/10)); done + c=1000000; for f in `ls ../bench/packets/binary/*.json | sort -r`; do bf=`basename $$f`; echo "json-glib: $$bf * $$c"; ./test_json_glib -snc $$c -f $$f | ${TEE} -a ../bench/results/$$bf-glib; c=$$((c/10)); done bench-xml: bench-dir @[[ -n "${xmlbench}" ]] || (echo xmlbench path needs to be set with xmlbench=/path/to/xmlbench; exit 1) -# for f in ../bench/packets/*.xml; do bf=`basename $$f`; echo strlen: $$bf; ./testStrlen -sc 1000000 -f $$f | ${TEE} -a ../bench/results/$$bf.strlen; done +# for f in ../bench/packets/*.xml; do bf=`basename $$f`; echo strlen: $$bf; ./test_strlen -sc 1000000 -f $$f | ${TEE} -a ../bench/results/$$bf.strlen; done for f in ../bench/packets/*.xml; do bf=`basename $$f`; echo libxml: $$bf; ${xmlbench}/parse/libxml 1000000 $$f | ${TEE} -a ../bench/results/$$bf-libxml; done for f in ../bench/packets/*.xml; do bf=`basename $$f`; echo libxml-sax: $$bf; ${xmlbench}/parse/libxml-sax 1000000 $$f | ${TEE} -a ../bench/results/$$bf-libxml-sax; done for f in ../bench/packets/*.xml; do bf=`basename $$f`; echo rapidxml: $$bf; ${xmlbench}/parse/rapidxml 1000000 $$f | ${TEE} -a ../bench/results/$$bf-rapidxml; done diff --git a/test/getVarType.c b/test/getVarType.c deleted file mode 100644 index de7f9e0..0000000 --- a/test/getVarType.c +++ /dev/null @@ -1,21 +0,0 @@ -#include -#include -#include -#include -#include - -int main() { - unless (psyc_getVarType2(PSYC_C2ARG("_list"))) return 1; - unless (psyc_getVarType2(PSYC_C2ARG("_list_foo"))) return 2; - unless (psyc_getVarType2(PSYC_C2ARG("_color_red"))) return 3; - if (psyc_getVarType2(PSYC_C2ARG("_last"))) return 4; - if (psyc_getVarType2(PSYC_C2ARG("_lost_foo"))) return 5; - if (psyc_getVarType2(PSYC_C2ARG("_colorful"))) return 6; - if (psyc_getVarType2(PSYC_C2ARG("_foo"))) return 7; - if (psyc_getVarType2(PSYC_C2ARG("bar"))) return 8; - if (psyc_getVarType2(PSYC_C2ARG("______"))) return 9; - if (psyc_getVarType2(PSYC_C2ARG("_"))) return 10; - - puts("psyc_getVarType passed all tests."); - return 0; // passed all tests -} diff --git a/test/isRoutingVar.c b/test/isRoutingVar.c deleted file mode 100644 index 4b6e431..0000000 --- a/test/isRoutingVar.c +++ /dev/null @@ -1,39 +0,0 @@ -#include -#include -#include -#include -#include - -int main() { -#if 0 - const char* vars[] = - { - "_source", - "_source_relay", - "_source_foo", - "_sourcherry", - "_foo", - "bar", - "_", - }; - - int i; - for (i = 0; i < sizeof(vars) / sizeof(*vars); i++) - { - printf(">> %s: %d %d\n", vars[i], sizeof(vars[i]), sizeof(*vars[i])); - printf("%s: %d\n", vars[i], psyc_isRoutingVar2(vars[i], strlen(vars[i]))); - } -#else - unless (psyc_isRoutingVar2(PSYC_C2ARG("_source"))) return 1; - unless (psyc_isRoutingVar2(PSYC_C2ARG("_source_relay"))) return 2; - if (psyc_isRoutingVar2(PSYC_C2ARG("_source_foo"))) return 3; - if (psyc_isRoutingVar2(PSYC_C2ARG("_sourcherry"))) return 4; - if (psyc_isRoutingVar2(PSYC_C2ARG("_sour"))) return 5; - if (psyc_isRoutingVar2(PSYC_C2ARG("_foo"))) return 6; - if (psyc_isRoutingVar2(PSYC_C2ARG("bar"))) return 7; - if (psyc_isRoutingVar2(PSYC_C2ARG("_"))) return 8; - - puts("psyc_isRoutingVar passed all tests."); -#endif - return 0; // passed all tests -} diff --git a/test/testJson.c b/test/test_json.c similarity index 100% rename from test/testJson.c rename to test/test_json.c diff --git a/test/testJsonGlib.c b/test/test_json_glib.c similarity index 100% rename from test/testJsonGlib.c rename to test/test_json_glib.c diff --git a/test/testMatch.c b/test/test_match.c similarity index 100% rename from test/testMatch.c rename to test/test_match.c diff --git a/test/testParser.c b/test/test_parser.c similarity index 84% rename from test/testParser.c rename to test/test_parser.c index 641c70d..9566692 100644 --- a/test/testParser.c +++ b/test/test_parser.c @@ -28,12 +28,9 @@ int main (int argc, char **argv) printf(">> PARSE\n"); } - if (routing_only) - psyc_initParseState2(&state, PSYC_PARSE_ROUTING_ONLY); - else - psyc_initParseState(&state); - - psyc_setParseBuffer2(&state, buffer, idx); + psyc_parse_state_init(&state, routing_only ? + PSYC_PARSE_ROUTING_ONLY : PSYC_PARSE_ALL); + psyc_parse_buffer_set(&state, buffer, idx); // try parsing that now do @@ -59,15 +56,15 @@ int main (int argc, char **argv) (int)name.length, name.ptr, (int)value.length, value.ptr); - if (psyc_isListVar(&name)) + if (psyc_var_is_list(PSYC_S2ARG(name))) { if (verbose) printf(">> LIST START\n"); - psyc_initParseListState(&listState); - psyc_setParseListBuffer(&listState, value); + psyc_parse_list_state_init(&listState); + psyc_parse_list_buffer_set(&listState, PSYC_S2ARG(value)); - while ((ret = psyc_parseList(&listState, &elem))) + while ((ret = psyc_parse_list(&listState, &elem))) { switch (ret) { diff --git a/test/testPsyc.c b/test/test_psyc.c similarity index 90% rename from test/testPsyc.c rename to test/test_psyc.c index 2deb620..1ce375f 100644 --- a/test/testPsyc.c +++ b/test/test_psyc.c @@ -37,10 +37,8 @@ void resetString (psycString *s, uint8_t freeptr); // initialize parser & packet variables void test_init (int i) { // reset parser state & packet - if (routing_only) - psyc_initParseState2(&parsers[i], PSYC_PARSE_ROUTING_ONLY); - else - psyc_initParseState(&parsers[i]); + psyc_parse_state_init(&parsers[i], routing_only ? + PSYC_PARSE_ROUTING_ONLY : PSYC_PARSE_ALL); memset(&packets[i], 0, sizeof(psycPacket)); memset(&routing[i], 0, sizeof(psycModifier) * ROUTING_LINES); @@ -76,7 +74,7 @@ int test_input (int i, char *recvbuf, size_t nbytes) { size_t len; // Set buffer with data for the parser. - psyc_setParseBuffer2(parser, parsebuf, contbytes + nbytes); + psyc_parse_buffer_set(parser, parsebuf, contbytes + nbytes); contbytes = 0; oper = 0; name.length = 0; @@ -111,7 +109,7 @@ int test_input (int i, char *recvbuf, size_t nbytes) { if (ret == PSYC_PARSE_ENTITY || ret == PSYC_PARSE_ENTITY_END) { packet->entity.lines++; - mod->flag = psyc_isParseValueLengthFound(parser) ? + mod->flag = psyc_parse_value_length_found(parser) ? PSYC_MODIFIER_NEED_LENGTH : PSYC_MODIFIER_NO_LENGTH; } break; @@ -133,7 +131,7 @@ int test_input (int i, char *recvbuf, size_t nbytes) { ret = -1; if (!no_render) { - packet->flag = psyc_isParseContentLengthFound(parser) ? + packet->flag = psyc_parse_content_length_found(parser) ? PSYC_PACKET_NEED_LENGTH : PSYC_PACKET_NO_LENGTH; if (routing_only) { @@ -141,7 +139,7 @@ int test_input (int i, char *recvbuf, size_t nbytes) { resetString(&(packet->data), 0); } - psyc_setPacketLength(packet); + psyc_packet_length_set(packet); if (psyc_render(packet, sendbuf, SEND_BUF_SIZE) == PSYC_RENDER_SUCCESS) { if (!quiet) { @@ -190,13 +188,13 @@ int test_input (int i, char *recvbuf, size_t nbytes) { if (verbose >= 2) printf("# Insufficient data.\n"); - contbytes = psyc_getParseRemainingLength(parser); + contbytes = psyc_parse_remaining_length(parser); if (contbytes > 0) { // copy end of parsebuf before start of recvbuf if (verbose >= 3) - printf("# remaining = [%.*s]\n", (int)contbytes, psyc_getParseRemainingBuffer(parser)); + printf("# remaining = [%.*s]\n", (int)contbytes, psyc_parse_remaining_buffer(parser)); assert(contbytes <= CONT_BUF_SIZE); // make sure it's still in the buffer - memmove(recvbuf - contbytes, psyc_getParseRemainingBuffer(parser), contbytes); + memmove(recvbuf - contbytes, psyc_parse_remaining_buffer(parser), contbytes); } ret = 0; break; @@ -237,8 +235,8 @@ int test_input (int i, char *recvbuf, size_t nbytes) { if (value.length) { if (!pvalue->length) { - if (psyc_isParseValueLengthFound(parser)) - len = psyc_getParseValueLength(parser); + if (psyc_parse_value_length_found(parser)) + len = psyc_parse_value_length(parser); else len = value.length; pvalue->ptr = malloc(len); @@ -272,15 +270,15 @@ int test_input (int i, char *recvbuf, size_t nbytes) { name.length = 0; value.length = 0; - if (psyc_isListVar(pname)) { + if (psyc_var_is_list(PSYC_S2ARG(*pname))) { if (verbose >= 2) printf("## LIST START\n"); - psyc_initParseListState(&listState); - psyc_setParseListBuffer(&listState, *pvalue); + psyc_parse_list_state_init(&listState); + psyc_parse_list_buffer_set(&listState, PSYC_S2ARG(*pvalue)); do { - retl = psyc_parseList(&listState, &elem); + retl = psyc_parse_list(&listState, &elem); switch (retl) { case PSYC_PARSE_LIST_END: retl = 0; diff --git a/test/testPsycSpeed.c b/test/test_psyc_speed.c similarity index 88% rename from test/testPsycSpeed.c rename to test/test_psyc_speed.c index b17f5d8..3abcfe1 100644 --- a/test/testPsycSpeed.c +++ b/test/test_psyc_speed.c @@ -26,10 +26,8 @@ size_t count = 1, recv_buf_size; psycParseState parser; void test_init (int i) { - if (routing_only) - psyc_initParseState2(&parser, PSYC_PARSE_ROUTING_ONLY); - else - psyc_initParseState(&parser); + psyc_parse_state_init(&parser, routing_only ? + PSYC_PARSE_ROUTING_ONLY : PSYC_PARSE_ALL); } int test_input (int i, char *recvbuf, size_t nbytes) { @@ -37,7 +35,7 @@ int test_input (int i, char *recvbuf, size_t nbytes) { psycString name, value; int ret; - psyc_setParseBuffer2(&parser, recvbuf, nbytes); + psyc_parse_buffer_set(&parser, recvbuf, nbytes); for (;;) { ret = psyc_parse(&parser, &oper, &name, &value); diff --git a/test/testRender.c b/test/test_render.c similarity index 76% rename from test/testRender.c rename to test/test_render.c index 1f1f61b..59432b3 100644 --- a/test/testRender.c +++ b/test/test_render.c @@ -12,19 +12,19 @@ int testPresence (const char *avail, int availlen, const char *rendered, uint8_t verbose) { psycModifier routing[] = { - psyc_newModifier2(C_GLYPH_OPERATOR_SET, PSYC_C2ARG("_context"), PSYC_C2ARG(myUNI), + psyc_modifier_new(C_GLYPH_OPERATOR_SET, PSYC_C2ARG("_context"), PSYC_C2ARG(myUNI), PSYC_MODIFIER_ROUTING), }; psycModifier entity[] = { // presence is to be assigned permanently in distributed state - psyc_newModifier2(C_GLYPH_OPERATOR_ASSIGN, PSYC_C2ARG("_degree_availability"), + psyc_modifier_new(C_GLYPH_OPERATOR_ASSIGN, PSYC_C2ARG("_degree_availability"), avail, availlen, PSYC_MODIFIER_CHECK_LENGTH), - psyc_newModifier2(C_GLYPH_OPERATOR_ASSIGN, PSYC_C2ARG("_description_presence"), + psyc_modifier_new(C_GLYPH_OPERATOR_ASSIGN, PSYC_C2ARG("_description_presence"), desc, desclen, PSYC_MODIFIER_CHECK_LENGTH), }; - psycPacket packet = psyc_newPacket2(routing, PSYC_NUM_ELEM(routing), + psycPacket packet = psyc_packet_new(routing, PSYC_NUM_ELEM(routing), entity, PSYC_NUM_ELEM(entity), PSYC_C2ARG("_notice_presence"), NULL, 0, @@ -40,9 +40,9 @@ int testPresence (const char *avail, int availlen, int testList (const char *rendered, uint8_t verbose) { psycModifier routing[] = { - psyc_newModifier2(C_GLYPH_OPERATOR_SET, PSYC_C2ARG("_source"), PSYC_C2ARG(myUNI), + psyc_modifier_new(C_GLYPH_OPERATOR_SET, PSYC_C2ARG("_source"), PSYC_C2ARG(myUNI), PSYC_MODIFIER_ROUTING), - psyc_newModifier2(C_GLYPH_OPERATOR_SET, PSYC_C2ARG("_context"), PSYC_C2ARG(myUNI), + psyc_modifier_new(C_GLYPH_OPERATOR_SET, PSYC_C2ARG("_context"), PSYC_C2ARG(myUNI), PSYC_MODIFIER_ROUTING), }; @@ -59,21 +59,21 @@ int testList (const char *rendered, uint8_t verbose) }; psycList list_text, list_bin; - list_text = psyc_newList(elems_text, PSYC_NUM_ELEM(elems_text), PSYC_LIST_CHECK_LENGTH); - list_bin = psyc_newList(elems_bin, PSYC_NUM_ELEM(elems_bin), PSYC_LIST_CHECK_LENGTH); + list_text = psyc_list_new(elems_text, PSYC_NUM_ELEM(elems_text), PSYC_LIST_CHECK_LENGTH); + list_bin = psyc_list_new(elems_bin, PSYC_NUM_ELEM(elems_bin), PSYC_LIST_CHECK_LENGTH); char buf_text[32], buf_bin[32]; - psyc_renderList(&list_text, buf_text, sizeof(buf_text)); - psyc_renderList(&list_bin, buf_bin, sizeof(buf_bin)); + psyc_render_list(&list_text, buf_text, sizeof(buf_text)); + psyc_render_list(&list_bin, buf_bin, sizeof(buf_bin)); psycModifier entity[] = { - psyc_newModifier2(C_GLYPH_OPERATOR_SET, PSYC_C2ARG("_list_text"), + psyc_modifier_new(C_GLYPH_OPERATOR_SET, PSYC_C2ARG("_list_text"), buf_text, list_text.length, list_text.flag), - psyc_newModifier2(C_GLYPH_OPERATOR_SET, PSYC_C2ARG("_list_binary"), + psyc_modifier_new(C_GLYPH_OPERATOR_SET, PSYC_C2ARG("_list_binary"), buf_bin, list_bin.length, list_bin.flag), }; - psycPacket packet = psyc_newPacket2(routing, PSYC_NUM_ELEM(routing), + psycPacket packet = psyc_packet_new(routing, PSYC_NUM_ELEM(routing), entity, PSYC_NUM_ELEM(entity), PSYC_C2ARG("_test_list"), PSYC_C2ARG("list test"), diff --git a/test/testStrlen.c b/test/test_strlen.c similarity index 100% rename from test/testStrlen.c rename to test/test_strlen.c diff --git a/test/testText.c b/test/test_text.c similarity index 92% rename from test/testText.c rename to test/test_text.c index 5f667f5..214d106 100644 --- a/test/testText.c +++ b/test/test_text.c @@ -38,17 +38,17 @@ int testText (char *template, size_t tmplen, char *buffer, size_t buflen, psycSt size_t length = 0; psycTextRC ret; - psyc_initTextState(&state, template, tmplen, buffer, buflen); + psyc_text_state_init(&state, template, tmplen, buffer, buflen); do { ret = psyc_text(&state, getValue, NULL); - length += psyc_getTextBytesWritten(&state); + length += psyc_text_bytes_written(&state); switch (ret) { case PSYC_TEXT_INCOMPLETE: if (verbose) printf("# %.*s...\n", (int)length, buffer); - psyc_setTextBuffer2(&state, buffer + length, BUFSIZE - length); + psyc_text_buffer_set(&state, buffer + length, BUFSIZE - length); break; case PSYC_TEXT_COMPLETE: if (verbose) diff --git a/test/parseUniform.c b/test/uniform_parse.c similarity index 86% rename from test/parseUniform.c rename to test/uniform_parse.c index ae20c5e..ff5d307 100644 --- a/test/parseUniform.c +++ b/test/uniform_parse.c @@ -4,11 +4,11 @@ #include void -testUniform(char *str, int ret) { +testUniform (char *str, int ret) { psycUniform *uni = malloc(sizeof(psycUniform)); memset(uni, 0, sizeof(psycUniform)); printf("%s\n", str); - int r = psyc_parseUniform2(uni, str, strlen(str)); + int r = psyc_uniform_parse(uni, str, strlen(str)); PP(("[%.*s] : [%.*s] [%.*s] : [%.*s] [%.*s] / [%.*s] # [%.*s]\n[%.*s] [%.*s]\n[%.*s]\n\n", (int)PSYC_S2ARG2(uni->scheme), @@ -24,12 +24,12 @@ testUniform(char *str, int ret) { free(uni); if (r != ret) { - fprintf(stderr, "ERROR: psyc_parseUniform returned %d instead of %d\n", r, ret); + fprintf(stderr, "ERROR: psyc_uniform_parse returned %d instead of %d\n", r, ret); exit(1); } } -int main() { +int main () { testUniform("psyc://foo.tld:4404d/@bar#baz", PSYC_SCHEME_PSYC); testUniform("psyc://foo:4405/~bar", PSYC_SCHEME_PSYC); testUniform("psyc://foo:1234", PSYC_SCHEME_PSYC); @@ -46,6 +46,6 @@ int main() { testUniform("psyc://host:d/~foo", PSYC_PARSE_UNIFORM_INVALID_PORT); testUniform("psyc://1234567890abcdef:1g/~foo", PSYC_PARSE_UNIFORM_INVALID_TRANSPORT); - printf("SUCCESS: psyc_parseUniform passed all tests.\n"); + printf("SUCCESS: psyc_uniform_parse passed all tests.\n"); return 0; } diff --git a/test/var_is_routing.c b/test/var_is_routing.c new file mode 100644 index 0000000..bb3ffca --- /dev/null +++ b/test/var_is_routing.c @@ -0,0 +1,39 @@ +#include +#include +#include +#include +#include + +int main() { +#if 0 + const char* vars[] = + { + "_source", + "_source_relay", + "_source_foo", + "_sourcherry", + "_foo", + "bar", + "_", + }; + + int i; + for (i = 0; i < sizeof(vars) / sizeof(*vars); i++) + { + printf(">> %s: %d %d\n", vars[i], sizeof(vars[i]), sizeof(*vars[i])); + printf("%s: %d\n", vars[i], psyc_var_is_routing(vars[i], strlen(vars[i]))); + } +#else + unless (psyc_var_is_routing(PSYC_C2ARG("_source"))) return 1; + unless (psyc_var_is_routing(PSYC_C2ARG("_source_relay"))) return 2; + if (psyc_var_is_routing(PSYC_C2ARG("_source_foo"))) return 3; + if (psyc_var_is_routing(PSYC_C2ARG("_sourcherry"))) return 4; + if (psyc_var_is_routing(PSYC_C2ARG("_sour"))) return 5; + if (psyc_var_is_routing(PSYC_C2ARG("_foo"))) return 6; + if (psyc_var_is_routing(PSYC_C2ARG("bar"))) return 7; + if (psyc_var_is_routing(PSYC_C2ARG("_"))) return 8; + + puts("psyc_var_is_routing passed all tests."); +#endif + return 0; // passed all tests +} diff --git a/test/var_type.c b/test/var_type.c new file mode 100644 index 0000000..b043979 --- /dev/null +++ b/test/var_type.c @@ -0,0 +1,21 @@ +#include +#include +#include +#include +#include + +int main() { + unless (psyc_var_type(PSYC_C2ARG("_list"))) return 1; + unless (psyc_var_type(PSYC_C2ARG("_list_foo"))) return 2; + unless (psyc_var_type(PSYC_C2ARG("_color_red"))) return 3; + if (psyc_var_type(PSYC_C2ARG("_last"))) return 4; + if (psyc_var_type(PSYC_C2ARG("_lost_foo"))) return 5; + if (psyc_var_type(PSYC_C2ARG("_colorful"))) return 6; + if (psyc_var_type(PSYC_C2ARG("_foo"))) return 7; + if (psyc_var_type(PSYC_C2ARG("bar"))) return 8; + if (psyc_var_type(PSYC_C2ARG("______"))) return 9; + if (psyc_var_type(PSYC_C2ARG("_"))) return 10; + + puts("psyc_var_type passed all tests."); + return 0; // passed all tests +}