cleanup, removing now unused code

17 files changed, 0 insertions, 2631 deletions

diff --git a/runtime/Makefile.am b/runtime/Makefile.am
index c6c860ea..7f7e55fd 100644
--- a/runtime/Makefile.am
+++ b/runtime/Makefile.am
@@ -5,16 +5,6 @@ pkglib_LTLIBRARIES =
 #pkglib_LTLIBRARIES = librsyslog.la
 
 librsyslog_la_SOURCES = \
-	expr.c \
-	expr.h \
-	vm.c \
-	vm.h \
-	vmstk.c \
-	vmstk.h \
-	vmprg.c \
-	vmprg.h \
-	vmop.c \
-	vmop.h \
 	rsyslog.c \
 	rsyslog.h \
 	typedefs.h \
diff --git a/runtime/conf.c b/runtime/conf.c
index 4c8f2285..413d02bb 100644
--- a/runtime/conf.c
+++ b/runtime/conf.c
@@ -65,7 +65,6 @@
 #include "srUtils.h"
 #include "errmsg.h"
 #include "net.h"
-#include "expr.h"
 #include "ctok.h"
 #include "ctok_token.h"
 #include "rule.h"
@@ -83,7 +82,6 @@ static rsRetVal cfline(rsconf_t *conf, uchar *line, rule_t **pfCurr);
 
 /* static data */
 DEFobjStaticHelpers
-DEFobjCurrIf(expr)
 DEFobjCurrIf(ctok)
 DEFobjCurrIf(ctok_token)
 DEFobjCurrIf(module)
@@ -508,77 +506,6 @@ rsRetVal cflineProcessTradPRIFilter(uchar **pline, register rule_t *pRule)
 }
 
 
-#if 0
-/* Helper to cfline(). This function processes an "if" type of filter,
- * what essentially means it parses an expression. As usual, 
- * It processes the line up to the beginning of the action part.
- * A pointer to that beginnig is passed back to the caller.
- * rgerhards 2008-01-19
- */
-static rsRetVal cflineProcessIfFilter(uchar **pline, register rule_t *f)
-{
-	DEFiRet;
-	ctok_t *tok;
-	ctok_token_t *pToken;
-
-	ASSERT(pline != NULL);
-	ASSERT(*pline != NULL);
-	ASSERT(f != NULL);
-
-	dbgprintf(" - general expression-based filter\n");
-	errno = 0;	/* keep strerror_r() stuff out of logerror messages */
-
-	f->f_filter_type = FILTER_EXPR;
-
-	/* if we come to over here, pline starts with "if ". We just skip that part. */
-	(*pline) += 3;
-
-	/* we first need a tokenizer... */
-	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, tok));
-
-	/* we now need to parse off the "then" - and note an error if it is
-	 * missing...
-	 */
-	CHKiRet(ctok.GetToken(tok, &pToken));
-	if(pToken->tok != ctok_THEN) {
-		ctok_token.Destruct(&pToken);
-		ABORT_FINALIZE(RS_RET_SYNTAX_ERROR);
-	}
-
-	ctok_token.Destruct(&pToken); /* no longer needed */
-
-	/* we are done, so we now need to restore things */
-	CHKiRet(ctok.Getpp(tok, pline));
-	CHKiRet(ctok.Destruct(&tok));
-
-	/* debug support - print vmprg after construction (uncomment to use) */
-	/* vmprgDebugPrint(f->f_filterData.f_expr->pVmprg); */
-
-	/* we now need to skip whitespace to the action part, else we confuse
-	 * the legacy rsyslog conf parser. -- rgerhards, 2008-02-25
-	 */
-	while(isspace(**pline))
-		++(*pline);
-
-finalize_it:
-	if(iRet == RS_RET_SYNTAX_ERROR) {
-		errmsg.LogError(0, RS_RET_SYNTAX_ERROR, "syntax error in expression");
-	}
-
-	RETiRet;
-}
-#endif
-
-
 /* Helper to cfline(). This function takes the filter part of a property
  * based filter and decodes it. It processes the line up to the beginning
  * of the action part. A pointer to that beginnig is passed back to the caller.
@@ -808,14 +735,6 @@ static rsRetVal cflineDoFilter(uchar **pp, rule_t *f)
 		case ':':
 			CHKiRet(cflineProcessPropFilter(pp, f));
 			break;
-#if 0
-		case 'i': /* "if" filter? */
-			if(*(*pp+1) && (*(*pp+1) == 'f') && isspace(*(*pp+2))) {
-				CHKiRet(cflineProcessIfFilter(pp, f));
-				break;
-				}
-			/*FALLTHROUGH*/
-#endif
 		default:
 			CHKiRet(cflineProcessTradPRIFilter(pp, f));
 			break;
@@ -1163,7 +1082,6 @@ CODESTARTObjClassExit(conf)
 	}
 
 	/* release objects we no longer need */
-	objRelease(expr, CORE_COMPONENT);
 	objRelease(ctok, CORE_COMPONENT);
 	objRelease(ctok_token, CORE_COMPONENT);
 	objRelease(module, CORE_COMPONENT);
@@ -1180,7 +1098,6 @@ ENDObjClassExit(conf)
  */
 BEGINAbstractObjClassInit(conf, 1, OBJ_IS_CORE_MODULE) /* class, version - CHANGE class also in END MACRO! */
 	/* request objects we use */
-	CHKiRet(objUse(expr, CORE_COMPONENT));
 	CHKiRet(objUse(ctok, CORE_COMPONENT));
 	CHKiRet(objUse(ctok_token, CORE_COMPONENT));
 	CHKiRet(objUse(module, CORE_COMPONENT));
