added --enable-debugless configure option for very high demanding environments

This actually at compile time disables a lot of debug code, resulting
in some speedup (but serious loss of debugging capabilities)

5 files changed, 39 insertions, 35 deletions

diff --git a/runtime/debug.h b/runtime/debug.h
index 26672c3e..5bd26bd8 100644
--- a/runtime/debug.h
+++ b/runtime/debug.h
@@ -106,8 +106,13 @@ void dbgPrintAllDebugInfo(void);
 void *dbgmalloc(size_t size);
 
 /* macros */
-#define DBGPRINTF(...) if(Debug) { dbgprintf(__VA_ARGS__); }
-#define DBGOPRINT(...) if(Debug) { dbgoprint(__VA_ARGS__); }
+#ifdef DEBUGLESS
+#	define DBGPRINTF(...) {}
+#	define DBGOPRINT(...) {}
+#else
+#	define DBGPRINTF(...) if(Debug) { dbgprintf(__VA_ARGS__); }
+#	define DBGOPRINT(...) if(Debug) { dbgoprint(__VA_ARGS__); }
+#endif
 #ifdef RTINST
 #	define BEGINfunc static dbgFuncDB_t *pdbgFuncDB; int dbgCALLStaCK_POP_POINT = dbgEntrFunc(&pdbgFuncDB, __FILE__, __func__, __LINE__);
 #	define ENDfunc dbgExitFunc(pdbgFuncDB, dbgCALLStaCK_POP_POINT, RS_RET_NO_IRET);
diff --git a/runtime/queue.c b/runtime/queue.c
index 2b017747..05399278 100644
--- a/runtime/queue.c
+++ b/runtime/queue.c
@@ -131,7 +131,7 @@ static void displayBatchState(batch_t *pBatch)
 {
 	int i;
 	for(i = 0 ; i < pBatch->nElem ; ++i) {
-		dbgprintf("XXXXX: displayBatchState %p[%d]: %d\n", pBatch, i, pBatch->pElem[i].state);
+		DBGPRINTF("displayBatchState %p[%d]: %d\n", pBatch, i, pBatch->pElem[i].state);
 	}
 }
 
@@ -1418,7 +1418,8 @@ DoDeleteBatchFromQStore(qqueue_t *pThis, int nElem)
 	/* iQueueSize is not decremented by qDel(), so we need to do it ourselves */
 	ATOMIC_SUB(&pThis->iQueueSize, nElem, &pThis->mutQueueSize);
 	ATOMIC_SUB(&pThis->nLogDeq, nElem, &pThis->mutLogDeq);
-dbgprintf("delete batch from store, new sizes: log %d, phys %d\n", getLogicalQueueSize(pThis), getPhysicalQueueSize(pThis));
+	DBGPRINTF("delete batch from store, new sizes: log %d, phys %d\n",
+		  getLogicalQueueSize(pThis), getPhysicalQueueSize(pThis));
 	++pThis->deqIDDel; /* one more batch dequeued */
 
 	RETiRet;
@@ -1454,7 +1455,7 @@ DeleteBatchFromQStore(qqueue_t *pThis, batch_t *pBatch)
 		DoDeleteBatchFromQStore(pThis, pBatch->nElem);
 	} else {
 		/* can not delete, insert into to-delete list */
-		dbgprintf("not at head of to-delete list, enqueue %d\n", (int) pBatch->deqID);
+		DBGPRINTF("not at head of to-delete list, enqueue %d\n", (int) pBatch->deqID);
 		CHKiRet(tdlAdd(pThis, pBatch->deqID, pBatch->nElem));
 	}
 
@@ -1484,7 +1485,6 @@ DeleteProcessedBatch(qqueue_t *pThis, batch_t *pBatch)
 		pUsr = pBatch->pElem[i].pUsrp;
 		if(   pBatch->pElem[i].state == BATCH_STATE_RDY
 		   || pBatch->pElem[i].state == BATCH_STATE_SUB) {
-dbgprintf("XXX: DeleteProcessedBatch re-enqueue %d of %d, state %d\n", i, pBatch->nElem, pBatch->pElem[i].state);
 			localRet = doEnqSingleObj(pThis, eFLOWCTL_NO_DELAY,
 				       (obj_t*)MsgAddRef((msg_t*) pUsr));
 			++nEnqueued;
@@ -1495,7 +1495,7 @@ dbgprintf("XXX: DeleteProcessedBatch re-enqueue %d of %d, state %d\n", i, pBatch
 		objDestruct(pUsr);
 	}
 
-	dbgprintf("we deleted %d objects and enqueued %d objects\n", i-nEnqueued, nEnqueued);
+	DBGPRINTF("we deleted %d objects and enqueued %d objects\n", i-nEnqueued, nEnqueued);
 
 	if(nEnqueued > 0)
 		qqueueChkPersist(pThis, nEnqueued);
@@ -2674,7 +2674,7 @@ qqueueApplyCnfParam(qqueue_t *pThis, struct cnfparamvals *pvals)
 		} else if(!strcmp(pblk.descr[i].name, "queuedequeuetimend.")) {
 			pThis->iDeqtWinToHr = pvals[i].val.d.n;
 		} else {
-			dbgprintf("queue: program error, non-handled "
+			DBGPRINTF("queue: program error, non-handled "
 			  "param '%s'\n", pblk.descr[i].name);
 		}
 	}
