psyc-mirrors
/
libpsyc
mirror of git://git.psyc.eu/libpsyc
1
0
Fork 0
Code Issues Releases Wiki Activity

refactoring - renamed functions

This commit is contained in:
tg(x) 2011-10-31 20:04:16 +01:00
parent 0a95b0a518
commit 260bba0c46
37 changed files with 570 additions and 691 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
.gitignore vendored
View File

@ -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

8
d/include/psyc/common.d
View File

@ -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.

43
d/include/psyc/packet.d
View File

@ -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);

2
d/include/psyc/parse.d
View File

@ -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

14
d/include/psyc/render.d
View File

@ -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);

66
doc/renames Normal file
View File

@ -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

82
include/psyc.h
View File

@ -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

79
include/psyc/packet.h
View File

@ -17,6 +17,7 @@
#include <psyc.h>
#include <psyc/syntax.h>
#include <math.h>
/** 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

144
include/psyc/parse.h
View File

@ -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

14
include/psyc/render.h
View File

@ -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

38
include/psyc/text.h
View File

@ -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 "<!--" and "-->" if you use
* the psyc_initTextState2 variant.
* the psyc_text_state_init_custom variant.
*
* @see http://about.psyc.eu/psyctext
**/

4
include/psyc/uniform.h
View File

@ -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

37
include/psyc/variable.h Normal file
View File

@ -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

52
pike/psyc.cmod
View File

@ -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

2
src/lib.h
View File

@ -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

64
src/match.c
View File

@ -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<size; i++)
if (kwlen == array[i].key.length ||
(inherit && kwlen > 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) {

89
src/packet.c
View File

@ -2,16 +2,8 @@
#include <psyc/syntax.h>
#include <psyc/packet.h>
#include <math.h>
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;
}

44
src/parse.c
View File

@ -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;

4
src/psyc_parser_cb.h
View File

@ -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
*
*/

8
src/render.c
View File

@ -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
{

17
src/uniform.c
View File

@ -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);
}

134
src/variable.c
View File

@ -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<psyc_routingVarsNum; i++)
if (len == psyc_routingVars[i].length)
for (i=0; i<psyc_routing_vars_num; i++)
if (len == psyc_routing_vars[i].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_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_varTypesNum; i++)
if (len == psyc_varTypes[i].name.length || (len > 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<size; i++)
if (namelen == array[i].name.length ||
(startswith && namelen > 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);
}

72
test/Makefile
View File

@ -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

21
test/getVarType.c
View File

@ -1,21 +0,0 @@
#include <psyc.h>
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <lib.h>
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
}

39
test/isRoutingVar.c
View File

@ -1,39 +0,0 @@
#include <psyc.h>
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <lib.h>
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
}

0
test/testJson.c → test/test_json.c
View File

0
test/testJsonGlib.c → test/test_json_glib.c
View File

0
test/testMatch.c → test/test_match.c
View File

17
test/testParser.c → test/test_parser.c
View File

@ -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)
{

32
test/testPsyc.c → test/test_psyc.c
View File

@ -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;

8
test/testPsycSpeed.c → test/test_psyc_speed.c
View File

@ -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);

26
test/testRender.c → test/test_render.c
View File

@ -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"),

0
test/testStrlen.c → test/test_strlen.c
View File

6
test/testText.c → test/test_text.c
View File

@ -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)

10
test/parseUniform.c → test/uniform_parse.c
View File

@ -4,11 +4,11 @@
#include <lib.h>
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;
}

39
test/var_is_routing.c Normal file
View File

@ -0,0 +1,39 @@
#include <psyc.h>
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <lib.h>
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
}

21
test/var_type.c Normal file
View File

@ -0,0 +1,21 @@
#include <psyc.h>
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <lib.h>
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
}