diff --git a/runtime/expr.c b/runtime/expr.c
deleted file mode 100644
index 01431474..00000000
--- a/runtime/expr.c
+++ /dev/null
@@ -1,482 +0,0 @@
-/* expr.c - an expression class.
- * This module contains all code needed to represent expressions. Most
- * importantly, that means code to parse and execute them. Expressions
- * heavily depend on (loadable) functions, so it works in conjunction
- * with the function manager.
- *
- * Module begun 2007-11-30 by Rainer Gerhards
- *
- * Copyright 2007, 2008 Rainer Gerhards and Adiscon GmbH.
- *
- * This file is part of the rsyslog runtime library.
- *
- * The rsyslog runtime library is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * The rsyslog runtime library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with the rsyslog runtime library.  If not, see <http://www.gnu.org/licenses/>.
- *
- * A copy of the GPL can be found in the file "COPYING" in this distribution.
- * A copy of the LGPL can be found in the file "COPYING.LESSER" in this distribution.
- */
-
-#include "config.h"
-#include <stdlib.h>
-#include <assert.h>
-
-#include "rsyslog.h"
-#include "template.h"
-#include "expr.h"
-
-/* static data */
-DEFobjStaticHelpers
-DEFobjCurrIf(vmprg)
-DEFobjCurrIf(var)
-DEFobjCurrIf(ctok_token)
-DEFobjCurrIf(ctok)
-
-
-/* ------------------------------ parser functions ------------------------------ */
-/* the following functions implement the parser. They are all static. For
- * simplicity, the function names match their ABNF definition. The ABNF is defined
- * in the doc set. See file expression.html for details. I do *not* reproduce it
- * here in an effort to keep both files in sync.
- * 
- * All functions receive the current expression object as parameter as well as the
- * current tokenizer.
- *
- * rgerhards, 2008-02-19
- */
-
-/* forward definition - thanks to recursive ABNF, we can not avoid at least one ;) */
-static rsRetVal expr(expr_t *pThis, ctok_t *tok);
-
-
-static rsRetVal
-function(expr_t *pThis, ctok_t *tok)
-{
-	DEFiRet;
-	ctok_token_t *pToken = NULL;
-	int iNumArgs = 0;
-	var_t *pVar;
-
-	ISOBJ_TYPE_assert(pThis, expr);
-	ISOBJ_TYPE_assert(tok, ctok);
-
-	CHKiRet(ctok.GetToken(tok, &pToken));
-	/* note: pToken is destructed in finalize_it */
-
-	if(pToken->tok == ctok_LPAREN) {
-		CHKiRet(ctok_token.Destruct(&pToken)); /* token processed, "eat" it */
-		CHKiRet(ctok.GetToken(tok, &pToken)); /* get next one */
-	} else
-		ABORT_FINALIZE(RS_RET_FUNC_NO_LPAREN);
-
-	/* we first push all the params on the stack. Then we call the function */
-	while(pToken->tok != ctok_RPAREN) { 
-		++iNumArgs;
-		CHKiRet(ctok.UngetToken(tok, pToken)); /* not for us, so let others process it */
-		CHKiRet(expr(pThis, tok));
-		CHKiRet(ctok.GetToken(tok, &pToken)); /* get next one, needed for while() check */
-		if(pToken->tok == ctok_COMMA) {
-			CHKiRet(ctok_token.Destruct(&pToken)); /* token processed, "eat" it */
-			CHKiRet(ctok.GetToken(tok, &pToken)); /* get next one */
-			if(pToken->tok == ctok_RPAREN) {
-				ABORT_FINALIZE(RS_RET_FUNC_MISSING_EXPR);
-			}
-		}
-	}
-
-
-	/* now push number of arguments - this must be on top of the stack */
-	CHKiRet(var.Construct(&pVar));
-	CHKiRet(var.ConstructFinalize(pVar));
-	CHKiRet(var.SetNumber(pVar, iNumArgs));
-	CHKiRet(vmprg.AddVarOperation(pThis->pVmprg, opcode_PUSHCONSTANT, pVar)); /* add to program */
-
-
-finalize_it:
-	if(pToken != NULL) {
-		ctok_token.Destruct(&pToken); /* "eat" processed token */
-	}
-
-	RETiRet;
-}
-
-
-static rsRetVal
-terminal(expr_t *pThis, ctok_t *tok)
-{
-	DEFiRet;
-	ctok_token_t *pToken = NULL;
-	var_t *pVar;
-
-	ISOBJ_TYPE_assert(pThis, expr);
-	ISOBJ_TYPE_assert(tok, ctok);
-
-	CHKiRet(ctok.GetToken(tok, &pToken));
-	/* note: pToken is destructed in finalize_it */
-
-	switch(pToken->tok) {
-		case ctok_SIMPSTR:
-			dbgoprint((obj_t*) pThis, "simpstr\n");
-			CHKiRet(ctok_token.UnlinkVar(pToken, &pVar));
-			CHKiRet(vmprg.AddVarOperation(pThis->pVmprg, opcode_PUSHCONSTANT, pVar)); /* add to program */
-			break;
-		case ctok_NUMBER:
-			dbgoprint((obj_t*) pThis, "number\n");
-			CHKiRet(ctok_token.UnlinkVar(pToken, &pVar));
-			CHKiRet(vmprg.AddVarOperation(pThis->pVmprg, opcode_PUSHCONSTANT, pVar)); /* add to program */
-			break;
-		case ctok_FUNCTION:
-			dbgoprint((obj_t*) pThis, "function\n");
-			CHKiRet(function(pThis, tok)); /* this creates the stack call frame */
-			/* ... but we place the call instruction onto the stack ourselfs (because
-			 * we have all relevant information)
-			 */
-			CHKiRet(ctok_token.UnlinkVar(pToken, &pVar));
-			CHKiRet(var.ConvToString(pVar)); /* make sure we have a string */
-			CHKiRet(vmprg.AddCallOperation(pThis->pVmprg, pVar->val.pStr)); /* add to program */
-			CHKiRet(var.Destruct(&pVar));
-			break;
-		case ctok_MSGVAR:
-			dbgoprint((obj_t*) pThis, "MSGVAR\n");
-			CHKiRet(ctok_token.UnlinkVar(pToken, &pVar));
-			CHKiRet(vmprg.AddVarOperation(pThis->pVmprg, opcode_PUSHMSGVAR, pVar)); /* add to program */
-			break;
-		case ctok_CEEVAR:
-			dbgoprint((obj_t*) pThis, "SYSVAR\n");
-			CHKiRet(ctok_token.UnlinkVar(pToken, &pVar));
-			CHKiRet(vmprg.AddVarOperation(pThis->pVmprg, opcode_PUSHCEEVAR, pVar)); /* add to program */
-			break;
-		case ctok_SYSVAR:
-			dbgoprint((obj_t*) pThis, "SYSVAR\n");
-			CHKiRet(ctok_token.UnlinkVar(pToken, &pVar));
-			CHKiRet(vmprg.AddVarOperation(pThis->pVmprg, opcode_PUSHSYSVAR, pVar)); /* add to program */
-			break;
-		case ctok_LPAREN:
-			dbgoprint((obj_t*) pThis, "expr\n");
-			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);
-			break;
-		default:
-			dbgoprint((obj_t*) pThis, "invalid token %d\n", pToken->tok);
-			ABORT_FINALIZE(RS_RET_SYNTAX_ERROR);
-			break;
-	}
-
-finalize_it:
-	if(pToken != NULL) {
-		ctok_token.Destruct(&pToken); /* "eat" processed token */
-	}
-
-	RETiRet;
-}
-
-static rsRetVal
-factor(expr_t *pThis, ctok_t *tok)
-{
-	DEFiRet;
-	ctok_token_t *pToken;
-	int bWasNot;
-	int bWasUnaryMinus;
-
-	ISOBJ_TYPE_assert(pThis, expr);
-	ISOBJ_TYPE_assert(tok, ctok);
-
-	CHKiRet(ctok.GetToken(tok, &pToken));
-	if(pToken->tok == ctok_NOT) {
-		dbgprintf("not\n");
-		bWasNot = 1;
-		CHKiRet(ctok_token.Destruct(&pToken)); /* no longer needed */
-		CHKiRet(ctok.GetToken(tok, &pToken)); /* get new one for next check */
-	} else {
-		bWasNot = 0;
-	}
-
-	if(pToken->tok == ctok_MINUS) {
-		dbgprintf("unary minus\n");
-		bWasUnaryMinus = 1;
-		CHKiRet(ctok_token.Destruct(&pToken)); /* no longer needed */
-	} else {
-		bWasUnaryMinus = 0;
-		/* we could not process the token, so push it back */
-		CHKiRet(ctok.UngetToken(tok, pToken));
-	}
-
-	CHKiRet(terminal(pThis, tok));
-
-	/* warning: the order if the two following ifs is important. Do not change them, this
-	 * would change the semantics of the expression!
-	 */
-	if(bWasUnaryMinus) {
-		CHKiRet(vmprg.AddVarOperation(pThis->pVmprg, opcode_UNARY_MINUS, NULL)); /* add to program */
-	}
-
-	if(bWasNot == 1) {
-		CHKiRet(vmprg.AddVarOperation(pThis->pVmprg, opcode_NOT, NULL)); /* add to program */
-	}
-
-finalize_it:
-	RETiRet;
-}
-
-
-static rsRetVal
-term(expr_t *pThis, ctok_t *tok)
-{
-	DEFiRet;
-	ctok_token_t *pToken;
-
-	ISOBJ_TYPE_assert(pThis, expr);
-	ISOBJ_TYPE_assert(tok, ctok);
-
-	CHKiRet(factor(pThis, tok));
-
- 	/* *(("*" / "/" / "%") factor) part */
-	CHKiRet(ctok.GetToken(tok, &pToken));
-	while(pToken->tok == ctok_TIMES || pToken->tok == ctok_DIV || pToken->tok == ctok_MOD) {
-		dbgoprint((obj_t*) pThis, "/,*,%%\n");
-		CHKiRet(factor(pThis, tok));
-		CHKiRet(vmprg.AddVarOperation(pThis->pVmprg, (opcode_t) pToken->tok, NULL)); /* add to program */
-		CHKiRet(ctok_token.Destruct(&pToken)); /* no longer needed */
-		CHKiRet(ctok.GetToken(tok, &pToken));
-	}
-
-	/* unget the token that made us exit the loop - it's obviously not one
-	 * we can process.
-	 */
-	CHKiRet(ctok.UngetToken(tok, pToken)); 
-
-finalize_it:
-	RETiRet;
-}
-
-static rsRetVal
-val(expr_t *pThis, ctok_t *tok)
-{
-	DEFiRet;
-	ctok_token_t *pToken;
-
-	ISOBJ_TYPE_assert(pThis, expr);
-	ISOBJ_TYPE_assert(tok, ctok);
-
-	CHKiRet(term(pThis, tok));
-
- 	/* *(("+" / "-") term) part */
-	CHKiRet(ctok.GetToken(tok, &pToken));
-	while(pToken->tok == ctok_PLUS || pToken->tok == ctok_MINUS || pToken->tok == ctok_STRADD) {
-		dbgoprint((obj_t*) pThis, "+/-/&\n");
-		CHKiRet(term(pThis, tok));
-		CHKiRet(vmprg.AddVarOperation(pThis->pVmprg, (opcode_t) pToken->tok, NULL)); /* add to program */
-		CHKiRet(ctok_token.Destruct(&pToken)); /* no longer needed */
-		CHKiRet(ctok.GetToken(tok, &pToken));
-	}
-
-	/* unget the token that made us exit the loop - it's obviously not one
-	 * we can process.
-	 */
-	CHKiRet(ctok.UngetToken(tok, pToken)); 
-
-finalize_it:
-	RETiRet;
-}
-
-
-static rsRetVal
-e_cmp(expr_t *pThis, ctok_t *tok)
-{
-	DEFiRet;
-	ctok_token_t *pToken;
-
-	ISOBJ_TYPE_assert(pThis, expr);
-	ISOBJ_TYPE_assert(tok, ctok);
-
-	CHKiRet(val(pThis, tok));
-
- 	/* 0*1(cmp_op val) part */
-	CHKiRet(ctok.GetToken(tok, &pToken));
-	if(ctok_token.IsCmpOp(pToken)) {
-		dbgoprint((obj_t*) pThis, "cmp\n");
-		CHKiRet(val(pThis, tok));
-		CHKiRet(vmprg.AddVarOperation(pThis->pVmprg, (opcode_t) pToken->tok, NULL)); /* add to program */
-		CHKiRet(ctok_token.Destruct(&pToken)); /* no longer needed */
-	} else {
-		/* we could not process the token, so push it back */
-		CHKiRet(ctok.UngetToken(tok, pToken));
-	}
-
-
-finalize_it:
-	RETiRet;
-}
-
-
-static rsRetVal
-e_and(expr_t *pThis, ctok_t *tok)
-{
-	DEFiRet;
-	ctok_token_t *pToken;
-
-	ISOBJ_TYPE_assert(pThis, expr);
-	ISOBJ_TYPE_assert(tok, ctok);
-
-	CHKiRet(e_cmp(pThis, tok));
-
- 	/* *("and" e_cmp) part */
-	CHKiRet(ctok.GetToken(tok, &pToken));
-	while(pToken->tok == ctok_AND) {
-		dbgoprint((obj_t*) pThis, "and\n");
-		CHKiRet(e_cmp(pThis, tok));
-		CHKiRet(vmprg.AddVarOperation(pThis->pVmprg, opcode_AND, NULL)); /* add to program */
-		CHKiRet(ctok_token.Destruct(&pToken)); /* no longer needed */
-		CHKiRet(ctok.GetToken(tok, &pToken));
-	}
-
-	/* unget the token that made us exit the loop - it's obviously not one
-	 * we can process.
-	 */
-	CHKiRet(ctok.UngetToken(tok, pToken)); 
-
-finalize_it:
-	RETiRet;
-}
-
-
-static rsRetVal
-expr(expr_t *pThis, ctok_t *tok)
-{
-	DEFiRet;
-	ctok_token_t *pToken;
-
-	ISOBJ_TYPE_assert(pThis, expr);
-	ISOBJ_TYPE_assert(tok, ctok);
-
-	CHKiRet(e_and(pThis, tok));
-
- 	/* *("or" e_and) part */
-	CHKiRet(ctok.GetToken(tok, &pToken));
-	while(pToken->tok == ctok_OR) {
-		dbgoprint((obj_t*) pThis, "found OR\n");
-		CHKiRet(e_and(pThis, tok));
-		CHKiRet(vmprg.AddVarOperation(pThis->pVmprg, opcode_OR, NULL)); /* add to program */
-		CHKiRet(ctok_token.Destruct(&pToken)); /* no longer needed */
-		CHKiRet(ctok.GetToken(tok, &pToken));
-	}
-
-	/* unget the token that made us exit the loop - it's obviously not one
-	 * we can process.
-	 */
-	CHKiRet(ctok.UngetToken(tok, pToken)); 
-
-finalize_it:
-	RETiRet;
-}
-
-
-/* ------------------------------ end parser functions ------------------------------ */
-
-
-/* ------------------------------ actual expr object functions ------------------------------ */
-
-/* Standard-Constructor
- * rgerhards, 2008-02-09 (a rainy Tenerife return flight day ;))
- */
-BEGINobjConstruct(expr) /* be sure to specify the object type also in END macro! */
-ENDobjConstruct(expr)
-
-
-/* ConstructionFinalizer
- * rgerhards, 2008-01-09
- */
-rsRetVal exprConstructFinalize(expr_t __attribute__((unused)) *pThis)
-{
-	DEFiRet;
-
-	ISOBJ_TYPE_assert(pThis, expr);
-
-	RETiRet;
-}
-
-
-/* destructor for the expr object */
-BEGINobjDestruct(expr) /* be sure to specify the object type also in END and CODESTART macros! */
-CODESTARTobjDestruct(expr)
-	if(pThis->pVmprg != NULL)
-		vmprg.Destruct(&pThis->pVmprg);
-ENDobjDestruct(expr)
-
-
-/* parse an expression object based on a given tokenizer
- * rgerhards, 2008-02-19
- */
-rsRetVal
-exprParse(expr_t *pThis, ctok_t *tok)
-{
-	DEFiRet;
-
-	ISOBJ_TYPE_assert(pThis, expr);
-	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, tok));
-	dbgoprint((obj_t*) pThis, "successfully parsed/created expression\n");
-
-finalize_it:
-	RETiRet;
-}
-
-
-/* queryInterface function
- * rgerhards, 2008-02-21
- */
-BEGINobjQueryInterface(expr)
-CODESTARTobjQueryInterface(expr)
-	if(pIf->ifVersion != exprCURR_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->Construct = exprConstruct;
-	pIf->ConstructFinalize = exprConstructFinalize;
-	pIf->Destruct = exprDestruct;
-	pIf->Parse = exprParse;
-finalize_it:
-ENDobjQueryInterface(expr)
-
-
-/* Initialize the expr class. Must be called as the very first method
- * before anything else is called inside this class.
- * rgerhards, 2008-02-19
- */
-BEGINObjClassInit(expr, 1, OBJ_IS_CORE_MODULE) /* class, version */
-	/* request objects we use */
-	CHKiRet(objUse(var, CORE_COMPONENT));
-	CHKiRet(objUse(vmprg, CORE_COMPONENT));
-	CHKiRet(objUse(var, CORE_COMPONENT));
-	CHKiRet(objUse(ctok_token, CORE_COMPONENT));
-	CHKiRet(objUse(ctok, CORE_COMPONENT));
-
-	OBJSetMethodHandler(objMethod_CONSTRUCTION_FINALIZER, exprConstructFinalize);
-ENDObjClassInit(expr)
-
-/* vi:set ai:
- */
diff --git a/runtime/expr.h b/runtime/expr.h
deleted file mode 100644
index 1afe1a1f..00000000
--- a/runtime/expr.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/* The expr object.
- *
- * Copyright 2008 Rainer Gerhards and Adiscon GmbH.
- *
- * This file is part of the rsyslog runtime library.
- *
- * The rsyslog runtime library is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * The rsyslog runtime library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with the rsyslog runtime library.  If not, see <http://www.gnu.org/licenses/>.
- *
- * A copy of the GPL can be found in the file "COPYING" in this distribution.
- * A copy of the LGPL can be found in the file "COPYING.LESSER" in this distribution.
- */
-#ifndef INCLUDED_EXPR_H
-#define INCLUDED_EXPR_H
-
-#include "obj.h"
-#include "ctok.h"
-#include "vmprg.h"
-#include "stringbuf.h"
-
-/* a node inside an expression tree */
-typedef struct exprNode_s {
-    	char dummy;
-} exprNode_t;
-
-
-/* the expression object */
-typedef struct expr_s {
-	BEGINobjInstance;	/* Data to implement generic object - MUST be the first data element! */
-	vmprg_t *pVmprg;	/* the expression in vmprg format - ready to execute */
-} expr_t;
-
-
-/* interfaces */
-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);
-ENDinterface(expr)
-#define exprCURR_IF_VERSION 1 /* increment whenever you change the interface structure! */
-
-/* prototypes */
-PROTOTYPEObj(expr);
-
-#endif /* #ifndef INCLUDED_EXPR_H */
diff --git a/runtime/rsyslog.c b/runtime/rsyslog.c
index d71fe88a..c5abcb2a 100644
--- a/runtime/rsyslog.c
+++ b/runtime/rsyslog.c
@@ -62,16 +62,11 @@
 
 #include "rsyslog.h"
 #include "obj.h"
-#include "vm.h"
 #include "sysvar.h"
 #include "stringbuf.h"
 #include "wti.h"
 #include "wtp.h"
-#include "expr.h"
 #include "ctok.h"
-#include "vmop.h"
-#include "vmstk.h"
-#include "vmprg.h"
 #include "datetime.h"
 #include "queue.h"
 #include "conf.h"
@@ -182,22 +177,8 @@ rsrtInit(char **ppErrObj, obj_if_t *pObjIF)
 		CHKiRet(ctok_tokenClassInit(NULL));
 		if(ppErrObj != NULL) *ppErrObj = "ctok";
 		CHKiRet(ctokClassInit(NULL));
-#if 1
-		if(ppErrObj != NULL) *ppErrObj = "vmstk";
-		CHKiRet(vmstkClassInit(NULL));
-#endif
 		if(ppErrObj != NULL) *ppErrObj = "sysvar";
 		CHKiRet(sysvarClassInit(NULL));