diff --git a/runtime/rule.c b/runtime/rule.c
index 18199230..41cc9e4e 100644
--- a/runtime/rule.c
+++ b/runtime/rule.c
@@ -132,14 +132,14 @@ shouldProcessThisMessage(rule_t *pRule, msg_t *pMsg, sbool *bProcessMsg)
 	} else if(pRule->eHostnameCmpMode == HN_COMP_MATCH) {
 		if(rsCStrSzStrCmp(pRule->pCSHostnameComp, (uchar*) getHOSTNAME(pMsg), getHOSTNAMELen(pMsg))) {
 			/* not equal, so we are already done... */
-			dbgprintf("hostname filter '+%s' does not match '%s'\n", 
+			DBGPRINTF("hostname filter '+%s' does not match '%s'\n", 
 				rsCStrGetSzStrNoNULL(pRule->pCSHostnameComp), getHOSTNAME(pMsg));
 			FINALIZE;
 		}
 	} else { /* must be -hostname */
 		if(!rsCStrSzStrCmp(pRule->pCSHostnameComp, (uchar*) getHOSTNAME(pMsg), getHOSTNAMELen(pMsg))) {
-			/* not equal, so we are already done... */
-			dbgprintf("hostname filter '-%s' does not match '%s'\n", 
+			/* not equal, SO WE ARe already done... */
+			DBGPRINTF("hostname filter '-%s' does not match '%s'\n", 
 				rsCStrGetSzStrNoNULL(pRule->pCSHostnameComp), getHOSTNAME(pMsg));
 			FINALIZE;
 		}
@@ -171,7 +171,7 @@ shouldProcessThisMessage(rule_t *pRule, msg_t *pMsg, sbool *bProcessMsg)
 
 	if(pRule->f_filter_type == FILTER_PRI) {
 		/* skip messages that are incorrect priority */
-		dbgprintf("testing filter, f_pmask %d\n", pRule->f_filterData.f_pmask[pMsg->iFacility]);
+		DBGPRINTF("testing filter, f_pmask %d\n", pRule->f_filterData.f_pmask[pMsg->iFacility]);
 		if ( (pRule->f_filterData.f_pmask[pMsg->iFacility] == TABLE_NOPRI) || \
 		    ((pRule->f_filterData.f_pmask[pMsg->iFacility] & (1<<pMsg->iSeverity)) == 0) )
 			bRet = 0;
@@ -179,7 +179,7 @@ shouldProcessThisMessage(rule_t *pRule, msg_t *pMsg, sbool *bProcessMsg)
 			bRet = 1;
 	} else if(pRule->f_filter_type == FILTER_EXPR) {
 		bRet = cnfexprEvalBool(pRule->f_filterData.expr, pMsg);
-		dbgprintf("result of rainerscript filter evaluation: %d\n", bRet);
+		DBGPRINTF("result of rainerscript filter evaluation: %d\n", bRet);
 	} else {
 		assert(pRule->f_filter_type == FILTER_PROP); /* assert() just in case... */
 		pszPropVal = MsgGetProp(pMsg, NULL, pRule->f_filterData.prop.propID,
@@ -230,21 +230,21 @@ shouldProcessThisMessage(rule_t *pRule, msg_t *pMsg, sbool *bProcessMsg)
 			char *cstr;
 			if(pRule->f_filterData.prop.propID == PROP_CEE) {
 				cstr = es_str2cstr(pRule->f_filterData.prop.propName, NULL);
-				dbgprintf("Filter: check for CEE property '%s' (value '%s') ",
+				DBGPRINTF("Filter: check for CEE property '%s' (value '%s') ",
 					cstr, pszPropVal);
 				free(cstr);
 			} else {
-				dbgprintf("Filter: check for property '%s' (value '%s') ",
+				DBGPRINTF("Filter: check for property '%s' (value '%s') ",
 					propIDToName(pRule->f_filterData.prop.propID), pszPropVal);
 			}
 			if(pRule->f_filterData.prop.isNegated)
-				dbgprintf("NOT ");
+				DBGPRINTF("NOT ");
 			if(pRule->f_filterData.prop.operation == FIOP_ISEMPTY) {
-				dbgprintf("%s : %s\n",
+				DBGPRINTF("%s : %s\n",
 				       getFIOPName(pRule->f_filterData.prop.operation),
 				       bRet ? "TRUE" : "FALSE");
 			} else {
-				dbgprintf("%s '%s': %s\n",
+				DBGPRINTF("%s '%s': %s\n",
 				       getFIOPName(pRule->f_filterData.prop.operation),
 				       rsCStrGetSzStrNoNULL(pRule->f_filterData.prop.pCSCompValue),
 				       bRet ? "TRUE" : "FALSE");
diff --git a/runtime/ruleset.c b/runtime/ruleset.c
index c384663a..ecded4a3 100644
--- a/runtime/ruleset.c
+++ b/runtime/ruleset.c
@@ -143,9 +143,9 @@ DEFFUNC_llExecFunc(processBatchDoRules)
 {
 	rsRetVal iRet;
 	ISOBJ_TYPE_assert(pData, rule);
-	dbgprintf("Processing next rule\n");
+	DBGPRINTF("Processing next rule\n");
 	iRet = rule.ProcessBatch((rule_t*) pData, (batch_t*) pParam);
-dbgprintf("ruleset: get iRet %d from rule.ProcessMsg()\n", iRet);
+	DBGPRINTF("ruleset: get iRet %d from rule.ProcessMsg()\n", iRet);
 	return iRet;
 }
 
@@ -266,7 +266,7 @@ addRule(ruleset_t *pThis, rule_t **ppRule)
 		rule.Destruct(ppRule);
 	} else {
 		CHKiRet(llAppend(&pThis->llRules, NULL, *ppRule));
-		dbgprintf("selector line successfully processed, %d actions\n", iActionCnt);
+		DBGPRINTF("selector line successfully processed, %d actions\n", iActionCnt);
 	}
 
 finalize_it:
@@ -337,7 +337,7 @@ SetDefaultRuleset(rsconf_t *conf, uchar *pszName)
 
 	CHKiRet(rulesetGetRuleset(conf, &pRuleset, pszName));
 	conf->rulesets.pDflt = pRuleset;
-	dbgprintf("default rule set changed to %p: '%s'\n", pRuleset, pszName);
+	DBGPRINTF("default rule set changed to %p: '%s'\n", pRuleset, pszName);
 
 finalize_it:
 	RETiRet;
@@ -355,7 +355,7 @@ SetCurrRuleset(rsconf_t *conf, uchar *pszName)
 
 	CHKiRet(rulesetGetRuleset(conf, &pRuleset, pszName));
 	conf->rulesets.pCurr = pRuleset;
-	dbgprintf("current rule set changed to %p: '%s'\n", pRuleset, pszName);
+	DBGPRINTF("current rule set changed to %p: '%s'\n", pRuleset, pszName);
 
 finalize_it:
 	RETiRet;
@@ -414,7 +414,7 @@ finalize_it:
 /* destructor for the ruleset object */
 BEGINobjDestruct(ruleset) /* be sure to specify the object type also in END and CODESTART macros! */
 CODESTARTobjDestruct(ruleset)
-	dbgprintf("destructing ruleset %p, name %p\n", pThis, pThis->pszName);
+	DBGPRINTF("destructing ruleset %p, name %p\n", pThis, pThis->pszName);
 	if(pThis->pQueue != NULL) {
 		qqueueDestruct(&pThis->pQueue);
 	}
@@ -515,7 +515,7 @@ doRulesetCreateQueue(rsconf_t *conf, int *pNewVal)
 	if(pNewVal == 0)
 		FINALIZE; /* if it is turned off, we do not need to change anything ;) */
 
-	dbgprintf("adding a ruleset-specific \"main\" queue");
+	DBGPRINTF("adding a ruleset-specific \"main\" queue");
 	rulesetMainQName = (conf->rulesets.pCurr->pszName == NULL)? UCHAR_CONSTANT("ruleset") :
 							    conf->rulesets.pCurr->pszName;
 	CHKiRet(createMainQueue(&conf->rulesets.pCurr->pQueue, rulesetMainQName));
@@ -560,8 +560,7 @@ doRulesetAddParser(rsconf_t *conf, uchar *pName)
 
 	CHKiRet(parser.AddParserToList(&conf->rulesets.pCurr->pParserLst, pParser));
 
-	dbgprintf("added parser '%s' to ruleset '%s'\n", pName, conf->rulesets.pCurr->pszName);
-RUNLOG_VAR("%p", conf->rulesets.pCurr->pParserLst);
+	DBGPRINTF("added parser '%s' to ruleset '%s'\n", pName, conf->rulesets.pCurr->pszName);
 
 finalize_it:
 	d_free(pName); /* no longer needed */
diff --git a/runtime/wti.c b/runtime/wti.c
index e44086af..382f3668 100644
--- a/runtime/wti.c
+++ b/runtime/wti.c
@@ -121,7 +121,7 @@ wtiWakeupThrd(wti_t *pThis)
 	if(wtiGetState(pThis)) {
 		/* we first try the cooperative "cancel" interface */
 		pthread_kill(pThis->thrdID, SIGTTIN);
-		dbgprintf("sent SIGTTIN to worker thread 0x%x\n", (unsigned) pThis->thrdID);
+		DBGPRINTF("sent SIGTTIN to worker thread 0x%x\n", (unsigned) pThis->thrdID);
 	}
 
 	RETiRet;
@@ -148,13 +148,13 @@ wtiCancelThrd(wti_t *pThis)
 	if(wtiGetState(pThis)) {
 		/* we first try the cooperative "cancel" interface */
 		pthread_kill(pThis->thrdID, SIGTTIN);
-		dbgprintf("sent SIGTTIN to worker thread 0x%x, giving it a chance to terminate\n", (unsigned) pThis->thrdID);
+		DBGPRINTF("sent SIGTTIN to worker thread 0x%x, giving it a chance to terminate\n", (unsigned) pThis->thrdID);
 		srSleep(0, 10000);
 	}
 
 	if(wtiGetState(pThis)) {
-		dbgprintf("cooperative worker termination failed, using cancellation...\n");
-		dbgoprint((obj_t*) pThis, "canceling worker thread\n");
+		DBGPRINTF("cooperative worker termination failed, using cancellation...\n");
+		DBGOPRINT((obj_t*) pThis, "canceling worker thread\n");
 		pthread_cancel(pThis->thrdID);
 		/* now wait until the thread terminates... */
 		while(wtiGetState(pThis)) {
@@ -195,7 +195,7 @@ wtiConstructFinalize(wti_t *pThis)
 
 	ISOBJ_TYPE_assert(pThis, wti);
 
-	dbgprintf("%s: finalizing construction of worker instance data\n", wtiGetDbgHdr(pThis));
+	DBGPRINTF("%s: finalizing construction of worker instance data\n", wtiGetDbgHdr(pThis));
 
 	/* initialize our thread instance descriptor (no concurrency here) */
 	pThis->bIsRunning = FALSE; 
@@ -257,7 +257,7 @@ doIdleProcessing(wti_t *pThis, wtp_t *pWtp, int *pbInactivityTOOccured)
 			*pbInactivityTOOccured = 1; /* indicate we had a timeout */
 		}
 	}
-	dbgoprint((obj_t*) pThis, "worker awoke from idle processing\n");
+	DBGOPRINT((obj_t*) pThis, "worker awoke from idle processing\n");
 	ENDfunc
 }
 
@@ -300,7 +300,7 @@ wtiWorker(wti_t *pThis)
 		if(terminateRet == RS_RET_TERMINATE_NOW) {
 			/* we now need to free the old batch */
 			localRet = pWtp->pfObjProcessed(pWtp->pUsr, pThis);
-			dbgoprint((obj_t*) pThis, "terminating worker because of TERMINATE_NOW mode, del iRet %d\n",
+			DBGOPRINT((obj_t*) pThis, "terminating worker because of TERMINATE_NOW mode, del iRet %d\n",
 				 localRet);
 			d_pthread_mutex_unlock(pWtp->pmutUsr);
 			break;
@@ -318,7 +318,7 @@ wtiWorker(wti_t *pThis)
 		} else if(localRet == RS_RET_IDLE) {
 			if(terminateRet == RS_RET_TERMINATE_WHEN_IDLE || bInactivityTOOccured) {
 				d_pthread_mutex_unlock(pWtp->pmutUsr);
-				dbgoprint((obj_t*) pThis, "terminating worker terminateRet=%d, bInactivityTOOccured=%d\n",
+				DBGOPRINT((obj_t*) pThis, "terminating worker terminateRet=%d, bInactivityTOOccured=%d\n",
 					  terminateRet, bInactivityTOOccured);
 				break;	/* end of loop */
 			}