rsyslog/rsyslog
1
0
Fork 0
mirror of https://github.com/rsyslog/rsyslog.git synced 2025-12-19 03:20:41 +01:00
Code Issues Packages Projects Releases Wiki Activity

some more interface changes

Browse Source
This commit is contained in:
Rainer Gerhards 2008-02-21 14:31:56 +00:00
parent 04622f7d22
commit 45136c6656
12 changed files with 222 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
conf.c
View File

@ -56,6 +56,7 @@
/* static data */
DEFobjCurrIf(expr)
DEFobjCurrIf(ctok)
uchar *pModDir = NULL; /* read-only after startup */
/* The following global variables are used for building
@ -733,7 +734,7 @@ dbgPrintAllDebugInfo();
static rsRetVal cflineProcessIfFilter(uchar **pline, register selector_t *f)
{
DEFiRet;
ctok_t *ctok;
ctok_t *tok;
ctok_token_t *pToken;
ASSERT(pline != NULL);
@ -750,28 +751,28 @@ dbgprintf("calling expression parser, pp %p ('%s')\n", *pline, *pline);
(*pline) += 3;
/* we first need a tokenizer... */
CHKiRet(ctokConstruct(&ctok));
CHKiRet(ctokSetpp(ctok, *pline));
CHKiRet(ctokConstructFinalize(ctok));
CHKiRet(ctok.Construct(&tok));
CHKiRet(ctok.Setpp(tok, *pline));
CHKiRet(ctok.ConstructFinalize(tok));
/* now construct our expression */
CHKiRet(expr.Construct(&f->f_filterData.f_expr));
CHKiRet(expr.ConstructFinalize(f->f_filterData.f_expr));
/* ready to go... */
CHKiRet(expr.Parse(f->f_filterData.f_expr, ctok));
CHKiRet(expr.Parse(f->f_filterData.f_expr, tok));
/* we now need to parse off the "then" - and note an error if it is
* missing...
*/
CHKiRet(ctokGetToken(ctok, &pToken));
CHKiRet(ctok.GetToken(tok, &pToken));
if(pToken->tok != ctok_THEN) {
ABORT_FINALIZE(RS_RET_SYNTAX_ERROR);
}
/* we are done, so we now need to restore things */
CHKiRet(ctokGetpp(ctok, pline));
CHKiRet(ctokDestruct(&ctok));
CHKiRet(ctok.Getpp(tok, pline));
CHKiRet(ctok.Destruct(&tok));
dbgprintf("expression parser successfully ended, pp %p ('%s')\n", *pline, *pline);
@ -1155,6 +1156,8 @@ rsRetVal confClassInit(void)
DEFiRet;
/* request objects we use */
CHKiRet(objUse(expr));
CHKiRet(objUse(ctok));
finalize_it:
RETiRet;
}

45
ctok.c
View File

