psyc-mirrors/libpsyc
1
0
Fork 0
mirror of git://git.psyc.eu/libpsyc synced 2024-08-15 03:19:02 +00:00
Code Issues Releases Wiki Activity

new style: psyc_functions, psycTypes, PSYC_MACROS

Browse source
This commit is contained in:
psyc://psyced.org/~lynX 2011-04-25 23:40:38 +02:00
parent 7dc8effab6
commit e48a6ab1eb
15 changed files with 204 additions and 203 deletions
Download patch file Download diff file Expand all files Collapse all files

88
include/psyc.h
View file

@ -28,7 +28,7 @@ typedef enum
{ {
PSYC_FALSE = 0, PSYC_FALSE = 0,
PSYC_TRUE = 1, PSYC_TRUE = 1,
} PSYC_Bool; } psycBool;
/** /**
* PSYC packet parts. * PSYC packet parts.
@ -42,7 +42,7 @@ typedef enum
PSYC_PART_METHOD, PSYC_PART_METHOD,
PSYC_PART_DATA, PSYC_PART_DATA,
PSYC_PART_END, PSYC_PART_END,
} PSYC_Part; } psycPart;
/** /**
* Different types that a variable can have. * Different types that a variable can have.
@ -67,7 +67,7 @@ typedef enum
PSYC_TYPE_PAGE, PSYC_TYPE_PAGE,
PSYC_TYPE_UNIFORM, PSYC_TYPE_UNIFORM,
PSYC_TYPE_TIME, PSYC_TYPE_TIME,
} PSYC_Type; } psycType;
/** /**
* List types. * List types.
@ -77,7 +77,7 @@ typedef enum
{ {
PSYC_LIST_TEXT = 1, PSYC_LIST_TEXT = 1,
PSYC_LIST_BINARY = 2, PSYC_LIST_BINARY = 2,
} PSYC_ListType; } psycListType;
typedef enum typedef enum
{ {
@ -85,30 +85,30 @@ typedef enum
PSYC_MODIFIER_NEED_LENGTH = 1, PSYC_MODIFIER_NEED_LENGTH = 1,
PSYC_MODIFIER_NO_LENGTH = 2, PSYC_MODIFIER_NO_LENGTH = 2,
PSYC_MODIFIER_ROUTING = 3, PSYC_MODIFIER_ROUTING = 3,
} PSYC_ModifierFlag; } psycModifierFlag;
typedef enum typedef enum
{ {
PSYC_PACKET_CHECK_LENGTH = 0, PSYC_PACKET_CHECK_LENGTH = 0,
PSYC_PACKET_NEED_LENGTH = 1, PSYC_PACKET_NEED_LENGTH = 1,
PSYC_PACKET_NO_LENGTH = 2, PSYC_PACKET_NO_LENGTH = 2,
} PSYC_PacketFlag; } psycPacketFlag;
typedef struct typedef struct
{ {
size_t length; size_t length;
const char *ptr; const char *ptr;
} PSYC_String; } psycString;
/** /**
* Shortcut for creating a PSYC_String. * Shortcut for creating a psycString.
* *
* @param memory Pointer to the buffer. * @param memory Pointer to the buffer.
* @param length Length of that buffer. * @param length Length of that buffer.
* *
* @return An instance of the PSYC_String struct. * @return An instance of the psycString struct.
*/ */
inline PSYC_String PSYC_newString (const char *str, size_t strlen); inline psycString psyc_newString (const char *str, size_t strlen);
#define PSYC_C2STR(string) {sizeof(string)-1, string} #define PSYC_C2STR(string) {sizeof(string)-1, string}
#define PSYC_C2ARG(string) string, sizeof(string)-1 #define PSYC_C2ARG(string) string, sizeof(string)-1
@ -117,88 +117,88 @@ inline PSYC_String PSYC_newString (const char *str, size_t strlen);
typedef struct typedef struct
{ {
char oper; // not call it 'operator' as C++ may not like that.. char oper; // not call it 'operator' as C++ may not like that..
PSYC_String name; psycString name;
PSYC_String value; psycString value;
PSYC_ModifierFlag flag; psycModifierFlag flag;
} PSYC_Modifier; } psycModifier;
typedef struct typedef struct
{ {
size_t lines; size_t lines;
PSYC_Modifier *modifiers; psycModifier *modifiers;
} PSYC_ModifierArray; } psycModifierArray;
/* intermediate struct for a PSYC packet */ /* intermediate struct for a PSYC packet */
typedef struct typedef struct
{ {
PSYC_ModifierArray routing; ///< Routing header. psycModifierArray routing; ///< Routing header.
PSYC_ModifierArray entity; ///< Entitiy header. psycModifierArray entity; ///< Entitiy header.
PSYC_String method; psycString method;
PSYC_String data; psycString data;
size_t routingLength; ///< Length of routing part. size_t routingLength; ///< Length of routing part.
size_t contentLength; ///< Length of content part. size_t contentLength; ///< Length of content part.
size_t length; ///< Total length of packet. size_t length; ///< Total length of packet.
PSYC_PacketFlag flag; psycPacketFlag flag;
} PSYC_Packet; } psycPacket;
inline int PSYC_version(); inline int psyc_version();
inline PSYC_Modifier PSYC_newModifier(char oper, PSYC_String *name, PSYC_String *value, inline psycModifier psyc_newModifier(char oper, psycString *name, psycString *value,
PSYC_ModifierFlag flag); psycModifierFlag flag);
inline PSYC_Modifier PSYC_newModifier2(char oper, inline psycModifier psyc_newModifier2(char oper,
const char *name, size_t namelen, const char *name, size_t namelen,
const char *value, size_t valuelen, const char *value, size_t valuelen,
PSYC_ModifierFlag flag); psycModifierFlag flag);
inline PSYC_Packet PSYC_newPacket(PSYC_ModifierArray *routing, inline psycPacket psyc_newPacket(psycModifierArray *routing,
PSYC_ModifierArray *entity, psycModifierArray *entity,
PSYC_String *method, PSYC_String *data, psycString *method, psycString *data,
PSYC_PacketFlag flag); psycPacketFlag flag);
inline PSYC_Packet PSYC_newPacket2(PSYC_Modifier *routing, size_t routinglen, inline psycPacket psyc_newPacket2(psycModifier *routing, size_t routinglen,
PSYC_Modifier *entity, size_t entitylen, psycModifier *entity, size_t entitylen,
const char *method, size_t methodlen, const char *method, size_t methodlen,
const char *data, size_t datalen, const char *data, size_t datalen,
PSYC_PacketFlag flag); psycPacketFlag flag);
/// Routing vars in alphabetical order. /// Routing vars in alphabetical order.
extern const PSYC_String PSYC_routingVars[]; extern const psycString PSYC_routingVars[];
/// Number of routing vars. /// Number of routing vars.
extern const size_t PSYC_routingVarsNum; extern const size_t PSYC_routingVarsNum;
/** /**
* Get the type of variable name. * Get the type of variable name.
*/ */
PSYC_Bool PSYC_isRoutingVar(const char *name, size_t len); psycBool psyc_isRoutingVar(const char *name, size_t len);
/** /**
* Get the type of variable name. * Get the type of variable name.
*/ */
PSYC_Type PSYC_getVarType(char *name, size_t len); psycType psyc_getVarType(char *name, size_t len);
/** /**
* Checks if long keyword string inherits from short keyword string. * Checks if long keyword string inherits from short keyword string.
*/ */
int PSYC_inherits(char *sho, size_t slen, int psyc_inherits(char *sho, size_t slen,
char *lon, size_t llen); char *lon, size_t llen);
/** /**
* Checks if short keyword string matches long keyword string. * Checks if short keyword string matches long keyword string.
*/ */
int PSYC_matches(char *sho, size_t slen, int psyc_matches(char *sho, size_t slen,
char *lon, size_t llen); char *lon, size_t llen);
/** /**
* Callback for PSYC_text() that produces a value for a match. * Callback for psyc_text() that produces a value for a match.
* *
* The application looks up a match such as _fruit from [_fruit] and * The application looks up a match such as _fruit from [_fruit] and
* if found writes its current value from its variable store into the * if found writes its current value from its variable store into the
* outgoing buffer.. "Apple" for example. The template returns the * outgoing buffer.. "Apple" for example. The template returns the
* number of bytes written. 0 is a legal return value. Should the * number of bytes written. 0 is a legal return value. Should the
* callback return -1, PSYC_text leaves the original template text as is. * callback return -1, psyc_text leaves the original template text as is.
*/ */
typedef int (*PSYC_textCB)(uint8_t *match, size_t mlen, typedef int (*psyctextCB)(uint8_t *match, size_t mlen,
uint8_t **buffer, size_t *blen); uint8_t **buffer, size_t *blen);
/** /**
@ -214,9 +214,9 @@ typedef int (*PSYC_textCB)(uint8_t *match, size_t mlen,
* *
* See also http://about.psyc.eu/psyctext * See also http://about.psyc.eu/psyctext
*/ */
int PSYC_text(uint8_t *template, size_t tlen, int psyc_text(uint8_t *template, size_t tlen,
uint8_t **buffer, size_t *blen, uint8_t **buffer, size_t *blen,
PSYC_textCB lookupValue, psyctextCB lookupValue,
char *braceOpen, char *braceClose); char *braceOpen, char *braceClose);
#endif // PSYC_H #endif // PSYC_H