-#if 1
-		if(ppErrObj != NULL) *ppErrObj = "vm";
-		CHKiRet(vmClassInit(NULL));
-		if(ppErrObj != NULL) *ppErrObj = "vmop";
-		CHKiRet(vmopClassInit(NULL));
-		if(ppErrObj != NULL) *ppErrObj = "vmprg";
-		CHKiRet(vmprgClassInit(NULL));
-		if(ppErrObj != NULL) *ppErrObj = "expr";
-		CHKiRet(exprClassInit(NULL));
-#endif
 		if(ppErrObj != NULL) *ppErrObj = "rule";
 		CHKiRet(ruleClassInit(NULL));
 		if(ppErrObj != NULL) *ppErrObj = "ruleset";
diff --git a/runtime/rule.c b/runtime/rule.c
index e7f3522e..1a430577 100644
--- a/runtime/rule.c
+++ b/runtime/rule.c
@@ -344,11 +344,6 @@ CODESTARTobjDestruct(rule)
 			rsCStrRegexDestruct(&pThis->f_filterData.prop.regex_cache);
 		if(pThis->f_filterData.prop.propName != NULL)
 			es_deleteStr(pThis->f_filterData.prop.propName);
-#if 0
-	} else if(pThis->f_filter_type == FILTER_EXPR) {
-		if(pThis->f_filterData.f_expr != NULL)
-			expr.Destruct(&pThis->f_filterData.f_expr);
-#endif
 	}
 
 	llDestroy(&pThis->llActList);
diff --git a/runtime/rule.h b/runtime/rule.h
index 8c2f72c9..76ed5f0b 100644
--- a/runtime/rule.h
+++ b/runtime/rule.h
@@ -28,7 +28,6 @@
 #include "libestr.h"
 #include "linkedlist.h"
 #include "regexp.h"
-#include "expr.h" // TODO: remove #if 0
 #include "rainerscript.h"
 
 /* the rule object */