@ -40,6 +40,7 @@
/* static data */
DEFobjStaticHelpers
DEFobjCurrIf(ctok_token)
/* Standard-Constructor
@ -328,7 +329,7 @@ finalize_it:
* a programming error.
* rgerhards, 2008-02-20
*/
rsRetVal
static rsRetVal
ctokUngetToken(ctok_t *pThis, ctok_token_t *pToken)
{
DEFiRet;
@ -373,7 +374,7 @@ finalize_it:
* back to ctokUngetToken().
* rgerhards, 2008-02-19
*/
rsRetVal
static rsRetVal
ctokGetToken(ctok_t *pThis, ctok_token_t **ppToken)
{
DEFiRet;
@ -395,8 +396,8 @@ ctokGetToken(ctok_t *pThis, ctok_token_t **ppToken)
}
/* setup the stage - create our token */
CHKiRet(ctok_tokenConstruct(&pToken));
CHKiRet(ctok_tokenConstructFinalize(pToken));
CHKiRet(ctok_token.Construct(&pToken));
CHKiRet(ctok_token.ConstructFinalize(pToken));
/* find the next token. We may loop when we have inline comments */
do {
@ -513,7 +514,7 @@ RUNLOG_VAR("%d", pToken->tok);
finalize_it:
if(iRet != RS_RET_OK) {
if(pToken != NULL)
ctok_tokenDestruct(&pToken);
ctok_token.Destruct(&pToken);
}
RETiRet;
@ -528,7 +529,7 @@ DEFpropSetMeth(ctok, pp, uchar*)
* partial parsing, so the rest must know where to start from...
* rgerhards, 2008-02-19
*/
rsRetVal
static rsRetVal
ctokGetpp(ctok_t *pThis, uchar **pp)
{
DEFiRet;
@ -537,7 +538,39 @@ ctokGetpp(ctok_t *pThis, uchar **pp)
RETiRet;
}
/* queryInterface function
* rgerhards, 2008-02-21
*/
BEGINobjQueryInterface(ctok)
CODESTARTobjQueryInterface(ctok)
if(pIf->ifVersion != ctokCURR_IF_VERSION) { /* check for current version, increment on each change */
ABORT_FINALIZE(RS_RET_INTERFACE_NOT_SUPPORTED);
}
/* ok, we have the right interface, so let's fill it
* Please note that we may also do some backwards-compatibility
* work here (if we can support an older interface version - that,
* of course, also affects the "if" above).
*/
pIf->oID = OBJctok;
pIf->Construct = ctokConstruct;
pIf->ConstructFinalize = ctokConstructFinalize;
pIf->Destruct = ctokDestruct;
pIf->Getpp = ctokGetpp;
pIf->GetToken = ctokGetToken;
pIf->UngetToken = ctokUngetToken;
pIf->Setpp = ctokSetpp;
finalize_it:
ENDobjQueryInterface(ctok)
BEGINObjClassInit(ctok, 1) /* class, version */
/* request objects we use */
CHKiRet(objUse(ctok_token));
OBJSetMethodHandler(objMethod_CONSTRUCTION_FINALIZER, ctokConstructFinalize);
ENDObjClassInit(ctok)

23
ctok.h
View File

@ -35,14 +35,21 @@ typedef struct ctok_s {
} ctok_t;
/* interfaces */
BEGINinterface(ctok) /* name must also be changed in ENDinterface macro! */
INTERFACEObjDebugPrint(ctok);
INTERFACEpropSetMeth(ctok, pp, uchar*);
rsRetVal (*Construct)(ctok_t **ppThis);
rsRetVal (*ConstructFinalize)(ctok_t __attribute__((unused)) *pThis);
rsRetVal (*Destruct)(ctok_t **ppThis);
rsRetVal (*Getpp)(ctok_t *pThis, uchar **pp);
rsRetVal (*GetToken)(ctok_t *pThis, ctok_token_t **ppToken);
rsRetVal (*UngetToken)(ctok_t *pThis, ctok_token_t *pToken);
ENDinterface(ctok)
#define ctokCURR_IF_VERSION 1 /* increment whenever you change the interface structure! */
/* prototypes */
rsRetVal ctokConstruct(ctok_t **ppThis);
rsRetVal ctokConstructFinalize(ctok_t __attribute__((unused)) *pThis);
rsRetVal ctokDestruct(ctok_t **ppThis);
rsRetVal ctokGetpp(ctok_t *pThis, uchar **pp);
rsRetVal ctokGetToken(ctok_t *pThis, ctok_token_t **ppToken);
rsRetVal ctokUngetToken(ctok_t *pThis, ctok_token_t *pToken);
PROTOTYPEObjClassInit(ctok);
PROTOTYPEpropSetMeth(ctok, pp, uchar*);
PROTOTYPEObj(ctok);
#endif /* #ifndef INCLUDED_CTOK_H */

34
ctok_token.c
View File

@ -66,7 +66,7 @@ ENDobjDestruct(ctok_token)
* caller is responsible for destructing it.
* rgerhards, 2008-02-20
*/
rsRetVal
static rsRetVal
ctok_tokenUnlinkCStr(ctok_token_t *pThis, cstr_t **ppCStr)
{
DEFiRet;
@ -80,6 +80,38 @@ ctok_tokenUnlinkCStr(ctok_token_t *pThis, cstr_t **ppCStr)
RETiRet;
}
/* tell the caller if the supplied token is a compare operation */
static int ctok_tokenIsCmpOp(ctok_token_t *pThis)
{
return(pThis->tok >= ctok_CMP_EQ && pThis->tok <= ctok_CMP_GTEQ);
}
/* queryInterface function
* rgerhards, 2008-02-21
*/
BEGINobjQueryInterface(ctok_token)
CODESTARTobjQueryInterface(ctok_token)
if(pIf->ifVersion != ctok_tokenCURR_IF_VERSION) { /* check for current version, increment on each change */
ABORT_FINALIZE(RS_RET_INTERFACE_NOT_SUPPORTED);
}
/* ok, we have the right interface, so let's fill it
* Please note that we may also do some backwards-compatibility
* work here (if we can support an older interface version - that,
* of course, also affects the "if" above).
*/
pIf->oID = OBJctok_token;
pIf->Construct = ctok_tokenConstruct;
pIf->ConstructFinalize = ctok_tokenConstructFinalize;
pIf->Destruct = ctok_tokenDestruct;
pIf->UnlinkCStr = ctok_tokenUnlinkCStr;
pIf->IsCmpOp = ctok_tokenIsCmpOp;
finalize_it:
ENDobjQueryInterface(ctok_token)
BEGINObjClassInit(ctok_token, 1) /* class, version */
OBJSetMethodHandler(objMethod_CONSTRUCTION_FINALIZER, ctok_tokenConstructFinalize);
ENDObjClassInit(ctok_token)

19
ctok_token.h
View File

@ -65,15 +65,20 @@ typedef struct {
int64 intVal;
} ctok_token_t;
/* defines to handle compare operation tokens in a single if... */
#define ctok_tokenIsCmpOp(x) ((x)->tok >= ctok_CMP_EQ && (x)->tok <= ctok_CMP_GTEQ)
/* interfaces */
BEGINinterface(ctok_token) /* name must also be changed in ENDinterface macro! */
INTERFACEObjDebugPrint(ctok_token);
rsRetVal (*Construct)(ctok_token_t **ppThis);
rsRetVal (*ConstructFinalize)(ctok_token_t __attribute__((unused)) *pThis);
rsRetVal (*Destruct)(ctok_token_t **ppThis);
rsRetVal (*UnlinkCStr)(ctok_token_t *pThis, cstr_t **ppCStr);
int (*IsCmpOp)(ctok_token_t *pThis);
ENDinterface(ctok_token)
#define ctok_tokenCURR_IF_VERSION 1 /* increment whenever you change the interface structure! */
/* prototypes */
rsRetVal ctok_tokenConstruct(ctok_token_t **ppThis);
rsRetVal ctok_tokenConstructFinalize(ctok_token_t __attribute__((unused)) *pThis);
rsRetVal ctok_tokenDestruct(ctok_token_t **ppThis);
rsRetVal ctok_tokenUnlinkCStr(ctok_token_t *pThis, cstr_t **ppCStr);
PROTOTYPEObjClassInit(ctok_token);
PROTOTYPEObj(ctok_token);
#endif /* #ifndef INCLUDED_CTOK_TOKEN_H */

111
expr.c
View File

@ -38,6 +38,8 @@
DEFobjStaticHelpers
DEFobjCurrIf(vmprg)
DEFobjCurrIf(var)
DEFobjCurrIf(ctok_token)
DEFobjCurrIf(ctok)
/* ------------------------------ parser functions ------------------------------ */
@ -53,11 +55,11 @@ DEFobjCurrIf(var)
*/
/* forward definiton - thanks to recursive ABNF, we can not avoid at least one ;) */
static rsRetVal expr(expr_t *pThis, ctok_t *ctok);
static rsRetVal expr(expr_t *pThis, ctok_t *tok);
static rsRetVal
terminal(expr_t *pThis, ctok_t *ctok)
terminal(expr_t *pThis, ctok_t *tok)
{
DEFiRet;
ctok_token_t *pToken;
@ -65,19 +67,18 @@ terminal(expr_t *pThis, ctok_t *ctok)
cstr_t *pCStr;
ISOBJ_TYPE_assert(pThis, expr);
ISOBJ_TYPE_assert(ctok, ctok);
ISOBJ_TYPE_assert(tok, ctok);
CHKiRet(ctokGetToken(ctok, &pToken));
CHKiRet(ctok.GetToken(tok, &pToken));
switch(pToken->tok) {
case ctok_SIMPSTR:
CHKiRet(var.Construct(&pVar));
CHKiRet(var.ConstructFinalize(pVar));
CHKiRet(ctok_tokenUnlinkCStr(pToken, &pCStr));
CHKiRet(ctok_token.UnlinkCStr(pToken, &pCStr));
CHKiRet(var.SetString(pVar, pCStr));
dbgoprint((obj_t*) pThis, "simpstr\n");
CHKiRet(vmprg.AddVarOperation(pThis->pVmprg, opcode_PUSHCONSTANT, pVar)); /* add to program */
// push val
break;
case ctok_NUMBER:
dbgoprint((obj_t*) pThis, "number\n");
@ -101,12 +102,12 @@ terminal(expr_t *pThis, ctok_t *ctok)
break;
case ctok_LPAREN:
dbgoprint((obj_t*) pThis, "expr\n");
CHKiRet(ctok_tokenDestruct(&pToken)); /* "eat" processed token */
CHKiRet(expr(pThis, ctok));
CHKiRet(ctokGetToken(ctok, &pToken)); /* get next one */
CHKiRet(ctok_token.Destruct(&pToken)); /* "eat" processed token */
CHKiRet(expr(pThis, tok));
CHKiRet(ctok.GetToken(tok, &pToken)); /* get next one */
if(pToken->tok != ctok_RPAREN)
ABORT_FINALIZE(RS_RET_SYNTAX_ERROR);
CHKiRet(ctok_tokenDestruct(&pToken)); /* "eat" processed token */
CHKiRet(ctok_token.Destruct(&pToken)); /* "eat" processed token */
dbgoprint((obj_t*) pThis, "end expr, rparen eaten\n");
break;
default:
@ -120,24 +121,24 @@ finalize_it:
}
static rsRetVal
factor(expr_t *pThis, ctok_t *ctok)
factor(expr_t *pThis, ctok_t *tok)
{
DEFiRet;
ctok_token_t *pToken;
ISOBJ_TYPE_assert(pThis, expr);
ISOBJ_TYPE_assert(ctok, ctok);
ISOBJ_TYPE_assert(tok, ctok);
CHKiRet(ctokGetToken(ctok, &pToken));
CHKiRet(ctok.GetToken(tok, &pToken));
if(pToken->tok == ctok_NOT) {
dbgprintf("not\n");
CHKiRet(ctok_tokenDestruct(&pToken)); /* no longer needed */
CHKiRet(ctokGetToken(ctok, &pToken)); /* get next one */
CHKiRet(ctok_token.Destruct(&pToken)); /* no longer needed */
CHKiRet(ctok.GetToken(tok, &pToken)); /* get next one */
} else {
/* we could not process the token, so push it back */
CHKiRet(ctokUngetToken(ctok, pToken));
CHKiRet(ctok.UngetToken(tok, pToken));
}
CHKiRet(terminal(pThis, ctok));
CHKiRet(terminal(pThis, tok));
// vm: not
finalize_it:
@ -146,14 +147,14 @@ finalize_it:
static rsRetVal
term(expr_t *pThis, ctok_t *ctok)
term(expr_t *pThis, ctok_t *tok)
{
DEFiRet;
ISOBJ_TYPE_assert(pThis, expr);
ISOBJ_TYPE_assert(ctok, ctok);
ISOBJ_TYPE_assert(tok, ctok);
CHKiRet(factor(pThis, ctok));
CHKiRet(factor(pThis, tok));
// vm: +/-
finalize_it:
@ -161,27 +162,27 @@ finalize_it:
}
static rsRetVal
val(expr_t *pThis, ctok_t *ctok)
val(expr_t *pThis, ctok_t *tok)
{
DEFiRet;
ctok_token_t *pToken;
ISOBJ_TYPE_assert(pThis, expr);
ISOBJ_TYPE_assert(ctok, ctok);
ISOBJ_TYPE_assert(tok, ctok);
CHKiRet(ctokGetToken(ctok, &pToken));
CHKiRet(ctok.GetToken(tok, &pToken));
if(pToken->tok == ctok_PLUS || pToken->tok == ctok_MINUS) {
/* TODO: this must be a loop! */
dbgprintf("plus/minus\n");
CHKiRet(ctok_tokenDestruct(&pToken)); /* no longer needed */
CHKiRet(ctok_token.Destruct(&pToken)); /* no longer needed */
// vm: +/-???
CHKiRet(ctokGetToken(ctok, &pToken)); /* get next one */
CHKiRet(ctok.GetToken(tok, &pToken)); /* get next one */
} else {
/* we could not process the token, so push it back */
CHKiRet(ctokUngetToken(ctok, pToken));
CHKiRet(ctok.UngetToken(tok, pToken));
}
CHKiRet(term(pThis, ctok));
CHKiRet(term(pThis, tok));
finalize_it:
RETiRet;
@ -189,26 +190,26 @@ finalize_it:
static rsRetVal
e_cmp(expr_t *pThis, ctok_t *ctok)
e_cmp(expr_t *pThis, ctok_t *tok)
{
DEFiRet;
ctok_token_t *pToken;
ISOBJ_TYPE_assert(pThis, expr);
ISOBJ_TYPE_assert(ctok, ctok);
ISOBJ_TYPE_assert(tok, ctok);
CHKiRet(val(pThis, ctok));
CHKiRet(val(pThis, tok));
/* 0*1(cmp_op val) part */
CHKiRet(ctokGetToken(ctok, &pToken));
if(ctok_tokenIsCmpOp(pToken)) {
CHKiRet(ctok.GetToken(tok, &pToken));
if(ctok_token.IsCmpOp(pToken)) {
dbgoprint((obj_t*) pThis, "cmp\n");
CHKiRet(val(pThis, ctok));
CHKiRet(val(pThis, tok));
CHKiRet(vmprg.AddVarOperation(pThis->pVmprg, (opcode_t) pToken->tok, NULL)); /* add to program */
CHKiRet(ctok_tokenDestruct(&pToken)); /* no longer needed */
CHKiRet(ctok_token.Destruct(&pToken)); /* no longer needed */
} else {
/* we could not process the token, so push it back */
CHKiRet(ctokUngetToken(ctok, pToken));
CHKiRet(ctok.UngetToken(tok, pToken));
}
@ -218,31 +219,31 @@ finalize_it:
static rsRetVal
e_and(expr_t *pThis, ctok_t *ctok)
e_and(expr_t *pThis, ctok_t *tok)
{
DEFiRet;
ctok_token_t *pToken;
ISOBJ_TYPE_assert(pThis, expr);
ISOBJ_TYPE_assert(ctok, ctok);
ISOBJ_TYPE_assert(tok, ctok);
CHKiRet(e_cmp(pThis, ctok));
CHKiRet(e_cmp(pThis, tok));
/* *("and" e_cmp) part */
CHKiRet(ctokGetToken(ctok, &pToken));
CHKiRet(ctok.GetToken(tok, &pToken));
while(pToken->tok == ctok_AND) {
dbgoprint((obj_t*) pThis, "and\n");
/* fill structure */
CHKiRet(ctok_tokenDestruct(&pToken)); /* no longer needed */
CHKiRet(e_cmp(pThis, ctok));
CHKiRet(ctok_token.Destruct(&pToken)); /* no longer needed */
CHKiRet(e_cmp(pThis, tok));
CHKiRet(vmprg.AddVarOperation(pThis->pVmprg, opcode_AND, NULL)); /* add to program */
CHKiRet(ctokGetToken(ctok, &pToken));
CHKiRet(ctok.GetToken(tok, &pToken));
}
/* unget the token that made us exit the loop - it's obviously not one
* we can process.
*/
CHKiRet(ctokUngetToken(ctok, pToken));
CHKiRet(ctok.UngetToken(tok, pToken));
finalize_it:
RETiRet;
@ -250,31 +251,31 @@ finalize_it:
static rsRetVal
expr(expr_t *pThis, ctok_t *ctok)
expr(expr_t *pThis, ctok_t *tok)
{
DEFiRet;
ctok_token_t *pToken;
ISOBJ_TYPE_assert(pThis, expr);
ISOBJ_TYPE_assert(ctok, ctok);
ISOBJ_TYPE_assert(tok, ctok);
CHKiRet(e_and(pThis, ctok));
CHKiRet(e_and(pThis, tok));
/* *("or" e_and) part */
CHKiRet(ctokGetToken(ctok, &pToken));
CHKiRet(ctok.GetToken(tok, &pToken));
while(pToken->tok == ctok_OR) {
/* fill structure */
dbgoprint((obj_t*) pThis, "found OR\n");
CHKiRet(ctok_tokenDestruct(&pToken)); /* no longer needed */
CHKiRet(e_and(pThis, ctok));
CHKiRet(ctok_token.Destruct(&pToken)); /* no longer needed */
CHKiRet(e_and(pThis, tok));
CHKiRet(vmprg.AddVarOperation(pThis->pVmprg, opcode_OR, NULL)); /* add to program */
CHKiRet(ctokGetToken(ctok, &pToken));
CHKiRet(ctok.GetToken(tok, &pToken));
}
/* unget the token that made us exit the loop - it's obviously not one
* we can process.
*/
CHKiRet(ctokUngetToken(ctok, pToken));
CHKiRet(ctok.UngetToken(tok, pToken));
finalize_it:
RETiRet;
@ -356,19 +357,19 @@ exprGetStr(expr_t *pThis, cstr_t **ppStr)
* rgerhards, 2008-02-19
*/
rsRetVal
exprParse(expr_t *pThis, ctok_t *ctok)
exprParse(expr_t *pThis, ctok_t *tok)
{
DEFiRet;
ISOBJ_TYPE_assert(pThis, expr);
ISOBJ_TYPE_assert(ctok, ctok);
ISOBJ_TYPE_assert(tok, ctok);
/* first, we need to make sure we have a program where we can add to what we parse... */
CHKiRet(vmprg.Construct(&pThis->pVmprg));
CHKiRet(vmprg.ConstructFinalize(pThis->pVmprg));
/* happy parsing... */
CHKiRet(expr(pThis, ctok));
CHKiRet(expr(pThis, tok));
dbgoprint((obj_t*) pThis, "successfully parsed/created expression\n");
vmprg.DebugPrint(pThis->pVmprg);
@ -409,6 +410,8 @@ BEGINObjClassInit(expr, 1) /* class, version */
/* request objects we use */
CHKiRet(objUse(vmprg));
CHKiRet(objUse(var));
CHKiRet(objUse(ctok_token));
CHKiRet(objUse(ctok));
OBJSetMethodHandler(objMethod_CONSTRUCTION_FINALIZER, exprConstructFinalize);
ENDObjClassInit(expr)

8
expr.h
View File

@ -40,18 +40,16 @@ typedef struct expr_s {
/* interfaces */
typedef struct expr_if_s {
ifBEGIN; /* This MUST always be the first interface member */
BEGINinterface(expr) /* name must also be changed in ENDinterface macro! */
INTERFACEObjDebugPrint(expr);
rsRetVal (*Construct)(expr_t **ppThis);
rsRetVal (*ConstructFinalize)(expr_t __attribute__((unused)) *pThis);
rsRetVal (*Destruct)(expr_t **ppThis);
rsRetVal (*Parse)(expr_t *pThis, ctok_t *ctok);
} expr_if_t;
ENDinterface(expr)
#define exprCURR_IF_VERSION 1 /* increment whenever you change the interface structure! */
/* prototypes */
PROTOTYPEObjClassInit(expr);
PROTOTYPEObjQueryInterface(expr);
PROTOTYPEObj(expr);
#endif /* #ifndef INCLUDED_EXPR_H */

18
obj-types.h
View File

@ -138,6 +138,8 @@ typedef struct obj { /* the dummy struct that each derived class can be casted t
}
#define PROTOTYPEpropSetMeth(obj, prop, dataType)\
rsRetVal obj##Set##prop(obj##_t *pThis, dataType pVal)
#define INTERFACEpropSetMeth(obj, prop, dataType)\
rsRetVal (*Set##prop)(obj##_t *pThis, dataType)
/* class initializer */
#define PROTOTYPEObjClassInit(objName) rsRetVal objName##ClassInit(void)
#define BEGINObjClassInit(objName, objVers) \
@ -288,6 +290,7 @@ finalize_it: \
#define ENDobjQueryInterface(obj) \
RETiRet; \
}
/* the base data type for interfaces
* This MUST be in sync with the ifBEGIN macro
*/
@ -297,6 +300,15 @@ typedef struct interface_s {
} interface_t;
/* the following macros should be used to define interfaces inside the
* header files.
*/
#define BEGINinterface(obj) \
typedef struct obj##_if_s {\
ifBEGIN; /* This MUST always be the first interface member */
#define ENDinterface(obj) \
} obj##_if_t;
/* the following macro is used to get access to an object (not an instance,
* just the class itself!). It must be called before any of the object's
* methods can be accessed.
@ -316,6 +328,12 @@ typedef struct interface_s {
#define DEFobjCurrIf(obj) \
static obj##_if_t obj = { .ifVersion = obj##CURR_IF_VERSION };
/* define the prototypes for a class - when we use interfaces, we just have few
* functions that actually need to be non-static.
*/
#define PROTOTYPEObj(obj) \
PROTOTYPEObjClassInit(obj); \
PROTOTYPEObjQueryInterface(obj) \
/* ------------------------------ end object loader system ------------------------------ */

21
var.c
View File

@ -102,8 +102,7 @@ varUnsetValues(var_t *pThis)
}
/* set a string value
*/
/* set a string value */
static rsRetVal
varSetString(var_t *pThis, cstr_t *pCStr)
{
@ -120,6 +119,23 @@ finalize_it:
}
/* set an int64 value */
static rsRetVal
varSetInt64(var_t *pThis, int64 iVal)
{
DEFiRet;
ISOBJ_TYPE_assert(pThis, var);
CHKiRet(varUnsetValues(pThis));
pThis->varType = VARTYPE_INT64;
pThis->val.vInt64 = iVal;
finalize_it:
RETiRet;
}
/* queryInterface function
* rgerhards, 2008-02-21
*/
@ -140,6 +156,7 @@ CODESTARTobjQueryInterface(var)
pIf->ConstructFinalize = varConstructFinalize;
pIf->Destruct = varDestruct;
pIf->DebugPrint = varDebugPrint;
pIf->SetInt64 = varSetInt64;
pIf->SetString = varSetString;
finalize_it:
ENDobjQueryInterface(var)

17
var.h
View File

@ -31,8 +31,9 @@ typedef enum {
VARTYPE_SHORT = 2,
VARTYPE_INT = 3,
VARTYPE_LONG = 4,
VARTYPE_CSTR = 5,
VARTYPE_SYSLOGTIME = 6
VARTYPE_INT64 = 5,
VARTYPE_CSTR = 6,
VARTYPE_SYSLOGTIME = 7
} varType_t;
/* the var object */
@ -44,6 +45,7 @@ typedef struct var_s {
short vShort;
int vInt;
long vLong;
int64 vInt64;
cstr_t *vpCStr; /* used for both rsCStr and psz */
syslogTime_t vSyslogTime;
@ -52,19 +54,18 @@ typedef struct var_s {
/* interfaces */
typedef struct var_if_s {
ifBEGIN; /* This MUST always be the first interface member */
BEGINinterface(var) /* name must also be changed in ENDinterface macro! */
INTERFACEObjDebugPrint(var);
rsRetVal (*Construct)(var_t **ppThis);
rsRetVal (*ConstructFinalize)(var_t __attribute__((unused)) *pThis);
rsRetVal (*Destruct)(var_t **ppThis);
rsRetVal (*SetInt64)(var_t *pThis, int64 iVal);
rsRetVal (*SetString)(var_t *pThis, cstr_t *pCStr);
} var_if_t;
#define varCURR_IF_VERSION 1 /* increment whenever you change the interface structure! */
ENDinterface(var)
#define varCURR_IF_VERSION 1 /* increment whenever you change the interface above! */
/* prototypes */
PROTOTYPEObjClassInit(var);
PROTOTYPEObjQueryInterface(var);
PROTOTYPEObj(var);
#endif /* #ifndef INCLUDED_VAR_H */

8
vmop.h
View File

@ -67,8 +67,7 @@ typedef struct vmop_s {
/* interfaces */
typedef struct vmop_if_s {
ifBEGIN; /* This MUST always be the first interface member */
BEGINinterface(vmop) /* name must also be changed in ENDinterface macro! */
INTERFACEObjDebugPrint(vmop);
rsRetVal (*Construct)(vmop_t **ppThis);
rsRetVal (*ConstructFinalize)(vmop_t __attribute__((unused)) *pThis);
@ -76,11 +75,10 @@ typedef struct vmop_if_s {
rsRetVal (*SetOpcode)(vmop_t *pThis, opcode_t opcode);
rsRetVal (*SetVar)(vmop_t *pThis, var_t *pVar);
rsRetVal (*Opcode2Str)(vmop_t *pThis, uchar **ppName);
} vmop_if_t;
ENDinterface(vmop)
#define vmopCURR_IF_VERSION 1 /* increment whenever you change the interface structure! */
/* the remaining prototypes */
PROTOTYPEObjClassInit(vmop);
PROTOTYPEObjQueryInterface(vmop);
PROTOTYPEObj(vmop);
#endif /* #ifndef INCLUDED_VMOP_H */

9
vmprg.h
View File

@ -48,21 +48,18 @@ typedef struct vmprg_s {
/* interfaces */
typedef struct vmprg_if_s {
ifBEGIN; /* This MUST always be the first interface member */
BEGINinterface(vmprg) /* name must also be changed in ENDinterface macro! */
INTERFACEObjDebugPrint(vmprg);
rsRetVal (*Construct)(vmprg_t **ppThis);
rsRetVal (*ConstructFinalize)(vmprg_t __attribute__((unused)) *pThis);
rsRetVal (*Destruct)(vmprg_t **ppThis);
rsRetVal (*AddOperation)(vmprg_t *pThis, vmop_t *pOp);
rsRetVal (*AddVarOperation)(vmprg_t *pThis, opcode_t opcode, var_t *pVar);
} vmprg_if_t;
ENDinterface(vmprg)
#define vmprgCURR_IF_VERSION 1 /* increment whenever you change the interface structure! */
/* prototypes */
PROTOTYPEObjClassInit(vmprg);
PROTOTYPEObjQueryInterface(vmprg);
PROTOTYPEObj(vmprg);
#endif /* #ifndef INCLUDED_VMPRG_H */