50
include/psyc/parser.h
View file

@ -22,11 +22,11 @@
typedef enum typedef enum
{ {
PSYC_PARSE_HEADER_ONLY = 1, PSYC_PARSE_HEADER_ONLY = 1,
} PSYC_ParseFlag; } psycParseFlag;
/** /**
* The return value definitions for the packet parsing function. * The return value definitions for the packet parsing function.
* @see PSYC_parse() * @see psyc_parse()
*/ */
typedef enum typedef enum
{ {
@ -59,11 +59,11 @@ typedef enum
PSYC_PARSE_COMPLETE = 7, PSYC_PARSE_COMPLETE = 7,
/// Binary value parsing incomplete, used internally. /// Binary value parsing incomplete, used internally.
PSYC_PARSE_INCOMPLETE = 8, PSYC_PARSE_INCOMPLETE = 8,
} PSYC_ParseRC; } psycParseRC;
/** /**
* The return value definitions for the list parsing function. * The return value definitions for the list parsing function.
* @see PSYC_parseList() * @see psyc_parseList()
*/ */
typedef enum typedef enum
{ {
@ -78,7 +78,7 @@ typedef enum
PSYC_PARSE_LIST_END = 2, PSYC_PARSE_LIST_END = 2,
/// Binary list is incomplete. /// Binary list is incomplete.
PSYC_PARSE_LIST_INCOMPLETE = 3, PSYC_PARSE_LIST_INCOMPLETE = 3,
} PSYC_ParseListRC; } psycParseListRC;
/** /**
* Struct for keeping parser state. * Struct for keeping parser state.
@ -87,16 +87,16 @@ typedef struct
{ {
size_t cursor; ///< current position in buffer size_t cursor; ///< current position in buffer
size_t startc; ///< position where the parsing would be resumed size_t startc; ///< position where the parsing would be resumed
PSYC_String buffer; ///< buffer with data to be parsed psycString buffer; ///< buffer with data to be parsed
uint8_t flags; ///< flags for the parser, see PSYC_ParseFlag uint8_t flags; ///< flags for the parser, see psycParseFlag
PSYC_Part part; ///< part of the packet being parsed currently psycPart part; ///< part of the packet being parsed currently
size_t contentParsed; ///< number of bytes parsed from the content so far size_t contentParsed; ///< number of bytes parsed from the content so far
size_t contentLength; ///< expected length of the content size_t contentLength; ///< expected length of the content
PSYC_Bool contentLengthFound; ///< is there a length given for this packet? psycBool contentLengthFound; ///< is there a length given for this packet?
size_t valueParsed; ///< number of bytes parsed from the value so far size_t valueParsed; ///< number of bytes parsed from the value so far
size_t valueLength; ///< expected length of the value size_t valueLength; ///< expected length of the value
} PSYC_ParseState; } psycParseState;
/** /**
* Struct for keeping list parser state. * Struct for keeping list parser state.
@ -105,60 +105,60 @@ typedef struct
{ {
size_t cursor; ///< current position in buffer size_t cursor; ///< current position in buffer
size_t startc; ///< line start position size_t startc; ///< line start position
PSYC_String buffer; psycString buffer;
PSYC_ListType type; ///< list type psycListType type; ///< list type
size_t elemParsed; ///< number of bytes parsed from the elem so far size_t elemParsed; ///< number of bytes parsed from the elem so far
size_t elemLength; ///< expected length of the elem size_t elemLength; ///< expected length of the elem
} PSYC_ParseListState; } psycParseListState;
/** /**
* Initiates the state struct. * Initiates the state struct.
* *
* @param state Pointer to the state struct that should be initiated. * @param state Pointer to the state struct that should be initiated.
*/ */
inline void PSYC_initParseState (PSYC_ParseState* state); inline void psyc_initParseState (psycParseState* state);
/** /**
* Initiates the state struct with flags. * Initiates the state struct with flags.
* *
* @param state Pointer to the state struct that should be initiated. * @param state Pointer to the state struct that should be initiated.
* @param flags Flags to be set for the parser, see PSYC_ParseFlag. * @param flags Flags to be set for the parser, see psycParseFlag.
*/ */
inline void PSYC_initParseState2 (PSYC_ParseState* state, uint8_t flags); inline void psyc_initParseState2 (psycParseState* state, uint8_t flags);
/** /**
* Initiates the list state struct. * Initiates the list state struct.
* *
* @param state Pointer to the list state struct that should be initiated. * @param state Pointer to the list state struct that should be initiated.
*/ */
inline void PSYC_initParseListState (PSYC_ParseListState* state); inline void psyc_initParseListState (psycParseListState* state);
inline void PSYC_nextParseBuffer (PSYC_ParseState* state, PSYC_String newBuf); inline void psyc_nextParseBuffer (psycParseState* state, psycString newBuf);
inline void PSYC_nextParseListBuffer (PSYC_ParseListState* state, PSYC_String newBuf); inline void psyc_nextParseListBuffer (psycParseListState* state, psycString newBuf);
inline size_t PSYC_getContentLength (PSYC_ParseState* s); inline size_t psyc_getContentLength (psycParseState* s);
/** /**
* Parse PSYC packets. * Parse PSYC packets.
* *
* Generalized line-based packet parser. * Generalized line-based packet parser.
* *
* @param state An initialized PSYC_ParseState * @param state An initialized psycParseState
* @param operator A pointer to a character. In case of a variable, it will * @param operator A pointer to a character. In case of a variable, it will
* be set to the operator of that variable * be set to the operator of that variable
* @param name A pointer to a PSYC_String. It will point to the name of * @param name A pointer to a psycString. It will point to the name of
* the variable or method and its length will be set accordingly * the variable or method and its length will be set accordingly
* @param value A pointer to a PSYC_String. It will point to the * @param value A pointer to a psycString. It will point to the
* value/body the variable/method and its length will be set accordingly * value/body the variable/method and its length will be set accordingly
*/ */
PSYC_ParseRC PSYC_parse(PSYC_ParseState* state, char* oper, PSYC_String* name, PSYC_String* value); psycParseRC psyc_parse(psycParseState* state, char* oper, psycString* name, psycString* value);
/** /**
* List value parser. * List value parser.
*/ */
PSYC_ParseListRC PSYC_parseList(PSYC_ParseListState* state, PSYC_String *name, PSYC_String* value, PSYC_String* elem); psycParseListRC psyc_parseList(psycParseListState* state, psycString *name, psycString* value, psycString* elem);
#endif // PSYC_PARSER_H #endif // PSYC_PARSER_H