diff --git a/runtime/vm.c b/runtime/vm.c
deleted file mode 100644
index bbc8d346..00000000
--- a/runtime/vm.c
+++ /dev/null
@@ -1,869 +0,0 @@
-/* vm.c - the arithmetic stack of a virtual machine.
- *
- * Module begun 2008-02-22 by Rainer Gerhards
- *
- * Copyright 2008 Rainer Gerhards and Adiscon GmbH.
- *
- * This file is part of the rsyslog runtime library.
- *
- * The rsyslog runtime library is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * The rsyslog runtime library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with the rsyslog runtime library.  If not, see <http://www.gnu.org/licenses/>.
- *
- * A copy of the GPL can be found in the file "COPYING" in this distribution.
- * A copy of the LGPL can be found in the file "COPYING.LESSER" in this distribution.
- */
-
-#include "config.h"
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-#include <ctype.h>
-
-#include "rsyslog.h"
-#include "obj.h"
-#include "vm.h"
-#include "sysvar.h"
-#include "stringbuf.h"
-#include "unicode-helper.h"
-
-/* static data */
-DEFobjStaticHelpers
-DEFobjCurrIf(vmstk)
-DEFobjCurrIf(var)
-DEFobjCurrIf(sysvar)
-
-static pthread_mutex_t mutGetenv; /* we need to make this global because otherwise we can not guarantee proper init! */
-
-/* ------------------------------ function registry code and structures  ------------------------------ */
-
-/* we maintain a registry of known functions */
-/* currently, this is a singly-linked list, this shall become a binary
- * tree when we add the real call interface. So far, entries are added
- * at the root, only.
- */
-typedef struct s_rsf_entry {
-	cstr_t *pName;			/* function name */
-	prsf_t rsf;	/* pointer to function code */
-	struct s_rsf_entry *pNext;	/* Pointer to next element or NULL */
-} rsf_entry_t;
-rsf_entry_t *funcRegRoot = NULL;
-
-
-/* add a function to the function registry.
- * The handed-over cstr_t* object must no longer be used by the caller.
- * A duplicate function name is an error.
- * rgerhards, 2009-04-06
- */
-static rsRetVal
-rsfrAddFunction(uchar *szName, prsf_t rsf)
-{
-	rsf_entry_t *pEntry;
-	size_t lenName;
-	DEFiRet;
-
-	assert(szName != NULL);
-	assert(rsf != NULL);
-
-	/* first check if we have a duplicate name, with the current approach this means
-	 * we need to go through the whole list.
-	 */
-	lenName = strlen((char*)szName);
-	for(pEntry = funcRegRoot ; pEntry != NULL ; pEntry = pEntry->pNext)
-		if(!rsCStrSzStrCmp(pEntry->pName, szName, lenName))
-			ABORT_FINALIZE(RS_RET_DUP_FUNC_NAME);
-
-	/* unique name, so add to head of list */
-	CHKmalloc(pEntry = calloc(1, sizeof(rsf_entry_t)));
-	CHKiRet(rsCStrConstructFromszStr(&pEntry->pName, szName));
-	CHKiRet(cstrFinalize(pEntry->pName));
-	pEntry->rsf = rsf;
-	pEntry->pNext = funcRegRoot;
-	funcRegRoot = pEntry;
-
-finalize_it:
-	if(iRet != RS_RET_OK && iRet != RS_RET_DUP_FUNC_NAME)
-		free(pEntry);
-
-	RETiRet;
-}
-
-
-/* find a function inside the function registry
- * The caller provides a cstr_t with the function name and receives
- * a function pointer back. If no function is found, an RS_RET_UNKNW_FUNC
- * error is returned. So if the function returns with RS_RET_OK, the caller
- * can savely assume the function pointer is valid.
- * rgerhards, 2009-04-06
- */
-static rsRetVal
-findRSFunction(cstr_t *pcsName, prsf_t *prsf)
-{
-	rsf_entry_t *pEntry;
-	rsf_entry_t *pFound;
-	DEFiRet;
-
-	assert(prsf != NULL);
-
-	/* find function by list walkthrough.  */
-	pFound = NULL;
-	for(pEntry = funcRegRoot ; pEntry != NULL && pFound == NULL ; pEntry = pEntry->pNext)
-		if(!rsCStrCStrCmp(pEntry->pName, pcsName))
-			pFound = pEntry;
-
-	if(pFound == NULL)
-		ABORT_FINALIZE(RS_RET_UNKNW_FUNC);
-
-	*prsf = pFound->rsf;
-
-finalize_it:
-	RETiRet;
-}
-
-
-/* find the name of a RainerScript function whom's function pointer
- * is known. This function returns the cstr_t object, which MUST NOT
- * be modified by the caller.
- * rgerhards, 2009-04-06
- */
-static rsRetVal
-findRSFunctionName(prsf_t rsf, cstr_t **ppcsName)
-{
-	rsf_entry_t *pEntry;
-	rsf_entry_t *pFound;
-	DEFiRet;
-
-	assert(rsf != NULL);
-	assert(ppcsName != NULL);
-
-	/* find function by list walkthrough.  */
-	pFound = NULL;
-	for(pEntry = funcRegRoot ; pEntry != NULL && pFound == NULL ; pEntry = pEntry->pNext)
-		if(pEntry->rsf == rsf)
-			pFound = pEntry;
-
-	if(pFound == NULL)
-		ABORT_FINALIZE(RS_RET_UNKNW_FUNC);
-
-	*ppcsName = pFound->pName;
-
-finalize_it:
-	RETiRet;
-}
-
-
-/* free the whole function registry
- */
-static void
-rsfrRemoveAll(void)
-{
-	rsf_entry_t *pEntry;
-	rsf_entry_t *pEntryDel;
-	
-	BEGINfunc
-	pEntry = funcRegRoot;
-	while(pEntry != NULL) {
-		pEntryDel = pEntry;
-		pEntry = pEntry->pNext;
-		cstrDestruct(&pEntryDel->pName);
-		free(pEntryDel);
-	}
-	funcRegRoot = NULL;
-	ENDfunc
-}
-
-
-/* ------------------------------ end function registry code and structures  ------------------------------ */
-
-
-/* ------------------------------ instruction set implementation ------------------------------ *
- * The following functions implement the VM's instruction set.
- */
-#define BEGINop(instruction) \
-	static rsRetVal op##instruction(vm_t *pThis, __attribute__((unused)) vmop_t *pOp) \
-	{ \
-		DEFiRet;
-
-#define CODESTARTop(instruction) \
-		ISOBJ_TYPE_assert(pThis, vm);
-
-#define PUSHRESULTop(operand, res) \
-	/* we have a result, so let's push it */ \
-	var.SetNumber(operand, res); \
-	vmstk.Push(pThis->pStk, operand); /* result */
-
-#define ENDop(instruction) \
-		RETiRet; \
-	}
-
-/* code generator for boolean operations */
-#define BOOLOP(name, OPERATION) \
-BEGINop(name) /* remember to set the instruction also in the ENDop macro! */ \
-	var_t *operand1; \
-	var_t *operand2; \
-CODESTARTop(name) \
-	vmstk.PopBool(pThis->pStk, &operand1); \
-	vmstk.PopBool(pThis->pStk, &operand2); \
-	if(operand1->val.num OPERATION operand2->val.num) { \
-		CHKiRet(var.SetNumber(operand1, 1)); \
-	} else { \
-		CHKiRet(var.SetNumber(operand1, 0)); \
-	} \
-	vmstk.Push(pThis->pStk, operand1); /* result */ \
-	var.Destruct(&operand2); /* no longer needed */ \
-finalize_it: \
-ENDop(name)
-BOOLOP(OR,  ||)
-BOOLOP(AND, &&)
-#undef BOOLOP
-
-
-/* code generator for numerical operations */
-#define NUMOP(name, OPERATION) \
-BEGINop(name) /* remember to set the instruction also in the ENDop macro! */ \
-	var_t *operand1; \
-	var_t *operand2; \
-CODESTARTop(name) \
-	vmstk.PopNumber(pThis->pStk, &operand1); \
-	vmstk.PopNumber(pThis->pStk, &operand2); \
-	operand1->val.num = operand1->val.num OPERATION operand2->val.num; \
-	vmstk.Push(pThis->pStk, operand1); /* result */ \
-	var.Destruct(&operand2); /* no longer needed */ \
-ENDop(name)
-NUMOP(PLUS,   +)
-NUMOP(MINUS,  -)
-NUMOP(TIMES,  *)
-NUMOP(DIV,    /)
-NUMOP(MOD,    %)
-#undef BOOLOP
-
-
-/* code generator for compare operations */
-#define BEGINCMPOP(name) \
-BEGINop(name) \
-	var_t *operand1; \
-	var_t *operand2; \
-	number_t bRes; \
-CODESTARTop(name) \
-	CHKiRet(vmstk.Pop2CommOp(pThis->pStk, &operand1, &operand2)); \
-	/* data types are equal (so we look only at operand1), but we must \
-	 * check which type we have to deal with... \
-	 */ \
-	switch(operand1->varType) {
-#define ENDCMPOP(name) \
-		default: \
-			bRes = 0; /* we do not abort just so that we have a value. TODO: reconsider */ \
-			break; \
-	} \
- \
-	/* we have a result, so let's push it */ \
-	var.SetNumber(operand1, bRes); \
-	vmstk.Push(pThis->pStk, operand1); /* result */ \
-	var.Destruct(&operand2); /* no longer needed */ \
-finalize_it: \
-ENDop(name)
-
-BEGINCMPOP(CMP_EQ) /* remember to change the name also in the END macro! */
-	case VARTYPE_NUMBER:
-		bRes = operand1->val.num == operand2->val.num;
-		break;
-	case VARTYPE_STR:
-		bRes = !rsCStrCStrCmp(operand1->val.pStr, operand2->val.pStr);
-		break;
-ENDCMPOP(CMP_EQ)
-
-BEGINCMPOP(CMP_NEQ) /* remember to change the name also in the END macro! */
-	case VARTYPE_NUMBER:
-		bRes = operand1->val.num != operand2->val.num;
-		break;
-	case VARTYPE_STR:
-		bRes = rsCStrCStrCmp(operand1->val.pStr, operand2->val.pStr);
-		break;
-ENDCMPOP(CMP_NEQ)
-
-BEGINCMPOP(CMP_LT) /* remember to change the name also in the END macro! */
-	case VARTYPE_NUMBER:
-		bRes = operand1->val.num < operand2->val.num;
-		break;
-	case VARTYPE_STR:
-		bRes = rsCStrCStrCmp(operand1->val.pStr, operand2->val.pStr) < 0;
-		break;
-ENDCMPOP(CMP_LT)
-
-BEGINCMPOP(CMP_GT) /* remember to change the name also in the END macro! */
-	case VARTYPE_NUMBER:
-		bRes = operand1->val.num > operand2->val.num;
-		break;
-	case VARTYPE_STR:
-		bRes = rsCStrCStrCmp(operand1->val.pStr, operand2->val.pStr) > 0;
-		break;
-ENDCMPOP(CMP_GT)
-
-BEGINCMPOP(CMP_LTEQ) /* remember to change the name also in the END macro! */
-	case VARTYPE_NUMBER:
-		bRes = operand1->val.num <= operand2->val.num;
-		break;
-	case VARTYPE_STR:
-		bRes = rsCStrCStrCmp(operand1->val.pStr, operand2->val.pStr) <= 0;
-		break;
-ENDCMPOP(CMP_LTEQ)
-
-BEGINCMPOP(CMP_GTEQ) /* remember to change the name also in the END macro! */
-	case VARTYPE_NUMBER:
-		bRes = operand1->val.num >= operand2->val.num;
-		break;
-	case VARTYPE_STR:
-		bRes = rsCStrCStrCmp(operand1->val.pStr, operand2->val.pStr) >= 0;
-		break;
-ENDCMPOP(CMP_GTEQ)
-
-#undef BEGINCMPOP
-#undef ENDCMPOP
-/* end regular compare operations */
-
-/* comare operations that work on strings, only */
-BEGINop(CMP_CONTAINS) /* remember to set the instruction also in the ENDop macro! */
-	var_t *operand1;
-	var_t *operand2;
-	number_t bRes;
-CODESTARTop(CMP_CONTAINS)
-	/* operand2 is on top of stack, so needs to be popped first */
-	vmstk.PopString(pThis->pStk, &operand2);
-	vmstk.PopString(pThis->pStk, &operand1);
-	/* TODO: extend cstr class so that it supports location of cstr inside cstr */
-	bRes = (rsCStrLocateInSzStr(operand2->val.pStr, rsCStrGetSzStr(operand1->val.pStr)) == -1) ? 0 : 1;
-
-	/* we have a result, so let's push it */
-	PUSHRESULTop(operand1, bRes);
-	var.Destruct(&operand2); /* no longer needed */
-ENDop(CMP_CONTAINS)
-
-
-BEGINop(CMP_CONTAINSI) /* remember to set the instruction also in the ENDop macro! */
-	var_t *operand1;
-	var_t *operand2;
-	number_t bRes;
-CODESTARTop(CMP_CONTAINSI)
-	/* operand2 is on top of stack, so needs to be popped first */
-	vmstk.PopString(pThis->pStk, &operand2);
-	vmstk.PopString(pThis->pStk, &operand1);
-var.DebugPrint(operand1); \
-var.DebugPrint(operand2); \
-	/* TODO: extend cstr class so that it supports location of cstr inside cstr */
-	bRes = (rsCStrCaseInsensitiveLocateInSzStr(operand2->val.pStr, rsCStrGetSzStr(operand1->val.pStr)) == -1) ? 0 : 1;
-
-	/* we have a result, so let's push it */
-	PUSHRESULTop(operand1, bRes);
-	var.Destruct(&operand2); /* no longer needed */
-ENDop(CMP_CONTAINSI)
-
-
-BEGINop(CMP_STARTSWITH) /* remember to set the instruction also in the ENDop macro! */
-	var_t *operand1;
-	var_t *operand2;
-	number_t bRes;
-CODESTARTop(CMP_STARTSWITH)
-	/* operand2 is on top of stack, so needs to be popped first */
-	vmstk.PopString(pThis->pStk, &operand2);
-	vmstk.PopString(pThis->pStk, &operand1);
-	/* TODO: extend cstr class so that it supports location of cstr inside cstr */
-	bRes = (rsCStrStartsWithSzStr(operand1->val.pStr, rsCStrGetSzStr(operand2->val.pStr),
-		rsCStrLen(operand2->val.pStr)) == 0) ? 1 : 0;
-
-	/* we have a result, so let's push it */
-	PUSHRESULTop(operand1, bRes);
-	var.Destruct(&operand2); /* no longer needed */
-ENDop(CMP_STARTSWITH)
-
-
-BEGINop(CMP_STARTSWITHI) /* remember to set the instruction also in the ENDop macro! */
-	var_t *operand1;
-	var_t *operand2;
-	number_t bRes;
-CODESTARTop(CMP_STARTSWITHI)
-	/* operand2 is on top of stack, so needs to be popped first */
-	vmstk.PopString(pThis->pStk, &operand2);
-	vmstk.PopString(pThis->pStk, &operand1);
-	/* TODO: extend cstr class so that it supports location of cstr inside cstr */
-	bRes = (rsCStrCaseInsensitveStartsWithSzStr(operand1->val.pStr, rsCStrGetSzStr(operand2->val.pStr),
-		rsCStrLen(operand2->val.pStr)) == 0) ? 1 : 0;
-
-	/* we have a result, so let's push it */
-	PUSHRESULTop(operand1, bRes);
-	var.Destruct(&operand2); /* no longer needed */
-ENDop(CMP_STARTSWITHI)
-
-/* end comare operations that work on strings, only */
-
-BEGINop(STRADD) /* remember to set the instruction also in the ENDop macro! */
-	var_t *operand1;
-	var_t *operand2;
-CODESTARTop(STRADD)
-	vmstk.PopString(pThis->pStk, &operand2);
-	vmstk.PopString(pThis->pStk, &operand1);
-
-	CHKiRet(rsCStrAppendCStr(operand1->val.pStr, operand2->val.pStr));
-	CHKiRet(cstrFinalize(operand1->val.pStr));
-
-	/* we have a result, so let's push it */
-	vmstk.Push(pThis->pStk, operand1);
-	var.Destruct(&operand2); /* no longer needed */
-finalize_it:
-ENDop(STRADD)
-
-BEGINop(NOT) /* remember to set the instruction also in the ENDop macro! */
-	var_t *operand;
-CODESTARTop(NOT)
-	vmstk.PopBool(pThis->pStk, &operand);
-	PUSHRESULTop(operand, !operand->val.num);
-ENDop(NOT)
-
-BEGINop(UNARY_MINUS) /* remember to set the instruction also in the ENDop macro! */
-	var_t *operand;
-CODESTARTop(UNARY_MINUS)
-	vmstk.PopNumber(pThis->pStk, &operand);
-	PUSHRESULTop(operand, -operand->val.num);
-ENDop(UNARY_MINUS)
-
-
-BEGINop(PUSHCONSTANT) /* remember to set the instruction also in the ENDop macro! */
-	var_t *pVarDup;   /* we need to duplicate the var, as we need to hand it over */
-CODESTARTop(PUSHCONSTANT)
-	CHKiRet(var.Duplicate(pOp->operand.pVar, &pVarDup));
-	vmstk.Push(pThis->pStk, pVarDup);
-finalize_it:
-ENDop(PUSHCONSTANT)
-
-
-BEGINop(PUSHMSGVAR) /* remember to set the instruction also in the ENDop macro! */
-	var_t *pVal; /* the value to push */
-	cstr_t *pstrVal;
-CODESTARTop(PUSHMSGVAR)
-dbgprintf("XXX: pushMSGVAR, var '%s'\n", rsCStrGetSzStr(pOp->operand.pVar->val.pStr));
-	if(pThis->pMsg == NULL) {
-		/* TODO: flag an error message! As a work-around, we permit
-		 * execution to continue here with an empty string
-		 */
-		/* TODO: create a method in var to create a string var? */
-		CHKiRet(var.Construct(&pVal));
-		CHKiRet(var.ConstructFinalize(pVal));
-		CHKiRet(rsCStrConstructFromszStr(&pstrVal, (uchar*)""));
-		CHKiRet(var.SetString(pVal, pstrVal));
-	} else {
-		/* we have a message, so pull value from there */
-		CHKiRet(msgGetMsgVar(pThis->pMsg, pOp->operand.pVar->val.pStr, &pVal));
-	}
-
-	/* if we reach this point, we have a valid pVal and can push it */
-	vmstk.Push(pThis->pStk, pVal);
-finalize_it:
-ENDop(PUSHMSGVAR)
-
-
-BEGINop(PUSHCEEVAR) /* remember to set the instruction also in the ENDop macro! */
-	var_t *pVal; /* the value to push */
-	cstr_t *pstrVal;
-CODESTARTop(PUSHCEEVAR)
-dbgprintf("XXX: pushCEEVAR, var '%s'\n", rsCStrGetSzStr(pOp->operand.pVar->val.pStr));
-	if(pThis->pMsg == NULL) {
-		/* TODO: flag an error message! As a work-around, we permit
-		 * execution to continue here with an empty string
-		 */
-		CHKiRet(var.Construct(&pVal));
-		CHKiRet(var.ConstructFinalize(pVal));
-		CHKiRet(rsCStrConstructFromszStr(&pstrVal, (uchar*)""));
-		CHKiRet(var.SetString(pVal, pstrVal));
-	} else {
-		/* we have a message, so pull value from there */
-		CHKiRet(msgGetCEEVar(pThis->pMsg, pOp->operand.pVar->val.pStr, &pVal));
-	}
-
-	/* if we reach this point, we have a valid pVal and can push it */
-	vmstk.Push(pThis->pStk, pVal);
-dbgprintf("XXX: pushCEEVAR, result '%s'\n", rsCStrGetSzStr(pVal->val.pStr));
-finalize_it:
-ENDop(PUSHCEEVAR)
-
-
-BEGINop(PUSHSYSVAR) /* remember to set the instruction also in the ENDop macro! */
-	var_t *pVal; /* the value to push */
-CODESTARTop(PUSHSYSVAR)
-	CHKiRet(sysvar.GetVar(pOp->operand.pVar->val.pStr, &pVal));
-	vmstk.Push(pThis->pStk, pVal);
-finalize_it:
-	if(Debug && iRet != RS_RET_OK) {
-		if(iRet == RS_RET_SYSVAR_NOT_FOUND) {
-			DBGPRINTF("rainerscript: sysvar '%s' not found\n",
-				  rsCStrGetSzStrNoNULL(pOp->operand.pVar->val.pStr));
-		} else {
-			DBGPRINTF("rainerscript: error %d trying to obtain sysvar '%s'\n",
-				  iRet, rsCStrGetSzStrNoNULL(pOp->operand.pVar->val.pStr));
-		}
-	}
-ENDop(PUSHSYSVAR)
-
-/* The function call operation is only very roughly implemented. While the plumbing
- * to reach this instruction is fine, the instruction itself currently supports only
- * functions with a single argument AND with a name that we know.
- * TODO: later, we can add here the real logic, that involves looking up function
- * names, loading them dynamically ... and all that...
- * implementation begun 2009-03-10 by rgerhards
- */
-BEGINop(FUNC_CALL) /* remember to set the instruction also in the ENDop macro! */
-	var_t *numOperands;
-CODESTARTop(FUNC_CALL)
-	vmstk.PopNumber(pThis->pStk, &numOperands);
-	CHKiRet((*pOp->operand.rsf)(pThis->pStk, numOperands->val.num));
-	var.Destruct(&numOperands); /* no longer needed */
-finalize_it:
-ENDop(FUNC_CALL)
-
-
-/* ------------------------------ end instruction set implementation ------------------------------ */
-
-
-/* ------------------------------ begin built-in function implementation ------------------------------ */
-/* note: this shall probably be moved to a separate module, but for the time being we do it directly
- * in here. This is on our way to get from a dirty to a clean solution via baby steps that are
- * a bit less dirty each time... 
- *
- * The advantage of doing it here is that we do not yet need to think about how to handle the
- * exit case, where we must not unload function modules which functions are still referenced.
- *
- * CALLING INTERFACE:
- * The function must pop its parameters off the stack and pop its result onto
- * the stack when it is finished. The number of parameters the function was
- * called with is provided to it. If the argument count is less then what the function
- * expected, it may handle the situation with defaults (or return an error). If the
- * argument count is greater than expected, returnung an error is highly 
- * recommended (use RS_RET_INVLD_NBR_ARGUMENTS for these cases).
- *
- * All function names are prefixed with "rsf_" (RainerScript Function) to have
- * a separate "name space".
- *
- * rgerhards, 2009-04-06
- */
-
-
-/* The strlen function, also probably a prototype of how all functions should be
- * implemented.
- * rgerhards, 2009-04-06
- */
-static rsRetVal
-rsf_strlen(vmstk_t *pStk, int numOperands)
-{
-	DEFiRet;
-	var_t *operand1;
-	int iStrlen;
-
-	if(numOperands != 1)
-		ABORT_FINALIZE(RS_RET_INVLD_NBR_ARGUMENTS);
-
-	/* pop args and do operaton (trivial case here...) */
-	vmstk.PopString(pStk, &operand1);
-	iStrlen = strlen((char*) rsCStrGetSzStr(operand1->val.pStr));
-
-	/* Store result and cleanup */
-	var.SetNumber(operand1, iStrlen);
-	vmstk.Push(pStk, operand1);
-finalize_it:
-	RETiRet;
-}
-
-
-/* The getenv function. Note that we guard the OS call by a mutex, as that
- * function is not guaranteed to be thread-safe. This implementation here is far from
- * being optimal, at least we should cache the result. This is left TODO for
- * a later revision.
- * rgerhards, 2009-11-03
- */
-static rsRetVal
-rsf_getenv(vmstk_t *pStk, int numOperands)
-{
-	DEFiRet;
-	var_t *operand1;
-	char *envResult;
-	cstr_t *pCstr;
-
-	if(numOperands != 1)
-		ABORT_FINALIZE(RS_RET_INVLD_NBR_ARGUMENTS);
-
-	/* pop args and do operaton (trivial case here...) */
-	vmstk.PopString(pStk, &operand1);
-	d_pthread_mutex_lock(&mutGetenv);
-	envResult = getenv((char*) rsCStrGetSzStr(operand1->val.pStr));
-	DBGPRINTF("rsf_getenv(): envvar '%s', return '%s'\n", rsCStrGetSzStr(operand1->val.pStr),
-		   envResult == NULL ? "(NULL)" : envResult);
-	iRet = rsCStrConstructFromszStr(&pCstr, (envResult == NULL) ? UCHAR_CONSTANT("") : (uchar*)envResult);
-	d_pthread_mutex_unlock(&mutGetenv);
-	if(iRet != RS_RET_OK)
-		FINALIZE; /* need to do this after mutex is unlocked! */
-
-	/* Store result and cleanup */
-	var.SetString(operand1, pCstr);
-	vmstk.Push(pStk, operand1);
-finalize_it:
-	RETiRet;
-}
-
-
-/* The "tolower" function, which converts its sole argument to lower case.
- * Quite honestly, currently this is primarily a test driver for me...
- * rgerhards, 2009-04-06
- */
-static rsRetVal
-rsf_tolower(vmstk_t *pStk, int numOperands)
-{
-	DEFiRet;
-	var_t *operand1;
-	uchar *pSrc;
-	cstr_t *pcstr;
-	int iStrlen;
-
-	if(numOperands != 1)
-		ABORT_FINALIZE(RS_RET_INVLD_NBR_ARGUMENTS);
-
-	/* pop args and do operaton */
-	CHKiRet(cstrConstruct(&pcstr));
-	vmstk.PopString(pStk, &operand1);
-	pSrc = cstrGetSzStr(operand1->val.pStr);
-	iStrlen = strlen((char*)pSrc); // TODO: use count from string!
-	while(iStrlen--) {
-		CHKiRet(cstrAppendChar(pcstr, tolower(*pSrc++)));
-	}
-
-	/* Store result and cleanup */
-	CHKiRet(cstrFinalize(pcstr));
-	var.SetString(operand1, pcstr);
-	vmstk.Push(pStk, operand1);
-finalize_it:
-	RETiRet;
-}
-
-
-/* Standard-Constructor
- */
-BEGINobjConstruct(vm) /* be sure to specify the object type also in END macro! */
-ENDobjConstruct(vm)
-
-
-/* ConstructionFinalizer
- * rgerhards, 2008-01-09
- */
-static rsRetVal
-vmConstructFinalize(vm_t __attribute__((unused)) *pThis)
-{
-	DEFiRet;
-	ISOBJ_TYPE_assert(pThis, vm);
-	
-	CHKiRet(vmstk.Construct(&pThis->pStk));
-	CHKiRet(vmstk.ConstructFinalize(pThis->pStk));
-
-finalize_it:
-	RETiRet;
-}
-
-
-/* destructor for the vm object */
-BEGINobjDestruct(vm) /* be sure to specify the object type also in END and CODESTART macros! */
-CODESTARTobjDestruct(vm)
-	if(pThis->pStk != NULL)
-		vmstk.Destruct(&pThis->pStk);
-	if(pThis->pMsg != NULL)
-		msgDestruct(&pThis->pMsg);
-ENDobjDestruct(vm)
-
-
-/* debugprint for the vm object */
-BEGINobjDebugPrint(vm) /* be sure to specify the object type also in END and CODESTART macros! */
-CODESTARTobjDebugPrint(vm)
-	dbgoprint((obj_t*) pThis, "rsyslog virtual machine, currently no state info available\n");
-ENDobjDebugPrint(vm)
-
-
-/* execute a program
- */
-static rsRetVal
-execProg(vm_t *pThis, vmprg_t *pProg)
-{
-	DEFiRet;
-	vmop_t *pCurrOp; /* virtual instruction pointer */
-
-	ISOBJ_TYPE_assert(pThis, vm);
-	ISOBJ_TYPE_assert(pProg, vmprg);
-
-#define doOP(OP) case opcode_##OP: DBGPRINTF("rainerscript: opcode %s\n", #OP); \
-				   CHKiRet(op##OP(pThis, pCurrOp)); break
-	pCurrOp = pProg->vmopRoot; /* TODO: do this via a method! */
-	while(pCurrOp != NULL && pCurrOp->opcode != opcode_END_PROG) {
-		DBGPRINTF("rainerscript: executing step, opcode %d...\n", pCurrOp->opcode);
-		switch(pCurrOp->opcode) {
-			doOP(OR);
-			doOP(AND);
-			doOP(CMP_EQ);
-			doOP(CMP_NEQ);
-			doOP(CMP_LT);
-			doOP(CMP_GT);
-			doOP(CMP_LTEQ);
-			doOP(CMP_GTEQ);
-			doOP(CMP_CONTAINS);
-			doOP(CMP_CONTAINSI);
-			doOP(CMP_STARTSWITH);
-			doOP(CMP_STARTSWITHI);
-			doOP(NOT);
-			doOP(PUSHCONSTANT);
-			doOP(PUSHMSGVAR);
-			doOP(PUSHCEEVAR);
-			doOP(PUSHSYSVAR);
-			doOP(STRADD);
-			doOP(PLUS);
-			doOP(MINUS);
-			doOP(TIMES);
-			doOP(DIV);
-			doOP(MOD);
-			doOP(UNARY_MINUS);
-			doOP(FUNC_CALL);
-			default:
-				dbgoprint((obj_t*) pThis, "invalid instruction %d in vmprg\n", pCurrOp->opcode);
-				ABORT_FINALIZE(RS_RET_INVALID_VMOP);
-				break;
-		}
-		/* so far, we have plain sequential execution, so on to next... */
-		pCurrOp = pCurrOp->pNext;
-	}
-#undef doOP
-
-	/* if we reach this point, our program has intintionally terminated
-	 * (no error state).
-	 */
-
-finalize_it:
-	DBGPRINTF("rainerscript: script execution terminated with state %d\n", iRet);
-	RETiRet;
-}
-
-
-/* Set the current message object for the VM. It *is* valid to set a
- * NULL message object, what simply means there is none. Message
- * objects are properly reference counted.
- */
-static rsRetVal
-SetMsg(vm_t *pThis, msg_t *pMsg)
-{
-	DEFiRet;
-	if(pThis->pMsg != NULL) {
-		msgDestruct(&pThis->pMsg);
-	}
-
-	if(pMsg != NULL) {
-		pThis->pMsg = MsgAddRef(pMsg);
-	}
-
-	RETiRet;
-}
-
-
-/* Pop a var from the stack and return it to caller. The variable type is not
- * changed, it is taken from the stack as is. This functionality is
- * partly needed. We may (or may not ;)) be able to remove it once we have
- * full RainerScript support. -- rgerhards, 2008-02-25
- */
-static rsRetVal
-PopVarFromStack(vm_t *pThis, var_t **ppVar)
-{
-	DEFiRet;
-	CHKiRet(vmstk.Pop(pThis->pStk, ppVar));
-finalize_it:
-	RETiRet;
-}
-
-
-/* Pop a boolean from the stack and return it to caller. This functionality is
- * partly needed. We may (or may not ;)) be able to remove it once we have
- * full RainerScript support. -- rgerhards, 2008-02-25
- */
-static rsRetVal
-PopBoolFromStack(vm_t *pThis, var_t **ppVar)
-{
-	DEFiRet;
-	CHKiRet(vmstk.PopBool(pThis->pStk, ppVar));
-finalize_it:
-	RETiRet;
-}
-
-
-/* queryInterface function
- * rgerhards, 2008-02-21
- */
-BEGINobjQueryInterface(vm)
-CODESTARTobjQueryInterface(vm)
-	if(pIf->ifVersion != vmCURR_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->Construct = vmConstruct;
-	pIf->ConstructFinalize = vmConstructFinalize;
-	pIf->Destruct = vmDestruct;
-	pIf->DebugPrint = vmDebugPrint;
-	pIf->ExecProg = execProg;
-	pIf->PopBoolFromStack = PopBoolFromStack;
-	pIf->PopVarFromStack = PopVarFromStack;
-	pIf->SetMsg = SetMsg;
-	pIf->FindRSFunction = findRSFunction;
-	pIf->FindRSFunctionName = findRSFunctionName;
-finalize_it:
-ENDobjQueryInterface(vm)
-
-
-/* Exit the vm class.
- * rgerhards, 2009-04-06
- */
-BEGINObjClassExit(vm, OBJ_IS_CORE_MODULE) /* class, version */
-	rsfrRemoveAll();
-	objRelease(sysvar, CORE_COMPONENT);
-	objRelease(var, CORE_COMPONENT);
-	objRelease(vmstk, CORE_COMPONENT);
-
-	pthread_mutex_destroy(&mutGetenv);
-ENDObjClassExit(vm)
-
-
-/* Initialize the vm class. Must be called as the very first method
- * before anything else is called inside this class.
- * rgerhards, 2008-02-19
- */
-BEGINObjClassInit(vm, 1, OBJ_IS_CORE_MODULE) /* class, version */
-	/* request objects we use */
-	CHKiRet(objUse(vmstk, CORE_COMPONENT));
-	CHKiRet(objUse(var, CORE_COMPONENT));
-	CHKiRet(objUse(sysvar, CORE_COMPONENT));
-
-	/* set our own handlers */
-	OBJSetMethodHandler(objMethod_DEBUGPRINT, vmDebugPrint);
-	OBJSetMethodHandler(objMethod_CONSTRUCTION_FINALIZER, vmConstructFinalize);
-
-	/* register built-in functions // TODO: move to its own module */
-	CHKiRet(rsfrAddFunction((uchar*)"strlen",  rsf_strlen));
-	CHKiRet(rsfrAddFunction((uchar*)"tolower", rsf_tolower));
-	CHKiRet(rsfrAddFunction((uchar*)"getenv",  rsf_getenv));
-
-	pthread_mutex_init(&mutGetenv, NULL);
-
-ENDObjClassInit(vm)
-
-/* vi:set ai:
- */
diff --git a/runtime/vm.h b/runtime/vm.h
deleted file mode 100644
index cb3c69d0..00000000
--- a/runtime/vm.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/* The vm object.
- *
- * This implements the rsyslog virtual machine. The initial implementation is
- * done to support complex user-defined expressions, but it may evolve into a
- * much more useful thing over time.
- *
- * The virtual machine uses rsyslog variables as its memory storage system.
- * All computation is done on a stack (vmstk). The vm supports a given
- * instruction set and executes programs of type vmprg, which consist of
- * single operations defined in vmop (which hold the instruction and the
- * data).
- *
- * Copyright 2008 Rainer Gerhards and Adiscon GmbH.
- *
- * This file is part of the rsyslog runtime library.
- *
- * The rsyslog runtime library is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * The rsyslog runtime library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with the rsyslog runtime library.  If not, see <http://www.gnu.org/licenses/>.
- *
- * A copy of the GPL can be found in the file "COPYING" in this distribution.
- * A copy of the LGPL can be found in the file "COPYING.LESSER" in this distribution.
- */
-#ifndef INCLUDED_VM_H
-#define INCLUDED_VM_H
-
-#include "msg.h"
-#include "vmstk.h"
-#include "vmprg.h"
-
-/* the vm object */
-typedef struct vm_s {
-	BEGINobjInstance;	/* Data to implement generic object - MUST be the first data element! */
-	vmstk_t *pStk;		/* The stack */
-	msg_t *pMsg;		/* the current message (or NULL, if we have none) */
-} vm_t;
-
-
-/* interfaces */
-BEGINinterface(vm) /* name must also be changed in ENDinterface macro! */
-	INTERFACEObjDebugPrint(vm);
-	rsRetVal (*Construct)(vm_t **ppThis);
-	rsRetVal (*ConstructFinalize)(vm_t __attribute__((unused)) *pThis);
-	rsRetVal (*Destruct)(vm_t **ppThis);
-	rsRetVal (*ExecProg)(vm_t *pThis, vmprg_t *pProg);
-	rsRetVal (*PopBoolFromStack)(vm_t *pThis, var_t **ppVar); /* there are a few cases where we need this... */
-	rsRetVal (*PopVarFromStack)(vm_t *pThis, var_t **ppVar); /* there are a few cases where we need this... */
-	rsRetVal (*SetMsg)(vm_t *pThis, msg_t *pMsg); /* there are a few cases where we need this... */
-	/* v2 (4.1.7) */
-	rsRetVal (*FindRSFunction)(cstr_t *pcsName, prsf_t *prsf); /* 2009-06-04 */
-	rsRetVal (*FindRSFunctionName)(prsf_t rsf, cstr_t **ppcsName); /* 2009-06-04 */
-ENDinterface(vm)
-#define vmCURR_IF_VERSION 2 /* increment whenever you change the interface structure! */
-
-
-/* prototypes */
-PROTOTYPEObj(vm);
-
-#endif /* #ifndef INCLUDED_VM_H */
diff --git a/runtime/vmop.c b/runtime/vmop.c
deleted file mode 100644
index ea627220..00000000
--- a/runtime/vmop.c
+++ /dev/null
@@ -1,307 +0,0 @@
-/* vmop.c - abstracts an operation (instructed) supported by the
- * rsyslog virtual machine
- *
- * Module begun 2008-02-20 by Rainer Gerhards
- *
- * Copyright 2007, 2008 Rainer Gerhards and Adiscon GmbH.
- *
- * This file is part of the rsyslog runtime library.
- *
- * The rsyslog runtime library is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * The rsyslog runtime library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with the rsyslog runtime library.  If not, see <http://www.gnu.org/licenses/>.
- *
- * A copy of the GPL can be found in the file "COPYING" in this distribution.
- * A copy of the LGPL can be found in the file "COPYING.LESSER" in this distribution.
- */
-
-#include "config.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <assert.h>
-
-#include "rsyslog.h"
-#include "obj.h"
-#include "vmop.h"
-#include "vm.h"
-
-/* static data */
-DEFobjStaticHelpers
-DEFobjCurrIf(var)
-DEFobjCurrIf(vm)
-
-
-/* forward definitions */
-static rsRetVal vmopOpcode2Str(vmop_t *pThis, uchar **ppName);
-
-/* Standard-Constructor
- */
-BEGINobjConstruct(vmop) /* be sure to specify the object type also in END macro! */
-ENDobjConstruct(vmop)
-
-
-/* ConstructionFinalizer
- * rgerhards, 2008-01-09
- */
-rsRetVal vmopConstructFinalize(vmop_t __attribute__((unused)) *pThis)
-{
-	DEFiRet;
-	ISOBJ_TYPE_assert(pThis, vmop);
-	RETiRet;
-}
-
-
-/* destructor for the vmop object */
-BEGINobjDestruct(vmop) /* be sure to specify the object type also in END and CODESTART macros! */
-CODESTARTobjDestruct(vmop)
-	if(pThis->opcode != opcode_FUNC_CALL) {
-		if(pThis->operand.pVar != NULL)
-			var.Destruct(&pThis->operand.pVar);
-	}
-ENDobjDestruct(vmop)
-
-
-/* DebugPrint support for the vmop object */
-BEGINobjDebugPrint(vmop) /* be sure to specify the object type also in END and CODESTART macros! */
-	uchar *pOpcodeName;
-	cstr_t *pStrVar;
-CODESTARTobjDebugPrint(vmop)
-	vmopOpcode2Str(pThis, &pOpcodeName);
-	if(pThis->opcode == opcode_FUNC_CALL) {
-		CHKiRet(vm.FindRSFunctionName(pThis->operand.rsf, &pStrVar));
-		assert(pStrVar != NULL);
-	} else {
-		CHKiRet(rsCStrConstruct(&pStrVar));
-		if(pThis->operand.pVar != NULL) {
-			CHKiRet(var.Obj2Str(pThis->operand.pVar, pStrVar));
-		}
-	}
-	CHKiRet(cstrFinalize(pStrVar));
-	dbgoprint((obj_t*) pThis, "%.12s\t%s\n", pOpcodeName, rsCStrGetSzStrNoNULL(pStrVar));
-	if(pThis->opcode != opcode_FUNC_CALL)
-		rsCStrDestruct(&pStrVar);
-finalize_it:
-ENDobjDebugPrint(vmop)
-
-
-/* This function is similar to DebugPrint, but does not send its output to
- * the debug log but instead to a caller-provided string. The idea here is that
- * we can use this string to get a textual representation of an operation.
- * Among others, this is useful for creating testbenches, our first use case for
- * it. Here, it enables simple comparison of the resulting program to a
- * reference program by simple string compare.
- * Note that the caller must initialize the string object. We always add
- * data to it. So, it can be easily combined into a chain of methods
- * to generate the final string.
- * rgerhards, 2008-07-04
- */
-static rsRetVal
-Obj2Str(vmop_t *pThis, cstr_t *pstrPrg)
-{
-	uchar *pOpcodeName;
-	cstr_t *pcsFuncName;
-	uchar szBuf[2048];
-	size_t lenBuf;
-	DEFiRet;
-
-	ISOBJ_TYPE_assert(pThis, vmop);
-	assert(pstrPrg != NULL);
-	vmopOpcode2Str(pThis, &pOpcodeName);
-	lenBuf = snprintf((char*) szBuf, sizeof(szBuf), "%s\t", pOpcodeName);
-	CHKiRet(rsCStrAppendStrWithLen(pstrPrg, szBuf, lenBuf));
-	if(pThis->opcode == opcode_FUNC_CALL) {
-		CHKiRet(vm.FindRSFunctionName(pThis->operand.rsf, &pcsFuncName));
-		CHKiRet(rsCStrAppendCStr(pstrPrg, pcsFuncName));
-	} else {
-		if(pThis->operand.pVar != NULL)
-			CHKiRet(var.Obj2Str(pThis->operand.pVar, pstrPrg));
-	}
-	CHKiRet(cstrAppendChar(pstrPrg, '\n'));
-
-finalize_it:
-	RETiRet;
-}
-
-
-/* set function
- * rgerhards, 2009-04-06
- */
-static rsRetVal
-vmopSetFunc(vmop_t *pThis, cstr_t *pcsFuncName)
-{
-	prsf_t rsf;	/* pointer to function */
-	DEFiRet;
-	ISOBJ_TYPE_assert(pThis, vmop);
-	CHKiRet(vm.FindRSFunction(pcsFuncName, &rsf)); /* check if function exists and obtain pointer to it */
-	assert(rsf != NULL);	/* just double-check, would be very hard to find! */
-	pThis->operand.rsf = rsf;
-finalize_it:
-	RETiRet;
-}
-
-
-/* set operand (variant case)
- * rgerhards, 2008-02-20
- */
-static rsRetVal
-vmopSetVar(vmop_t *pThis, var_t *pVar)
-{
-	DEFiRet;
-	ISOBJ_TYPE_assert(pThis, vmop);
-	ISOBJ_TYPE_assert(pVar, var);
-	pThis->operand.pVar = pVar;
-	RETiRet;
-}
-
-
-/* set operation
- * rgerhards, 2008-02-20
- */
-static rsRetVal
-vmopSetOpcode(vmop_t *pThis, opcode_t opcode)
-{
-	DEFiRet;
-	ISOBJ_TYPE_assert(pThis, vmop);
-	pThis->opcode = opcode;
-	RETiRet;
-}
-
-
-/* a way to turn an opcode into a readable string
- */
-static rsRetVal
-vmopOpcode2Str(vmop_t *pThis, uchar **ppName)
-{
-	DEFiRet;
-	ISOBJ_TYPE_assert(pThis, vmop);
-
-	switch(pThis->opcode) {
-		case opcode_OR:
-			*ppName = (uchar*) "or";
-			break;
-		case opcode_AND:
-			*ppName = (uchar*) "and";
-			break;
-		case opcode_PLUS:
-			*ppName = (uchar*) "add";
-			break;
-		case opcode_MINUS:
-			*ppName = (uchar*) "sub";
-			break;
-		case opcode_TIMES:
-			*ppName = (uchar*) "mul";
-			break;
-		case opcode_DIV:
-			*ppName = (uchar*) "div";
-			break;
-		case opcode_MOD:
-			*ppName = (uchar*) "mod";
-			break;
-		case opcode_NOT:
-			*ppName = (uchar*) "not";
-			break;
-		case opcode_CMP_EQ:
-			*ppName = (uchar*) "cmp_==";
-			break;
-		case opcode_CMP_NEQ:
-			*ppName = (uchar*) "cmp_!=";
-			break;
-		case opcode_CMP_LT:
-			*ppName = (uchar*) "cmp_<";
-			break;
-		case opcode_CMP_GT:
-			*ppName = (uchar*) "cmp_>";
-			break;
-		case opcode_CMP_LTEQ:
-			*ppName = (uchar*) "cmp_<=";
-			break;
-		case opcode_CMP_CONTAINS:
-			*ppName = (uchar*) "contains";
-			break;
-		case opcode_CMP_STARTSWITH:
-			*ppName = (uchar*) "startswith";
-			break;
-		case opcode_CMP_GTEQ:
-			*ppName = (uchar*) "cmp_>=";
-			break;
-		case opcode_PUSHSYSVAR:
-			*ppName = (uchar*) "push_sysvar";
-			break;
-		case opcode_PUSHMSGVAR:
-			*ppName = (uchar*) "push_msgvar";
-			break;
-		case opcode_PUSHCONSTANT:
-			*ppName = (uchar*) "push_const";
-			break;
-		case opcode_POP:
-			*ppName = (uchar*) "pop";
-			break;
-		case opcode_UNARY_MINUS:
-			*ppName = (uchar*) "unary_minus";
-			break;
-		case opcode_STRADD:
-			*ppName = (uchar*) "strconcat";
-			break;
-		case opcode_FUNC_CALL:
-			*ppName = (uchar*) "func_call";
-			break;
-		default:
-			*ppName = (uchar*) "!invalid_opcode!";
-			break;
-	}
-
-	RETiRet;
-}
-
-
-/* queryInterface function
- * rgerhards, 2008-02-21
- */
-BEGINobjQueryInterface(vmop)
-CODESTARTobjQueryInterface(vmop)
-	if(pIf->ifVersion != vmopCURR_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->Construct = vmopConstruct;
-	pIf->ConstructFinalize = vmopConstructFinalize;
-	pIf->Destruct = vmopDestruct;
-	pIf->DebugPrint = vmopDebugPrint;
-	pIf->SetFunc = vmopSetFunc;
-	pIf->SetOpcode = vmopSetOpcode;
-	pIf->SetVar = vmopSetVar;
-	pIf->Opcode2Str = vmopOpcode2Str;
-	pIf->Obj2Str = Obj2Str;
-finalize_it:
-ENDobjQueryInterface(vmop)
-
-
-/* Initialize the vmop class. Must be called as the very first method
- * before anything else is called inside this class.
- * rgerhards, 2008-02-19
- */
-BEGINObjClassInit(vmop, 1, OBJ_IS_CORE_MODULE) /* class, version */
-	/* request objects we use */
-	CHKiRet(objUse(var, CORE_COMPONENT));
-	CHKiRet(objUse(vm, CORE_COMPONENT));
-
-	OBJSetMethodHandler(objMethod_DEBUGPRINT, vmopDebugPrint);
-	OBJSetMethodHandler(objMethod_CONSTRUCTION_FINALIZER, vmopConstructFinalize);
-ENDObjClassInit(vmop)
-
-/* vi:set ai:
- */
diff --git a/runtime/vmop.h b/runtime/vmop.h
deleted file mode 100644
index c085a940..00000000
--- a/runtime/vmop.h
+++ /dev/null
@@ -1,129 +0,0 @@
-/* The vmop object.
- *
- * Copyright 2008 Rainer Gerhards and Adiscon GmbH.
- *
- * This file is part of rsyslog.
- *
- * This file is part of the rsyslog runtime library.
- *
- * The rsyslog runtime library is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * The rsyslog runtime library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with the rsyslog runtime library.  If not, see <http://www.gnu.org/licenses/>.
- *
- * A copy of the GPL can be found in the file "COPYING" in this distribution.
- * A copy of the LGPL can be found in the file "COPYING.LESSER" in this distribution.
- */
-#ifndef INCLUDED_VMOP_H
-#define INCLUDED_VMOP_H
-
-#include "ctok_token.h"
-#include "vmstk.h"
-#include "stringbuf.h"
-
-/* machine instructions types */
-typedef enum {	 /* do NOT start at 0 to detect uninitialized types after calloc() */
-	opcode_INVALID = 0,
-	/* for simplicity of debugging and reading dumps, we use the same IDs
-	 * that the tokenizer uses where this applicable.
-	 */
-	opcode_OR    = ctok_OR,
-	opcode_AND   = ctok_AND,
-	opcode_STRADD= ctok_STRADD,
-	opcode_PLUS  = ctok_PLUS,
-	opcode_MINUS = ctok_MINUS,
-	opcode_TIMES = ctok_TIMES,	 /* "*" */
-	opcode_DIV   = ctok_DIV,
-	opcode_MOD   = ctok_MOD,
-	opcode_NOT   = ctok_NOT,
-	opcode_CMP_EQ          = ctok_CMP_EQ, /* all compare operations must be in a row */
-	opcode_CMP_NEQ         = ctok_CMP_NEQ,
-	opcode_CMP_LT          = ctok_CMP_LT,
-	opcode_CMP_GT          = ctok_CMP_GT,
-	opcode_CMP_LTEQ        = ctok_CMP_LTEQ,
-	opcode_CMP_CONTAINS    = ctok_CMP_CONTAINS,
-	opcode_CMP_STARTSWITH  = ctok_CMP_STARTSWITH,
-	opcode_CMP_CONTAINSI   = ctok_CMP_CONTAINSI,
-	opcode_CMP_STARTSWITHI = ctok_CMP_STARTSWITHI,
-	opcode_CMP_GTEQ        = ctok_CMP_GTEQ, /* end compare operations */
-	/* here we start our own codes */
-	opcode_POP             = 1000,	 /* requires var operand to receive result */
-	opcode_PUSHSYSVAR      = 1001,	 /* requires var operand */
-	opcode_PUSHMSGVAR      = 1002,	 /* requires var operand */
-	opcode_PUSHCONSTANT    = 1003,	 /* requires var operand */
-	opcode_PUSHCEEVAR      = 1004,	 /* requires var operand */
-	opcode_UNARY_MINUS     = 1010,
-	opcode_FUNC_CALL       = 1012,
-	opcode_END_PROG        = 2000
-} opcode_t;
-
-
-/* Additional doc, operation specific
-
-  FUNC_CALL
-  All parameter passing is via the stack. Parameters are placed onto the stack in reverse order,
-  that means the last parameter is on top of the stack, the first at the bottom location. 
-  At the actual top of the stack is the number of parameters. This permits functions to be
-  called with variable number of arguments. The function itself is responsible for poping
-  the right number of parameters of the stack and complaining if the number is incorrect.
-  On exit, a single return value must be pushed onto the stack. The FUNC_CALL operation 
-  is generic. Its pVar argument contains the function name string (TODO: very slow, make
-  faster in later releases).
-
-  Sample Function call:  sampleFunc(p1, p2, p3) ; returns number 4711 (sample)
-  Stacklayout on entry (order is top to bottom):
-  3
-  p3
-  p2
-  p1
-  ... other vars ...
-
-  Stack on exit
-  4711
-  ... other vars ...
-  
- */
-
-
-/* the vmop object */
-typedef struct vmop_s {
-	BEGINobjInstance;	/* Data to implement generic object - MUST be the first data element! */
-	opcode_t opcode;
-	union {
-		var_t *pVar;
-		prsf_t rsf; /* pointer to function for "call" instruction */
-	} operand;
-	struct vmop_s *pNext; /* next operation or NULL, if end of program (logically this belongs to vmprg) */
-} vmop_t;
-
-
-/* interfaces */
-BEGINinterface(vmop) /* name must also be changed in ENDinterface macro! */
-	INTERFACEObjDebugPrint(vmop);
-	rsRetVal (*Construct)(vmop_t **ppThis);
-	rsRetVal (*ConstructFinalize)(vmop_t __attribute__((unused)) *pThis);
-	rsRetVal (*Destruct)(vmop_t **ppThis);
-	rsRetVal (*SetOpcode)(vmop_t *pThis, opcode_t opcode);
-	rsRetVal (*SetVar)(vmop_t *pThis, var_t *pVar);
-	rsRetVal (*Opcode2Str)(vmop_t *pThis, uchar **ppName);
-	rsRetVal (*Obj2Str)(vmop_t *pThis, cstr_t *pstr);
-	/* v2 */
-	rsRetVal (*SetFunc)(vmop_t *pThis, cstr_t *pcsFuncName);
-ENDinterface(vmop)
-#define vmopCURR_IF_VERSION 2 /* increment whenever you change the interface structure! */
-/* interface changes, v1 -> v2
- * added SetFuct after existing function pointers -- rgerhards, 2009-04-06
- */
-
-/* the remaining prototypes */
-PROTOTYPEObj(vmop);
-
-#endif /* #ifndef INCLUDED_VMOP_H */
diff --git a/runtime/vmprg.c b/runtime/vmprg.c
deleted file mode 100644
index 07757b98..00000000
--- a/runtime/vmprg.c
+++ /dev/null
@@ -1,236 +0,0 @@
-/* vmprg.c - abstracts a program (bytecode) for the rsyslog virtual machine
- *
- * Module begun 2008-02-20 by Rainer Gerhards
- *
- * Copyright 2007, 2008 Rainer Gerhards and Adiscon GmbH.
- *
- * This file is part of the rsyslog runtime library.
- *
- * The rsyslog runtime library is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * The rsyslog runtime library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with the rsyslog runtime library.  If not, see <http://www.gnu.org/licenses/>.
- *
- * A copy of the GPL can be found in the file "COPYING" in this distribution.
- * A copy of the LGPL can be found in the file "COPYING.LESSER" in this distribution.
- */
-
-#include "config.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <assert.h>
-
-#include "rsyslog.h"
-#include "obj.h"
-#include "vmprg.h"
-#include "stringbuf.h"
-
-/* static data */
-DEFobjStaticHelpers
-DEFobjCurrIf(vmop)
-
-
-/* Standard-Constructor
- */
-BEGINobjConstruct(vmprg) /* be sure to specify the object type also in END macro! */
-ENDobjConstruct(vmprg)
-
-
-/* ConstructionFinalizer
- * rgerhards, 2008-01-09
- */
-static rsRetVal
-vmprgConstructFinalize(vmprg_t __attribute__((unused)) *pThis)
-{
-	DEFiRet;
-	ISOBJ_TYPE_assert(pThis, vmprg);
-	RETiRet;
-}
-
-
-/* destructor for the vmprg object */
-BEGINobjDestruct(vmprg) /* be sure to specify the object type also in END and CODESTART macros! */
-	vmop_t *pOp;
-	vmop_t *pTmp;
-CODESTARTobjDestruct(vmprg)
-	/* we need to destruct the program elements! */
-	for(pOp = pThis->vmopRoot ; pOp != NULL ; ) {
-		pTmp = pOp;
-		pOp = pOp->pNext;
-		vmop.Destruct(&pTmp);
-	}
-ENDobjDestruct(vmprg)
-
-
-/* destructor for the vmop object */
-BEGINobjDebugPrint(vmprg) /* be sure to specify the object type also in END and CODESTART macros! */
-	vmop_t *pOp;
-CODESTARTobjDebugPrint(vmprg)
-	dbgoprint((obj_t*) pThis, "VM Program:\n");
-	for(pOp = pThis->vmopRoot ; pOp != NULL ; pOp = pOp->pNext) {
-		vmop.DebugPrint(pOp);
-	}
-ENDobjDebugPrint(vmprg)
-
-
-/* This function is similar to DebugPrint, but does not send its output to
- * the debug log but instead to a caller-provided string. The idea here is that
- * we can use this string to get a textual representation of a bytecode program. 
- * Among others, this is useful for creating testbenches, our first use case for
- * it. Here, it enables simple comparison of the resulting program to a
- * reference program by simple string compare.
- * Note that the caller must initialize the string object. We always add
- * data to it. So, it can be easily combined into a chain of methods
- * to generate the final string.
- * rgerhards, 2008-07-04
- */
-static rsRetVal
-Obj2Str(vmprg_t *pThis, cstr_t *pstrPrg)
-{
-	uchar szAddr[12];
-	vmop_t *pOp;
-	int i;
-	int lenAddr;
-	DEFiRet;
-
-	ISOBJ_TYPE_assert(pThis, vmprg);
-	assert(pstrPrg != NULL);
-	i = 0;	/* "program counter" */
-	for(pOp = pThis->vmopRoot ; pOp != NULL ; pOp = pOp->pNext) {
-		lenAddr = snprintf((char*)szAddr, sizeof(szAddr), "%8.8d: ", i++);
-		CHKiRet(rsCStrAppendStrWithLen(pstrPrg, szAddr, lenAddr));
-		vmop.Obj2Str(pOp, pstrPrg);
-	}
-
-finalize_it:
-	RETiRet;
-}
-
-
-/* add an operation (instruction) to the end of the current program. This
- * function is expected to be called while creating the program, but never
- * again after this is done and it is being executed. Results are undefined if
- * it is called after execution.
- */
-static rsRetVal
-vmprgAddOperation(vmprg_t *pThis, vmop_t *pOp)
-{
-	DEFiRet;
-
-	ISOBJ_TYPE_assert(pThis, vmprg);
-	ISOBJ_TYPE_assert(pOp, vmop);
-
-	if(pThis->vmopRoot == NULL) {
-		pThis->vmopRoot = pOp;
-	} else {
-		pThis->vmopLast->pNext = pOp;
-	}
-	pThis->vmopLast = pOp;
-
-	RETiRet;
-}
-
-
-/* this is a shortcut for high-level callers. It creates a new vmop, sets its
- * parameters and adds it to the program - all in one big step. If there is no
- * var associated with this operation, the caller can simply supply NULL as
- * pVar.
- */
-static rsRetVal
-vmprgAddVarOperation(vmprg_t *pThis, opcode_t opcode, var_t *pVar)
-{
-	DEFiRet;
-	vmop_t *pOp;
-
-	ISOBJ_TYPE_assert(pThis, vmprg);
-
-	/* construct and fill vmop */
-	CHKiRet(vmop.Construct(&pOp));
-	CHKiRet(vmop.ConstructFinalize(pOp));
-	CHKiRet(vmop.SetOpcode(pOp, opcode));
-	if(pVar != NULL)
-		CHKiRet(vmop.SetVar(pOp, pVar));
-
-	/* and add it to the program */
-	CHKiRet(vmprgAddOperation(pThis, pOp));
-
-finalize_it:
-	RETiRet;
-}
-
-
-/* this is another shortcut for high-level callers. It is similar to vmprgAddVarOperation
- * but adds a call operation. Among others, this include a check if the function
- * is known.
- */
-static rsRetVal
-vmprgAddCallOperation(vmprg_t *pThis, cstr_t *pcsName)
-{
-	DEFiRet;
-	vmop_t *pOp;
-
-	ISOBJ_TYPE_assert(pThis, vmprg);
-
-	/* construct and fill vmop */
-	CHKiRet(vmop.Construct(&pOp));
-	CHKiRet(vmop.ConstructFinalize(pOp));
-	CHKiRet(vmop.SetFunc(pOp, pcsName));
-	CHKiRet(vmop.SetOpcode(pOp, opcode_FUNC_CALL));
-
-	/* and add it to the program */
-	CHKiRet(vmprgAddOperation(pThis, pOp));
-
-finalize_it:
-	RETiRet;
-}
-
-
-/* queryInterface function
- * rgerhards, 2008-02-21
- */
-BEGINobjQueryInterface(vmprg)
-CODESTARTobjQueryInterface(vmprg)
-	if(pIf->ifVersion != vmprgCURR_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->Construct = vmprgConstruct;
-	pIf->ConstructFinalize = vmprgConstructFinalize;
-	pIf->Destruct = vmprgDestruct;
-	pIf->DebugPrint = vmprgDebugPrint;
-	pIf->Obj2Str = Obj2Str;
-	pIf->AddOperation = vmprgAddOperation;
-	pIf->AddVarOperation = vmprgAddVarOperation;
-	pIf->AddCallOperation = vmprgAddCallOperation;
-finalize_it:
-ENDobjQueryInterface(vmprg)
-
-
-/* Initialize the vmprg class. Must be called as the very first method
- * before anything else is called inside this class.
- * rgerhards, 2008-02-19
- */
-BEGINObjClassInit(vmprg, 1, OBJ_IS_CORE_MODULE) /* class, version */
-	/* request objects we use */
-	CHKiRet(objUse(vmop, CORE_COMPONENT));
-
-	/* set our own handlers */
-	OBJSetMethodHandler(objMethod_DEBUGPRINT, vmprgDebugPrint);
-	OBJSetMethodHandler(objMethod_CONSTRUCTION_FINALIZER, vmprgConstructFinalize);
-ENDObjClassInit(vmprg)
-
-/* vi:set ai:
- */
diff --git a/runtime/vmprg.h b/runtime/vmprg.h
deleted file mode 100644
index 66f03913..00000000
--- a/runtime/vmprg.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/* The vmprg object.
- *
- * The program is made up of vmop_t's, one after another. When we support
- * branching (or user-defined functions) at some time, well do this via
- * special branch opcodes. They will then contain the actual memory
- * address of a logical program entry that we shall branch to. Other than
- * that, all execution is serial - that is one opcode is executed after
- * the other. This class implements a logical program store, modelled
- * after real main memory. A linked list of opcodes is used to implement it.
- * In the future, we may use linked lists of array's to enhance performance,
- * but for the time being we have taken the simplistic approach (which also
- * reduces risk of bugs during initial development). The necessary pointers
- * for this are already implemented in vmop. Though this is not the 100%
- * correct place, we have opted this time in favor of performance, which
- * made them go there.
- *
- * Copyright 2008 Rainer Gerhards and Adiscon GmbH.
- *
- * This file is part of the rsyslog runtime library.
- *
- * The rsyslog runtime library is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * The rsyslog runtime library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with the rsyslog runtime library.  If not, see <http://www.gnu.org/licenses/>.
- *
- * A copy of the GPL can be found in the file "COPYING" in this distribution.
- * A copy of the LGPL can be found in the file "COPYING.LESSER" in this distribution.
- */
-#ifndef INCLUDED_VMPRG_H
-#define INCLUDED_VMPRG_H
-
-#include "vmop.h"
-#include "stringbuf.h"
-
-/* the vmprg object */
-typedef struct vmprg_s {
-	BEGINobjInstance;	/* Data to implement generic object - MUST be the first data element! */
-	vmop_t *vmopRoot;	/* start of program */
-	vmop_t *vmopLast;	/* last vmop of program (for adding new ones) */
-} vmprg_t;
-
-
-/* interfaces */
-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);
-	rsRetVal (*Obj2Str)(vmprg_t *pThis, cstr_t *pstr);
-	/* v2 (4.1.7) */
-	rsRetVal (*AddCallOperation)(vmprg_t *pThis, cstr_t *pVar); /* added 2009-04-06 */
-ENDinterface(vmprg)
-#define vmprgCURR_IF_VERSION 2 /* increment whenever you change the interface structure! */
-
-
-/* prototypes */
-PROTOTYPEObj(vmprg);
-
-#endif /* #ifndef INCLUDED_VMPRG_H */
diff --git a/runtime/vmstk.c b/runtime/vmstk.c
deleted file mode 100644
index 1ee3d485..00000000
--- a/runtime/vmstk.c
+++ /dev/null
@@ -1,234 +0,0 @@
-/* vmstk.c - the arithmetic stack of a virtual machine.
- *
- * Module begun 2008-02-21 by Rainer Gerhards
- *
- * Copyright 2008 Rainer Gerhards and Adiscon GmbH.
- *
- * This file is part of the rsyslog runtime library.
- *
- * The rsyslog runtime library is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * The rsyslog runtime library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with the rsyslog runtime library.  If not, see <http://www.gnu.org/licenses/>.
- *
- * A copy of the GPL can be found in the file "COPYING" in this distribution.
- * A copy of the LGPL can be found in the file "COPYING.LESSER" in this distribution.
- */
-
-#include "config.h"
-#include <stdlib.h>
-#include <assert.h>
-
-#include "rsyslog.h"
-#include "obj.h"
-#include "vmstk.h"
-
-/* static data */
-DEFobjStaticHelpers
-DEFobjCurrIf(var)
-
-
-/* Standard-Constructor
- */
-BEGINobjConstruct(vmstk) /* be sure to specify the object type also in END macro! */
-ENDobjConstruct(vmstk)
-
-
-/* ConstructionFinalizer
- * rgerhards, 2008-01-09
- */
-static rsRetVal
-vmstkConstructFinalize(vmstk_t __attribute__((unused)) *pThis)
-{
-	DEFiRet;
-	ISOBJ_TYPE_assert(pThis, vmstk);
-	RETiRet;
-}
-
-
-/* destructor for the vmstk object */
-BEGINobjDestruct(vmstk) /* be sure to specify the object type also in END and CODESTART macros! */
-CODESTARTobjDestruct(vmstk)
-ENDobjDestruct(vmstk)
-
-
-/* debugprint for the vmstk object */
-BEGINobjDebugPrint(vmstk) /* be sure to specify the object type also in END and CODESTART macros! */
-CODESTARTobjDebugPrint(vmstk)
-	dbgoprint((obj_t*) pThis, "stack contents:\n");
-ENDobjDebugPrint(vmstk)
-
-
-/* push a value on the stack. The provided pVar is now owned
- * by the stack. If the user intends to continue use it, it
- * must be duplicated.
- */
-static rsRetVal
-push(vmstk_t *pThis, var_t *pVar)
-{
-	DEFiRet;
-
-	ISOBJ_TYPE_assert(pThis, vmstk);
-	ISOBJ_TYPE_assert(pVar, var);
-
-	if(pThis->iStkPtr >= VMSTK_SIZE)
-		ABORT_FINALIZE(RS_RET_OUT_OF_STACKSPACE);
-
-	pThis->vStk[pThis->iStkPtr++] = pVar;
-
-finalize_it:
-	RETiRet;
-}
-
-
-/* pop a value from the stack
- * IMPORTANT: the stack pointer always points to the NEXT FREE entry. So in
- * order to pop, we must access the element one below the stack pointer.
- * The user is responsible for destructing the ppVar returned.
- */
-static rsRetVal
-pop(vmstk_t *pThis, var_t **ppVar)
-{
-	DEFiRet;
-
-	ISOBJ_TYPE_assert(pThis, vmstk);
-	ASSERT(ppVar != NULL);
-
-	if(pThis->iStkPtr == 0)
-		ABORT_FINALIZE(RS_RET_STACK_EMPTY);
-
-	*ppVar = pThis->vStk[--pThis->iStkPtr];
-
-finalize_it:
-	RETiRet;
-}
-
-
-/* pop a boolean value from the stack
- * The user is responsible for destructing the ppVar returned.
- */
-static rsRetVal
-popBool(vmstk_t *pThis, var_t **ppVar)
-{
-	DEFiRet;
-
-	/* assertions are done in pop(), we do not duplicate here */
-	CHKiRet(pop(pThis, ppVar));
-	CHKiRet(var.ConvToBool(*ppVar));
-
-finalize_it:
-	RETiRet;
-}
-
-
-/* pop a number value from the stack
- * The user is responsible for destructing the ppVar returned.
- */
-static rsRetVal
-popNumber(vmstk_t *pThis, var_t **ppVar)
-{
-	DEFiRet;
-
-	/* assertions are done in pop(), we do not duplicate here */
-	CHKiRet(pop(pThis, ppVar));
-	CHKiRet(var.ConvToNumber(*ppVar));
-
-finalize_it:
-	RETiRet;
-}
-
-
-/* pop a number value from the stack
- * The user is responsible for destructing the ppVar returned.
- */
-static rsRetVal
-popString(vmstk_t *pThis, var_t **ppVar)
-{
-	DEFiRet;
-
-	/* assertions are done in pop(), we do not duplicate here */
-	CHKiRet(pop(pThis, ppVar));
-	CHKiRet(var.ConvToString(*ppVar));
-
-finalize_it:
-	RETiRet;
-}
-
-
-/* pop two variables for a common operation, e.g. a compare. When this
- * functions returns, both variables have the same type, but the type
- * is not set to anything specific.
- * The user is responsible for destructing the ppVar's returned.
- * A quick note on the name: it means pop 2 variable for a common
- * opertion - just in case you wonder (I don't really like the name,
- * but I didn't come up with a better one...).
- * rgerhards, 2008-02-25
- */
-static rsRetVal
-pop2CommOp(vmstk_t *pThis, var_t **ppVar1, var_t **ppVar2)
-{
-	DEFiRet;
-
-	/* assertions are done in pop(), we do not duplicate here */
-	/* operand two must be popped first, because it is at the top of stack */
-	CHKiRet(pop(pThis, ppVar2));
-	CHKiRet(pop(pThis, ppVar1));
-	CHKiRet(var.ConvForOperation(*ppVar1, *ppVar2));
-
-finalize_it:
-	RETiRet;
-}
-
-
-/* queryInterface function
- * rgerhards, 2008-02-21
- */
-BEGINobjQueryInterface(vmstk)
-CODESTARTobjQueryInterface(vmstk)
-	if(pIf->ifVersion != vmstkCURR_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->Construct = vmstkConstruct;
-	pIf->ConstructFinalize = vmstkConstructFinalize;
-	pIf->Destruct = vmstkDestruct;
-	pIf->DebugPrint = vmstkDebugPrint;
-	pIf->Push = push;
-	pIf->Pop = pop;
-	pIf->PopBool = popBool;
-	pIf->PopNumber = popNumber;
-	pIf->PopString = popString;
-	pIf->Pop2CommOp = pop2CommOp;
-
-finalize_it:
-ENDobjQueryInterface(vmstk)
-
-
-/* Initialize the vmstk class. Must be called as the very first method
- * before anything else is called inside this class.
- * rgerhards, 2008-02-19
- */
-BEGINObjClassInit(vmstk, 1, OBJ_IS_CORE_MODULE) /* class, version */
-	/* request objects we use */
-	CHKiRet(objUse(var, CORE_COMPONENT));
-
-	/* set our own handlers */
-	OBJSetMethodHandler(objMethod_DEBUGPRINT, vmstkDebugPrint);
-	OBJSetMethodHandler(objMethod_CONSTRUCTION_FINALIZER, vmstkConstructFinalize);
-ENDObjClassInit(vmstk)
-
-/* vi:set ai:
- */
diff --git a/runtime/vmstk.h b/runtime/vmstk.h
deleted file mode 100644
index 06657cf4..00000000
--- a/runtime/vmstk.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/* The vmstk object.
- *
- * Copyright 2008 Rainer Gerhards and Adiscon GmbH.
- *
- * This file is part of the rsyslog runtime library.
- *
- * The rsyslog runtime library is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * The rsyslog runtime library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with the rsyslog runtime library.  If not, see <http://www.gnu.org/licenses/>.
- *
- * A copy of the GPL can be found in the file "COPYING" in this distribution.
- * A copy of the LGPL can be found in the file "COPYING.LESSER" in this distribution.
- */
-#ifndef INCLUDED_VMSTK_H
-#define INCLUDED_VMSTK_H
-
-/* The max size of the stack - TODO: make configurable */
-#define VMSTK_SIZE 256
-
-/* the vmstk object */
-struct vmstk_s {
-	BEGINobjInstance;	/* Data to implement generic object - MUST be the first data element! */
-	var_t *vStk[VMSTK_SIZE];/* the actual stack */
-	int iStkPtr;		/* stack pointer, points to next free location, grows from 0 --> topend */
-};
-
-
-/* interfaces */
-BEGINinterface(vmstk) /* name must also be changed in ENDinterface macro! */
-	INTERFACEObjDebugPrint(vmstk);
-	rsRetVal (*Construct)(vmstk_t **ppThis);
-	rsRetVal (*ConstructFinalize)(vmstk_t __attribute__((unused)) *pThis);
-	rsRetVal (*Destruct)(vmstk_t **ppThis);
-	rsRetVal (*Push)(vmstk_t *pThis, var_t *pVar);
-	rsRetVal (*Pop)(vmstk_t *pThis, var_t **ppVar);
-	rsRetVal (*PopBool)(vmstk_t *pThis, var_t **ppVar);
-	rsRetVal (*PopNumber)(vmstk_t *pThis, var_t **ppVar);
-	rsRetVal (*PopString)(vmstk_t *pThis, var_t **ppVar);
-	rsRetVal (*Pop2CommOp)(vmstk_t *pThis, var_t **ppVar1, var_t **ppVar2);
-ENDinterface(vmstk)
-#define vmstkCURR_IF_VERSION 1 /* increment whenever you change the interface structure! */
-
-
-/* prototypes */
-PROTOTYPEObj(vmstk);
-
-#endif /* #ifndef INCLUDED_VMSTK_H */
diff --git a/tools/syslogd.c b/tools/syslogd.c
index f623b398..45abf1a7 100644
--- a/tools/syslogd.c
+++ b/tools/syslogd.c
@@ -121,7 +121,6 @@
 #include "ruleset.h"
 #include "rule.h"
 #include "net.h"
-#include "vm.h"
 #include "prop.h"
 #include "rsconf.h"
 #include "dnscache.h"
@@ -132,7 +131,6 @@ DEFobjCurrIf(obj)
 DEFobjCurrIf(glbl)
 DEFobjCurrIf(datetime) /* TODO: make go away! */
 DEFobjCurrIf(conf)
-DEFobjCurrIf(expr)
 DEFobjCurrIf(module)
 DEFobjCurrIf(errmsg)
 DEFobjCurrIf(rule)
@@ -1544,8 +1542,6 @@ InitGlobalClasses(void)
 	CHKiRet(objUse(module,   CORE_COMPONENT));
 	pErrObj = "datetime";
 	CHKiRet(objUse(datetime, CORE_COMPONENT));
-	pErrObj = "expr";
-	CHKiRet(objUse(expr,     CORE_COMPONENT));
 	pErrObj = "rule";
 	CHKiRet(objUse(rule,     CORE_COMPONENT));
 	pErrObj = "ruleset";
@@ -1601,7 +1597,6 @@ GlobalClassExit(void)
 	objRelease(conf,     CORE_COMPONENT);
 	objRelease(ruleset,  CORE_COMPONENT);
 	objRelease(rule,     CORE_COMPONENT);
-	objRelease(expr,     CORE_COMPONENT);
 	parserClassExit();					/* this is hack, currently core_modules do not get this automatically called */
 	rsconfClassExit();					/* this is hack, currently core_modules do not get this automatically called */
 	objRelease(datetime, CORE_COMPONENT);
diff --git a/tools/syslogd.h b/tools/syslogd.h
index c3b99f9d..7c5dde81 100644
--- a/tools/syslogd.h
+++ b/tools/syslogd.h
@@ -27,7 +27,6 @@
 #include "template.h"
 #include "action.h"
 #include "linkedlist.h"
-#include "expr.h"
 
 /* the following prototypes should go away once we have an input
  * module interface -- rgerhards, 2007-12-12