some more interface changes

12 files changed, 222 insertions, 110 deletions

diff --git a/conf.c b/conf.c
index 89bc1c33..7140a98c 100644
--- a/conf.c
+++ b/conf.c
@@ -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;
 }
diff --git a/ctok.c b/ctok.c
index b0c24b9b..71b10098 100644
--- a/ctok.c
+++ b/ctok.c
@@ -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)
 
diff --git a/ctok.h b/ctok.h
index 26dae5f1..aa1af4e0 100644
--- a/ctok.h
+++ b/ctok.h
@@ -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 */
diff --git a/ctok_token.c b/ctok_token.c
index 11667323..a7acabd2 100644
--- a/ctok_token.c
+++ b/ctok_token.c
@@ -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)
diff --git a/ctok_token.h b/ctok_token.h
index a93cfe49..4ea88d1a 100644
--- a/ctok_token.h
+++ b/ctok_token.h
@@ -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 */
diff --git a/expr.c b/expr.c
index 785d4216..23284b10 100644
--- a/expr.c
+++ b/expr.c
@@ -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)
diff --git a/expr.h b/expr.h
index 78005a5a..34816952 100644
--- a/expr.h
+++ b/expr.h
@@ -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 */
diff --git a/obj-types.h b/obj-types.h
index 3046e96f..ee82c49f 100644
--- a/obj-types.h
+++ b/obj-types.h
@@ -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 ------------------------------ */
 
 
diff --git a/var.c b/var.c
index 308bd684..c4cf0b9b 100644
--- a/var.c
+++ b/var.c
@@ -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)
diff --git a/var.h b/var.h
index f400b109..24efca7b 100644
--- a/var.h
+++ b/var.h
@@ -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 */
diff --git a/vmop.h b/vmop.h
index 6964f7fd..dea54dbd 100644
--- a/vmop.h
+++ b/vmop.h
@@ -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 */
diff --git a/vmprg.h b/vmprg.h
index f69abca1..71e77e19 100644
--- a/vmprg.h
+++ b/vmprg.h
@@ -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 */