22
include/psyc/render.h
View file

@ -17,19 +17,19 @@
*/ */
/** /**
* Return codes for PSYC_render. * Return codes for psyc_render.
*/ */
typedef enum typedef enum
{ {
//PSYC_RENDER_ERROR_ROUTING = -2, //PSYC_RENDER_ERROR_ROUTING = -2,
PSYC_RENDER_ERROR = -1, PSYC_RENDER_ERROR = -1,
PSYC_RENDER_SUCCESS = 0, PSYC_RENDER_SUCCESS = 0,
} PSYC_RenderRC; } psycRenderRC;
/** /**
* Render a PSYC packet into a buffer. * Render a PSYC packet into a buffer.
*/ */
PSYC_RenderRC PSYC_render(PSYC_Packet *packet, char *buffer, size_t buflen); psycRenderRC psyc_render(psycPacket *packet, char *buffer, size_t buflen);
/* /*
typedef enum typedef enum
@ -38,7 +38,7 @@ typedef enum
PSYC_RENDER_NEED_LENGTH = 1, PSYC_RENDER_NEED_LENGTH = 1,
PSYC_RENDER_NO_LENGTH = 2, PSYC_RENDER_NO_LENGTH = 2,
PSYC_RENDER_ROUTING = 3, PSYC_RENDER_ROUTING = 3,
} PSYC_RenderFlag; } psycRenderFlag;
*/ */
/** /**
@ -47,14 +47,14 @@ typedef enum
/* /*
typedef struct typedef struct
{ {
PSYC_RenderFlag flag; ///< flags for the renderer psycRenderFlag flag; ///< flags for the renderer
PSYC_Part part; ///< part of the packet being rendered psycPart part; ///< part of the packet being rendered
size_t cursor; ///< current position in buffer size_t cursor; ///< current position in buffer
size_t spot; ///< space for rendered length between the headers size_t spot; ///< space for rendered length between the headers
size_t contentLength; ///< length of the content part size_t contentLength; ///< length of the content part
size_t length; ///< how big is the buffer we allocated size_t length; ///< how big is the buffer we allocated
char buffer[]; ///< OMG a C99 feature! variable size buffer! char buffer[]; ///< OMG a C99 feature! variable size buffer!
} PSYC_RenderState; } psycRenderState;
*/ */
/** /**
* Initiates the state struct. * Initiates the state struct.
@ -62,14 +62,14 @@ typedef struct
* @param state Pointer to the state struct that should be initiated. * @param state Pointer to the state struct that should be initiated.
*/ */
/* /*
inline void PSYC_initRenderState (PSYC_RenderState* state); inline void psyc_initRenderState (psycRenderState* state);
int PSYC_renderModifier(PSYC_RenderState* render, int psyc_renderModifier(psycRenderState* render,
const char* name, size_t nlength, const char* name, size_t nlength,
const char* value, size_t vlength, const char* value, size_t vlength,
PSYC_RenderFlag flags, char oper); psycRenderFlag flags, char oper);
int PSYC_renderBody(PSYC_RenderState* render, int psyc_renderBody(psycRenderState* render,
const char* method, size_t mlength, const char* method, size_t mlength,
const char* data, size_t dlength); const char* data, size_t dlength);
*/ */

10
src/match.c
View file

@ -1,6 +1,6 @@
#include "psyc/lib.h" #include "psyc/lib.h"
int PSYC_inherits(char* sho, size_t slen, int psyc_inherits(char* sho, size_t slen,
char* lon, size_t llen) { char* lon, size_t llen) {
// this allows to pass zero-terminated strings instead of providing // this allows to pass zero-terminated strings instead of providing
@ -41,7 +41,7 @@ int PSYC_inherits(char* sho, size_t slen,
return 1; return 1;
} }
int PSYC_matches(char* sho, size_t slen, int psyc_matches(char* sho, size_t slen,
char* lon, size_t llen) { char* lon, size_t llen) {
char *s, *l, *se, *le; char *s, *l, *se, *le;
@ -67,7 +67,7 @@ int PSYC_matches(char* sho, size_t slen,
P1(("Same length but different.\nNo match, but they could be related or have a common type.\n")) P1(("Same length but different.\nNo match, but they could be related or have a common type.\n"))
return -4; return -4;
} }
P3(("# PSYC_matches short '%*s' in long '%*s' ?\n", slen, sho, llen, lon)) P3(("# psyc_matches short '%*s' in long '%*s' ?\n", slen, sho, llen, lon))
se = sho+slen; se = sho+slen;
le = lon+llen; le = lon+llen;
@ -105,9 +105,9 @@ int main(int argc, char **argv) {
printf("Usage: %s <short> <long>\n\nExample: %s _failure_delivery _failure_unsuccessful_delivery_death\n", argv[0], argv[0]); printf("Usage: %s <short> <long>\n\nExample: %s _failure_delivery _failure_unsuccessful_delivery_death\n", argv[0], argv[0]);
return -1; return -1;
} }
if (PSYC_matches(argv[1], 0, argv[2], 0) == 0) if (psyc_matches(argv[1], 0, argv[2], 0) == 0)
printf("Yes, %s matches %s!\n", argv[1], argv[2]); printf("Yes, %s matches %s!\n", argv[1], argv[2]);
if (PSYC_inherits(argv[1], 0, argv[2], 0) == 0) if (psyc_inherits(argv[1], 0, argv[2], 0) == 0)
printf("Yes, %s inherits from %s!\n", argv[2], argv[1]); printf("Yes, %s inherits from %s!\n", argv[2], argv[1]);
} }
#endif #endif

2
src/misc.c
View file

@ -1,2 +1,2 @@
int PSYC_version() { return 1; } int psyc_version() { return 1; }

52
src/packet.c
View file

@ -3,16 +3,16 @@
#include <math.h> #include <math.h>
inline PSYC_String PSYC_newString(const char *str, size_t strlen) inline psycString psyc_newString(const char *str, size_t strlen)
{ {
PSYC_String s = {strlen, str}; psycString s = {strlen, str};
return s; return s;
} }
inline PSYC_Modifier PSYC_newModifier(char oper, PSYC_String *name, PSYC_String *value, inline psycModifier psyc_newModifier(char oper, psycString *name, psycString *value,
PSYC_ModifierFlag flag) psycModifierFlag flag)
{ {
PSYC_Modifier m = {oper, *name, *value, flag}; psycModifier m = {oper, *name, *value, flag};
if (flag == PSYC_MODIFIER_CHECK_LENGTH) // find out if it needs a length if (flag == PSYC_MODIFIER_CHECK_LENGTH) // find out if it needs a length
{ {
@ -27,18 +27,18 @@ inline PSYC_Modifier PSYC_newModifier(char oper, PSYC_String *name, PSYC_String
return m; return m;
} }
inline PSYC_Modifier PSYC_newModifier2(char oper, inline psycModifier psyc_newModifier2(char oper,
const char *name, size_t namelen, const char *name, size_t namelen,
const char *value, size_t valuelen, const char *value, size_t valuelen,
PSYC_ModifierFlag flag) psycModifierFlag flag)
{ {
PSYC_String n = {namelen, name}; psycString n = {namelen, name};
PSYC_String v = {valuelen, value}; psycString v = {valuelen, value};
return PSYC_newModifier(oper, &n, &v, flag); return psyc_newModifier(oper, &n, &v, flag);
} }
inline size_t PSYC_getModifierLength(PSYC_Modifier *m) inline size_t psyc_getModifierLength(psycModifier *m)
{ {
size_t length = 1 + // oper size_t length = 1 + // oper
m->name.length + 1 + // name\t m->name.length + 1 + // name\t
@ -50,12 +50,12 @@ inline size_t PSYC_getModifierLength(PSYC_Modifier *m)
return length; return length;
} }
inline PSYC_Packet PSYC_newPacket(PSYC_ModifierArray *routing, inline psycPacket psyc_newPacket(psycModifierArray *routing,
PSYC_ModifierArray *entity, psycModifierArray *entity,
PSYC_String *method, PSYC_String *data, psycString *method, psycString *data,
PSYC_PacketFlag flag) psycPacketFlag flag)
{ {
PSYC_Packet p = {*routing, *entity, *method, *data, 0, 0, flag}; psycPacket p = {*routing, *entity, *method, *data, 0, 0, flag};
size_t i; size_t i;
if (flag == PSYC_PACKET_CHECK_LENGTH) // find out if it needs a length if (flag == PSYC_PACKET_CHECK_LENGTH) // find out if it needs a length
@ -72,11 +72,11 @@ inline PSYC_Packet PSYC_newPacket(PSYC_ModifierArray *routing,
// add routing header length // add routing header length
for (i = 0; i < routing->lines; i++) for (i = 0; i < routing->lines; i++)
p.routingLength += PSYC_getModifierLength(&routing->modifiers[i]); p.routingLength += psyc_getModifierLength(&routing->modifiers[i]);
// add entity header length // add entity header length
for (i = 0; i < entity->lines; i++) for (i = 0; i < entity->lines; i++)
p.contentLength += PSYC_getModifierLength(&entity->modifiers[i]); p.contentLength += psyc_getModifierLength(&entity->modifiers[i]);
// add length of method, data & delimiter // add length of method, data & delimiter
if (method->length) if (method->length)
@ -92,16 +92,16 @@ inline PSYC_Packet PSYC_newPacket(PSYC_ModifierArray *routing,
return p; return p;
} }
inline PSYC_Packet PSYC_newPacket2(PSYC_Modifier *routing, size_t routinglen, inline psycPacket psyc_newPacket2(psycModifier *routing, size_t routinglen,
PSYC_Modifier *entity, size_t entitylen, psycModifier *entity, size_t entitylen,
const char *method, size_t methodlen, const char *method, size_t methodlen,
const char *data, size_t datalen, const char *data, size_t datalen,
PSYC_PacketFlag flag) psycPacketFlag flag)
{ {
PSYC_ModifierArray r = {routinglen, routing}; psycModifierArray r = {routinglen, routing};
PSYC_ModifierArray e = {entitylen, entity}; psycModifierArray e = {entitylen, entity};
PSYC_String m = {methodlen, method}; psycString m = {methodlen, method};
PSYC_String d = {datalen, data}; psycString d = {datalen, data};
return PSYC_newPacket(&r, &e, &m, &d, flag); return psyc_newPacket(&r, &e, &m, &d, flag);
} }

46
src/parser.c
View file

@ -15,35 +15,35 @@
return ret; \ return ret; \
} }
inline void PSYC_initParseState (PSYC_ParseState* state) inline void psyc_initParseState (psycParseState* state)
{ {
memset(state, 0, sizeof(PSYC_ParseState)); memset(state, 0, sizeof(psycParseState));
} }
inline void PSYC_initParseState2 (PSYC_ParseState* state, uint8_t flags) inline void psyc_initParseState2 (psycParseState* state, uint8_t flags)
{ {
memset(state, 0, sizeof(PSYC_ParseState)); memset(state, 0, sizeof(psycParseState));
state->flags = flags; state->flags = flags;
} }
inline void PSYC_initParseListState (PSYC_ParseListState* state) inline void psyc_initParseListState (psycParseListState* state)
{ {
memset(state, 0, sizeof(PSYC_ParseListState)); memset(state, 0, sizeof(psycParseListState));
} }
inline void PSYC_nextParseBuffer (PSYC_ParseState* state, PSYC_String newBuf) inline void psyc_nextParseBuffer (psycParseState* state, psycString newBuf)
{ {
state->buffer = newBuf; state->buffer = newBuf;
state->cursor = 0; state->cursor = 0;
} }
inline void PSYC_nextParseListBuffer (PSYC_ParseListState* state, PSYC_String newBuf) inline void psyc_nextParseListBuffer (psycParseListState* state, psycString newBuf)
{ {
state->buffer = newBuf; state->buffer = newBuf;
state->cursor = 0; state->cursor = 0;
} }
inline size_t PSYC_getContentLength (PSYC_ParseState* s) inline size_t psyc_getContentLength (psycParseState* s)
{ {
return s->contentLength; return s->contentLength;
} }
@ -101,7 +101,7 @@ inline char isKwChar(uint8_t c)
* It should contain one or more keyword characters. * It should contain one or more keyword characters.
* @return PSYC_PARSE_ERROR or PSYC_PARSE_SUCCESS * @return PSYC_PARSE_ERROR or PSYC_PARSE_SUCCESS
*/ */
inline PSYC_ParseRC PSYC_parseName(PSYC_ParseState* state, PSYC_String* name) inline psycParseRC psyc_parseName(psycParseState* state, psycString* name)
{ {
name->ptr = state->buffer.ptr + state->cursor; name->ptr = state->buffer.ptr + state->cursor;
name->length = 0; name->length = 0;
@ -125,7 +125,7 @@ inline PSYC_ParseRC PSYC_parseName(PSYC_ParseState* state, PSYC_String* name)
* *
* @return PSYC_PARSE_COMPLETE or PSYC_PARSE_INCOMPLETE * @return PSYC_PARSE_COMPLETE or PSYC_PARSE_INCOMPLETE
*/ */
inline PSYC_ParseRC PSYC_parseBinaryValue(PSYC_ParseState* state, PSYC_String* value, size_t* length, size_t* parsed) inline psycParseRC psyc_parseBinaryValue(psycParseState* state, psycString* value, size_t* length, size_t* parsed)
{ {
size_t remaining = *length - *parsed; size_t remaining = *length - *parsed;
value->ptr = state->buffer.ptr + state->cursor; value->ptr = state->buffer.ptr + state->cursor;
@ -148,12 +148,12 @@ inline PSYC_ParseRC PSYC_parseBinaryValue(PSYC_ParseState* state, PSYC_String* v
* Parse simple or binary variable. * Parse simple or binary variable.
* @return PSYC_PARSE_ERROR or PSYC_PARSE_SUCCESS * @return PSYC_PARSE_ERROR or PSYC_PARSE_SUCCESS
*/ */
inline PSYC_ParseRC PSYC_parseModifier(PSYC_ParseState* state, char* oper, PSYC_String* name, PSYC_String* value) inline psycParseRC psyc_parseModifier(psycParseState* state, char* oper, psycString* name, psycString* value)
{ {
*oper = *(state->buffer.ptr + state->cursor); *oper = *(state->buffer.ptr + state->cursor);
ADVANCE_CURSOR_OR_RETURN(PSYC_PARSE_INSUFFICIENT); ADVANCE_CURSOR_OR_RETURN(PSYC_PARSE_INSUFFICIENT);
if (PSYC_parseName(state, name) != PSYC_PARSE_SUCCESS) if (psyc_parseName(state, name) != PSYC_PARSE_SUCCESS)
return PSYC_PARSE_ERROR_VAR_NAME; return PSYC_PARSE_ERROR_VAR_NAME;
value->length = 0; value->length = 0;
@ -185,7 +185,7 @@ inline PSYC_ParseRC PSYC_parseModifier(PSYC_ParseState* state, char* oper, PSYC_
if (state->buffer.length <= ++(state->cursor)) // Incremented cursor inside length? if (state->buffer.length <= ++(state->cursor)) // Incremented cursor inside length?
return PSYC_PARSE_ENTITY_INCOMPLETE; return PSYC_PARSE_ENTITY_INCOMPLETE;
if (PSYC_parseBinaryValue(state, value, &(state->valueLength), &(state->valueParsed)) == PSYC_PARSE_INCOMPLETE) if (psyc_parseBinaryValue(state, value, &(state->valueLength), &(state->valueParsed)) == PSYC_PARSE_INCOMPLETE)
return PSYC_PARSE_ENTITY_INCOMPLETE; return PSYC_PARSE_ENTITY_INCOMPLETE;
state->cursor++; state->cursor++;
@ -212,7 +212,7 @@ inline PSYC_ParseRC PSYC_parseModifier(PSYC_ParseState* state, char* oper, PSYC_
* Parse PSYC packets. * Parse PSYC packets.
* Generalized line-based parser. * Generalized line-based parser.
*/ */
PSYC_ParseRC PSYC_parse(PSYC_ParseState* state, char* oper, PSYC_String* name, PSYC_String* value) psycParseRC psyc_parse(psycParseState* state, char* oper, psycString* name, psycString* value)
{ {
int ret; // a return value int ret; // a return value
size_t pos; // a cursor position size_t pos; // a cursor position
@ -242,7 +242,7 @@ PSYC_ParseRC PSYC_parse(PSYC_ParseState* state, char* oper, PSYC_String* name, P
// so just test if the first char is a glyph. // so just test if the first char is a glyph.
if (isGlyph(state->buffer.ptr[state->cursor])) // is the first char a glyph? if (isGlyph(state->buffer.ptr[state->cursor])) // is the first char a glyph?
{ // it is a glyph, so a variable starts here { // it is a glyph, so a variable starts here
ret = PSYC_parseModifier(state, oper, name, value); ret = psyc_parseModifier(state, oper, name, value);
return ret == PSYC_PARSE_SUCCESS ? PSYC_PARSE_ROUTING : ret; return ret == PSYC_PARSE_SUCCESS ? PSYC_PARSE_ROUTING : ret;
} }
else // not a glyph else // not a glyph
@ -291,7 +291,7 @@ PSYC_ParseRC PSYC_parse(PSYC_ParseState* state, char* oper, PSYC_String* name, P
case PSYC_PART_CONTENT: case PSYC_PART_CONTENT:
// In case of an incomplete binary variable resume parsing it. // In case of an incomplete binary variable resume parsing it.
if (state->valueParsed < state->valueLength) { if (state->valueParsed < state->valueLength) {
ret = PSYC_parseBinaryValue(state, value, &(state->valueLength), &(state->valueParsed)); ret = psyc_parseBinaryValue(state, value, &(state->valueLength), &(state->valueParsed));
state->contentParsed += value->length; state->contentParsed += value->length;
return ret == PSYC_PARSE_COMPLETE ? PSYC_PARSE_ENTITY : PSYC_PARSE_ENTITY_INCOMPLETE; return ret == PSYC_PARSE_COMPLETE ? PSYC_PARSE_ENTITY : PSYC_PARSE_ENTITY_INCOMPLETE;
} }
@ -304,7 +304,7 @@ PSYC_ParseRC PSYC_parse(PSYC_ParseState* state, char* oper, PSYC_String* name, P
if (isGlyph(state->buffer.ptr[state->cursor])) if (isGlyph(state->buffer.ptr[state->cursor]))
{ {
pos = state->cursor; pos = state->cursor;
ret = PSYC_parseModifier(state, oper, name, value); ret = psyc_parseModifier(state, oper, name, value);
state->contentParsed += state->cursor - pos; state->contentParsed += state->cursor - pos;
return ret == PSYC_PARSE_SUCCESS ? PSYC_PARSE_ENTITY : ret; return ret == PSYC_PARSE_SUCCESS ? PSYC_PARSE_ENTITY : ret;
} }
@ -317,7 +317,7 @@ PSYC_ParseRC PSYC_parse(PSYC_ParseState* state, char* oper, PSYC_String* name, P
case PSYC_PART_METHOD: case PSYC_PART_METHOD:
pos = state->cursor; pos = state->cursor;
if (PSYC_parseName(state, name) == PSYC_PARSE_SUCCESS) if (psyc_parseName(state, name) == PSYC_PARSE_SUCCESS)
{ // the method ends with a \n then the data follows { // the method ends with a \n then the data follows
if (state->buffer.ptr[state->cursor] != '\n') if (state->buffer.ptr[state->cursor] != '\n')
return PSYC_PARSE_ERROR_METHOD; return PSYC_PARSE_ERROR_METHOD;
@ -343,7 +343,7 @@ PSYC_ParseRC PSYC_parse(PSYC_ParseState* state, char* oper, PSYC_String* name, P
if (state->contentLengthFound) // We know the length of the packet. if (state->contentLengthFound) // We know the length of the packet.
{ {
if (PSYC_parseBinaryValue(state, value, &(state->contentLength), &(state->contentParsed)) == PSYC_PARSE_INCOMPLETE) if (psyc_parseBinaryValue(state, value, &(state->contentLength), &(state->contentParsed)) == PSYC_PARSE_INCOMPLETE)
return PSYC_PARSE_BODY_INCOMPLETE; return PSYC_PARSE_BODY_INCOMPLETE;
state->cursor++; state->cursor++;
@ -400,9 +400,9 @@ PSYC_ParseRC PSYC_parse(PSYC_ParseState* state, char* oper, PSYC_String* name, P
/** /**
* List value parser. * List value parser.
* @return see PSYC_ListRC. * @return see psycListRC.
*/ */
PSYC_ParseListRC PSYC_parseList(PSYC_ParseListState* state, PSYC_String *name, PSYC_String* value, PSYC_String* elem) psycParseListRC psyc_parseList(psycParseListState* state, psycString *name, psycString* value, psycString* elem)
{ {
if (state->cursor >= state->buffer.length) if (state->cursor >= state->buffer.length)
return PSYC_PARSE_LIST_INCOMPLETE; return PSYC_PARSE_LIST_INCOMPLETE;
@ -473,7 +473,7 @@ PSYC_ParseListRC PSYC_parseList(PSYC_ParseListState* state, PSYC_String *name, P
// Start or resume parsing the binary data // Start or resume parsing the binary data
if (state->elemParsed < state->elemLength) if (state->elemParsed < state->elemLength)
{ {
if (PSYC_parseBinaryValue((PSYC_ParseState*)state, elem, &(state->elemLength), &(state->elemParsed)) == PSYC_PARSE_INCOMPLETE) if (psyc_parseBinaryValue((psycParseState*)state, elem, &(state->elemLength), &(state->elemParsed)) == PSYC_PARSE_INCOMPLETE)
return PSYC_PARSE_LIST_INCOMPLETE; return PSYC_PARSE_LIST_INCOMPLETE;
state->elemLength = 0; state->elemLength = 0;

34
src/psyc_parser_cb.h
View file

@ -1,19 +1,19 @@
#include <stdint.h> #include <stdint.h>
struct PSYC_Parser; struct psycParser;
/** @brief initialize a pstate struct /** @brief initialize a pstate struct
* *
* @param pstate pointer to an allocated * @param pstate pointer to an allocated
* PSYC_Parser struct. * psycParser struct.
*/ */
void PSYC_initState(struct PSYC_Parser* pstate); void psyc_initState(struct psycParser* pstate);
/** @brief parses a packet /** @brief parses a packet
* *
* This function parses rawdata * This function parses rawdata
* and uses the callbacks in PSYC_Parser * and uses the callbacks in psycParser
* to communicate with the caller. * to communicate with the caller.
* *
* First the header will be parsed, * First the header will be parsed,
@ -23,7 +23,7 @@ void PSYC_initState(struct PSYC_Parser* pstate);
* Then, routingCallback will be called * Then, routingCallback will be called
* to find out if further parsing * to find out if further parsing
* is desired. * is desired.
* If it returns false, PSYC_parser returns. * If it returns false, psyc_parse returns.
* If it returns true, parsing continues * If it returns true, parsing continues
* to the body. * to the body.
* After the entitystate has been parsed, * After the entitystate has been parsed,
@ -38,15 +38,15 @@ void PSYC_initState(struct PSYC_Parser* pstate);
* raw data that is to be processed. * raw data that is to be processed.
* @param length the amount of bytes to parse * @param length the amount of bytes to parse
* @param pstate pointer to a preallocated * @param pstate pointer to a preallocated
* and initialized (PSYC_initState) * and initialized (psyc_initState)
* instance of the struct state * instance of the struct state
* *
*/ */
void PSYC_parse(const uint8_t* data, unsigned int length, void psyc_parse(const uint8_t* data, unsigned int length,
struct PSYC_Parser* pstate); struct psycParser* pstate);
/** @brief FlagMod */ /** @brief FlagMod */
enum PSYC_Operator enum psycOperator
{ {
// modifier operators // modifier operators
ASSIGN = 0x02, ASSIGN = 0x02,
@ -56,7 +56,7 @@ enum PSYC_Operator
QUERY = 0x20, QUERY = 0x20,
}; };
struct PSYC_Parser struct psycParser
{ {
/** @brief Callback for the states /** @brief Callback for the states
* *
@ -76,10 +76,10 @@ struct PSYC_Parser
* @param modifers modifer of the variable (see Modifer) * @param modifers modifer of the variable (see Modifer)
* @param inEntity wether this variable is an entity * @param inEntity wether this variable is an entity
* variable(true) or a routing variable(false) */ * variable(true) or a routing variable(false) */
void (*stateCallback)(struct PSYC_Parser* pstate, void (*stateCallback)(struct psycParser* pstate,
const uint8_t *name, const unsigned int nlength, const uint8_t *name, const unsigned int nlength,
const uint8_t *value, const unsigned int vlength, const uint8_t *value, const unsigned int vlength,
enum PSYC_Operator oper, char inEntity); enum psycOperator oper, char inEntity);
/** @brief gets called after the routing-header was parsed /** @brief gets called after the routing-header was parsed
* *
@ -88,7 +88,7 @@ struct PSYC_Parser
* when finished, * when finished,
* if not 0, parser will stop parsing and * if not 0, parser will stop parsing and
* calls contentCallback */ * calls contentCallback */
char (*routingCallback)(struct PSYC_Parser* pstate); char (*routingCallback)(struct psycParser* pstate);
/** @brief Body callback, gets called when the body was parsed /** @brief Body callback, gets called when the body was parsed
* *
@ -102,7 +102,7 @@ struct PSYC_Parser
* containing the data section * containing the data section
* @param content not null terminated c-string * @param content not null terminated c-string
* @param clength length of the content string */ * @param clength length of the content string */
void (*bodyCallback)(struct PSYC_Parser* pstate, void (*bodyCallback)(struct psycParser* pstate,
const uint8_t* method, unsigned int mlength, const uint8_t* method, unsigned int mlength,
const uint8_t* data, unsigned int dlength, const uint8_t* data, unsigned int dlength,
const uint8_t* content, unsigned int clength); const uint8_t* content, unsigned int clength);
@ -123,7 +123,7 @@ struct PSYC_Parser
* *
* Any previous state or body callbacks become * Any previous state or body callbacks become
* invalid and have to be purged.*/ * invalid and have to be purged.*/
void (*errorCallback)(struct PSYC_Parser* pstate, void (*errorCallback)(struct psycParser* pstate,
const uint8_t *method, unsigned int mlength); const uint8_t *method, unsigned int mlength);
/** @brief error state callback /** @brief error state callback
@ -132,10 +132,10 @@ struct PSYC_Parser
* The callback will be called once for each * The callback will be called once for each
* state variable in the error report packet * state variable in the error report packet
*/ */
void (*errorStateCallback)(struct PSYC_Parser* pstate, void (*errorStateCallback)(struct psycParser* pstate,
const uint8_t *name, const unsigned int nlength, const uint8_t *name, const unsigned int nlength,
const uint8_t *value, const unsigned int vlength, const uint8_t *value, const unsigned int vlength,
enum PSYC_Operator oper); enum psycOperator oper);
/******************************************* /*******************************************

20
src/render.c
View file

@ -2,7 +2,7 @@
#include "psyc/render.h" #include "psyc/render.h"
#include "psyc/syntax.h" #include "psyc/syntax.h"
inline size_t PSYC_renderModifier(PSYC_Modifier *m, char *buffer) inline size_t psyc_renderModifier(psycModifier *m, char *buffer)
{ {
size_t cur = 0; size_t cur = 0;
@ -24,7 +24,7 @@ inline size_t PSYC_renderModifier(PSYC_Modifier *m, char *buffer)
return cur; return cur;
} }
PSYC_RenderRC PSYC_render(PSYC_Packet *packet, char *buffer, size_t buflen) psycRenderRC psyc_render(psycPacket *packet, char *buffer, size_t buflen)
{ {
size_t i, cur = 0; size_t i, cur = 0;
@ -33,7 +33,7 @@ PSYC_RenderRC PSYC_render(PSYC_Packet *packet, char *buffer, size_t buflen)
// render routing modifiers // render routing modifiers
for (i = 0; i < packet->routing.lines; i++) for (i = 0; i < packet->routing.lines; i++)
cur += PSYC_renderModifier(&packet->routing.modifiers[i], buffer + cur); cur += psyc_renderModifier(&packet->routing.modifiers[i], buffer + cur);
// add length if needed // add length if needed
if (packet->flag == PSYC_PACKET_NEED_LENGTH) { if (packet->flag == PSYC_PACKET_NEED_LENGTH) {
@ -45,7 +45,7 @@ PSYC_RenderRC PSYC_render(PSYC_Packet *packet, char *buffer, size_t buflen)
// render entity modifiers // render entity modifiers
for (i = 0; i < packet->entity.lines; i++) for (i = 0; i < packet->entity.lines; i++)
cur += PSYC_renderModifier(&packet->entity.modifiers[i], buffer + cur); cur += psyc_renderModifier(&packet->entity.modifiers[i], buffer + cur);
if (packet->method.length) // add method\n if (packet->method.length) // add method\n
{ {
@ -71,15 +71,15 @@ PSYC_RenderRC PSYC_render(PSYC_Packet *packet, char *buffer, size_t buflen)
} }
/* /*
inline void PSYC_initRenderState (PSYC_RenderState *state) inline void psyc_initRenderState (psycRenderState *state)
{ {
memset(state, 0, sizeof(PSYC_RenderState)); memset(state, 0, sizeof(psycRenderState));
} }
PSYC_RenderRC PSYC_renderModifier(PSYC_RenderState *state, psycRenderRC psyc_renderModifier(psycRenderState *state,
const char *name, size_t nlength, const char *name, size_t nlength,
const char *value, size_t vlength, const char *value, size_t vlength,
const PSYC_RenderFlag flags, char oper) const psycRenderFlag flags, char oper)
{ {
size_t startc = state->cursor; size_t startc = state->cursor;
@ -99,7 +99,7 @@ PSYC_RenderRC PSYC_renderModifier(PSYC_RenderState *state,
} }
//if (flags == PSYC_RENDER_ROUTING) //if (flags == PSYC_RENDER_ROUTING)
if (PSYC_isRoutingVar(name, nlength)) if (psyc_isRoutingVar(name, nlength))
{ // no more routing headers allowed after content started { // no more routing headers allowed after content started
if (state->part != PSYC_PART_ROUTING) if (state->part != PSYC_PART_ROUTING)
{ {
@ -121,7 +121,7 @@ PSYC_RenderRC PSYC_renderModifier(PSYC_RenderState *state,
return PSYC_RENDER_SUCCESS; return PSYC_RENDER_SUCCESS;
} }
PSYC_RenderRC PSYC_renderBody(PSYC_RenderState *state, psycRenderRC psyc_renderBody(psycRenderState *state,
const char *method, size_t mlength, const char *method, size_t mlength,
const char *data, size_t dlength) const char *data, size_t dlength)
{ {

2
src/text.c
View file

@ -1,2 +1,2 @@
/* PSYC_text() */ /* psyc_text() */

6
src/variable.c
View file

@ -2,7 +2,7 @@
#include <stdint.h> #include <stdint.h>
/// Routing variables in alphabetical order. /// Routing variables in alphabetical order.
const PSYC_String PSYC_routingVars[] = const psycString PSYC_routingVars[] =
{ {
PSYC_C2STR("_amount_fragments"), PSYC_C2STR("_amount_fragments"),
PSYC_C2STR("_context"), PSYC_C2STR("_context"),
@ -29,7 +29,7 @@ const size_t PSYC_routingVarsNum = sizeof(PSYC_routingVars) / sizeof(*PSYC_routi
/** /**
* Get the type of variable name. * Get the type of variable name.
*/ */
PSYC_Bool PSYC_isRoutingVar(const char *name, size_t len) psycBool psyc_isRoutingVar(const char *name, size_t len)
{ {
size_t cursor = 1; size_t cursor = 1;
int8_t matching[PSYC_routingVarsNum]; // indexes of matching vars int8_t matching[PSYC_routingVarsNum]; // indexes of matching vars
@ -68,7 +68,7 @@ PSYC_Bool PSYC_isRoutingVar(const char *name, size_t len)
/** /**
* Get the type of variable name. * Get the type of variable name.
*/ */
PSYC_Type PSYC_getVarType(char *name, size_t len) psycType psyc_getVarType(char *name, size_t len)
{ {
return PSYC_TYPE_UNKNOWN; return PSYC_TYPE_UNKNOWN;
} }

4
test/isRoutingVar.c
View file

@ -19,8 +19,8 @@ int main(int argc, char** argv)
int i; int i;
for (i = 0; i < sizeof(vars) / sizeof(*vars); i++) for (i = 0; i < sizeof(vars) / sizeof(*vars); i++)
{ {
printf(">> %s: %ld %ld\n", vars[i], sizeof(vars[i]), sizeof(*vars[i])); printf(">> %s: %d %d\n", vars[i], sizeof(vars[i]), sizeof(*vars[i]));
printf("%s: %d\n", vars[i], PSYC_isRoutingVar(vars[i], strlen(vars[i]))); printf("%s: %d\n", vars[i], psyc_isRoutingVar(vars[i], strlen(vars[i])));
} }
return 0; return 0;

20
test/testMatch.c
View file

@ -2,19 +2,19 @@
#include "../include/psyc/lib.h" #include "../include/psyc/lib.h"
int main() { int main() {
if (PSYC_matches("_failure_delivery", 0, "_failure_unsuccessful_delivery_death", 0)) return -1; if (psyc_matches("_failure_delivery", 0, "_failure_unsuccessful_delivery_death", 0)) return -1;
if (PSYC_matches("_failure_trash", 8, "_failure_unsuccessful_delivery_death", 0)) return -2; if (psyc_matches("_failure_trash", 8, "_failure_unsuccessful_delivery_death", 0)) return -2;
if (PSYC_matches("_unsuccessful", 0, "_failure_unsuccessful_delivery_death", 0)) return -3; if (psyc_matches("_unsuccessful", 0, "_failure_unsuccessful_delivery_death", 0)) return -3;
unless (PSYC_matches("_fail", 0, "_failure_unsuccessful_delivery_death", 0)) return -4; unless (psyc_matches("_fail", 0, "_failure_unsuccessful_delivery_death", 0)) return -4;
unless (PSYC_matches("_truthahn", 0, "_failure_unsuccessful_delivery_death", 0)) return -5; unless (psyc_matches("_truthahn", 0, "_failure_unsuccessful_delivery_death", 0)) return -5;
puts("PSYC_matches passed all tests."); puts("psyc_matches passed all tests.");
unless (PSYC_inherits("_failure_delivery", 0, "_failure_unsuccessful_delivery_death", 0)) return -11; unless (psyc_inherits("_failure_delivery", 0, "_failure_unsuccessful_delivery_death", 0)) return -11;
if (PSYC_inherits("_failure_unsuccessful", 0, "_failure_unsuccessful_delivery_death", 0)) return -12; if (psyc_inherits("_failure_unsuccessful", 0, "_failure_unsuccessful_delivery_death", 0)) return -12;
unless (PSYC_inherits("_fail", 0, "_failure_unsuccessful_delivery_death", 0)) return -13; unless (psyc_inherits("_fail", 0, "_failure_unsuccessful_delivery_death", 0)) return -13;
puts("PSYC_inherits passed all tests."); puts("psyc_inherits passed all tests.");
return 0; // passed all tests return 0; // passed all tests
} }

18
test/testParser.c
View file

@ -8,9 +8,9 @@ int main(int argc, char** argv)
{ {
int indx, ret; int indx, ret;
char buffer[2048], oper; char buffer[2048], oper;
PSYC_String name, value, elem; psycString name, value, elem;
PSYC_ParseState state; psycParseState state;
PSYC_ParseListState listState; psycParseListState listState;
int file = open(argv[1],O_RDONLY); int file = open(argv[1],O_RDONLY);
if(file < 0) if(file < 0)
@ -21,11 +21,11 @@ int main(int argc, char** argv)
write(1, buffer, indx); write(1, buffer, indx);
write(1, ">> PARSE\n", 9); write(1, ">> PARSE\n", 9);
PSYC_initParseState(&state); psyc_initParseState(&state);
PSYC_nextParseBuffer(&state, PSYC_newString(buffer, indx)); psyc_nextParseBuffer(&state, psyc_newString(buffer, indx));
// try parsing that now // try parsing that now
while ((ret = PSYC_parse(&state, &oper, &name, &value))) while ((ret = psyc_parse(&state, &oper, &name, &value)))
{ {
switch (ret) switch (ret)
{ {
@ -41,9 +41,9 @@ int main(int argc, char** argv)
if (memcmp(name.ptr, "_list", 5) == 0) if (memcmp(name.ptr, "_list", 5) == 0)
{ {
write(1, ">>> LIST START\n", 15); write(1, ">>> LIST START\n", 15);
PSYC_initParseListState(&listState); psyc_initParseListState(&listState);
PSYC_nextParseListBuffer(&listState, value); psyc_nextParseListBuffer(&listState, value);
while ((ret = PSYC_parseList(&listState, &name, &value, &elem))) while ((ret = psyc_parseList(&listState, &name, &value, &elem)))
{ {
switch (ret) switch (ret)
{ {

33
test/testRender.c
View file

@ -2,28 +2,29 @@
#include <unistd.h> #include <unistd.h>
#include "../include/psyc/lib.h" #include "../include/psyc/lib.h"
#include "../include/psyc/render.h" #include "../include/psyc/render.h"
#include "../include/psyc/syntax.h"
#define myUNI "psyc://10.100.1000/~ludwig" #define myUNI "psyc://10.100.1000/~ludwig"
/* example renderer generating a presence packet */ /* example renderer generating a presence packet */
int writePresence(const char *avail, int availlen, const char *desc, int desclen) int writePresence(const char *avail, int availlen, const char *desc, int desclen)
{ {
PSYC_Modifier routing[] = { psycModifier routing[] = {
PSYC_newModifier2(C_GLYPH_OPERATOR_SET, PSYC_C2ARG("_source"), PSYC_C2ARG(myUNI), psyc_newModifier2(C_GLYPH_OPERATOR_SET, PSYC_C2ARG("_source"), PSYC_C2ARG(myUNI),
PSYC_MODIFIER_ROUTING), PSYC_MODIFIER_ROUTING),
PSYC_newModifier2(C_GLYPH_OPERATOR_SET, PSYC_C2ARG("_context"), PSYC_C2ARG(myUNI), psyc_newModifier2(C_GLYPH_OPERATOR_SET, PSYC_C2ARG("_context"), PSYC_C2ARG(myUNI),
PSYC_MODIFIER_ROUTING), PSYC_MODIFIER_ROUTING),
}; };
PSYC_Modifier entity[] = { psycModifier entity[] = {
// presence is to be assigned permanently in distributed state // presence is to be assigned permanently in distributed state
PSYC_newModifier2(C_GLYPH_OPERATOR_ASSIGN, PSYC_C2ARG("_degree_availability"), psyc_newModifier2(C_GLYPH_OPERATOR_ASSIGN, PSYC_C2ARG("_degree_availability"),
avail, availlen, PSYC_PACKET_CHECK_LENGTH), avail, availlen, PSYC_PACKET_CHECK_LENGTH),
PSYC_newModifier2(C_GLYPH_OPERATOR_ASSIGN, PSYC_C2ARG("_description_presence"), psyc_newModifier2(C_GLYPH_OPERATOR_ASSIGN, PSYC_C2ARG("_description_presence"),
desc, desclen, PSYC_PACKET_CHECK_LENGTH), desc, desclen, PSYC_PACKET_CHECK_LENGTH),
}; };
PSYC_Packet packet = PSYC_newPacket2(routing, PSYC_NUM_ELEM(routing), psycPacket packet = psyc_newPacket2(routing, PSYC_NUM_ELEM(routing),
entity, PSYC_NUM_ELEM(entity), entity, PSYC_NUM_ELEM(entity),
PSYC_C2ARG("_notice_presence"), PSYC_C2ARG("_notice_presence"),
NULL, 0, NULL, 0,
@ -31,11 +32,11 @@ int writePresence(const char *avail, int availlen, const char *desc, int desclen
PSYC_PACKET_CHECK_LENGTH); PSYC_PACKET_CHECK_LENGTH);
char buffer[512]; char buffer[512];
PSYC_render(&packet, buffer, sizeof(buffer)); psyc_render(&packet, buffer, sizeof(buffer));
write(0, buffer, packet.length); write(0, buffer, packet.length);
/* /*
PSYC_RenderState *pb; // a chunk of mem will host both struct and buf1 psycRenderState *pb; // a chunk of mem will host both struct and buf1
// char *t; // char *t;
// unsigned int l; // unsigned int l;
@ -46,20 +47,20 @@ int writePresence(const char *avail, int availlen, const char *desc, int desclen
P0(("Out of memory\n")) P0(("Out of memory\n"))
return -1; return -1;
} }
// if (PSYC_initBuffer(pb, WHATEVER)) die("PSYC_initBuffer hates me"); // if (psyc_initBuffer(pb, WHATEVER)) die("psyc_initBuffer hates me");
(void) PSYC_renderModifier(pb, "_context", 0, (void) psyc_renderModifier(pb, "_context", 0,
myUNI, sizeof(myUNI), PSYC_RENDER_ROUTING, 0); myUNI, sizeof(myUNI), PSYC_RENDER_ROUTING, 0);
// the first call to PSYC_renderHeader() without PSYC_RENDER_ROUTING adds the // the first call to psyc_renderHeader() without PSYC_RENDER_ROUTING adds the
// extra newline to the buffer. later vars with PSYC_RENDER_ROUTING cause an error. // extra newline to the buffer. later vars with PSYC_RENDER_ROUTING cause an error.
(void) PSYC_renderModifier(pb, "_degree_availability", 0, avail, availlen, 0, C_GLYPH_OPERATOR_ASSIGN); (void) psyc_renderModifier(pb, "_degree_availability", 0, avail, availlen, 0, C_GLYPH_OPERATOR_ASSIGN);
(void) PSYC_renderModifier(pb, "_description_presence", 0, desc, desclen, 0, C_GLYPH_OPERATOR_ASSIGN); (void) psyc_renderModifier(pb, "_description_presence", 0, desc, desclen, 0, C_GLYPH_OPERATOR_ASSIGN);
// presence is to be assigned permanently in distributed state // presence is to be assigned permanently in distributed state
(void) PSYC_renderBody(pb, "_notice_presence", 0, (void) psyc_renderBody(pb, "_notice_presence", 0,
NULL, 0); // no data in packet NULL, 0); // no data in packet
// (void) PSYC_doneRender(pb, &t, &l); // (void) psyc_doneRender(pb, &t, &l);
// write(stdout, t, l); // write(stdout, t, l);
free(pb); free(pb);
*/ */