X-Git-Url: https://code.citadel.org/?p=citadel.git;a=blobdiff_plain;f=webcit%2Fsubst.c;h=7aa54bff8ad451b36691366c016413487941051a;hp=90c76eca305b2fd9404d4c236cf573cce783b0d6;hb=b98d9f087b3a24a9549470ab066c2aea187ecfba;hpb=4a934a743d2ec967b7abc382c887cc3e23a5fc25

diff --git a/webcit/subst.c b/webcit/subst.c
index 90c76eca3..7aa54bff8 100644
--- a/webcit/subst.c
+++ b/webcit/subst.c
@@ -1,6 +1,3 @@
-/*
- * $Id$
- */
 #include "sysdep.h"
 
 
@@ -21,8 +18,6 @@
 
 extern char *static_dirs[PATH_MAX];  /* Disk representation */
 
-HashList *WirelessTemplateCache;
-HashList *WirelessLocalTemplateCache;
 HashList *TemplateCache;
 HashList *LocalTemplateCache;
 
@@ -48,6 +43,7 @@ const char EmptyStr[]="";
 #define SV_PREEVALUATED 6
 
 
+
 /*
  * Dynamic content for variable substitution in templates
  */
@@ -76,8 +72,13 @@ typedef struct _HashHandler {
 	WCHandlerFunc HandlerFunc;
 }HashHandler;
 
-void *load_template(WCTemplate *NewTemplate);
-int EvaluateConditional(StrBuf *Target, int Neg, int state, WCTemplputParams *TP);
+typedef enum _estate {
+	eNext,
+	eSkipTilEnd
+} TemplState;
+
+void *load_template(StrBuf *Target, WCTemplate *NewTemplate);
+int EvaluateConditional(StrBuf *Target, int Neg, int state, WCTemplputParams **TPP);
 
 
 
@@ -88,35 +89,124 @@ typedef struct _SortStruct {
 	CompareFunc Reverse;
 	CompareFunc GroupChange;
 
-	long ContextType;
+	CtxType ContextType;
 }SortStruct;
 
-const char *CtxNames[]  = {
-	"Context NONE",
-	"Context SITECFG",
-	"Context SESSION",
-	"Context INETCFG",
-	"Context VNOTE",
-	"Context WHO",
-	"Context PREF",
-	"Context NODECONF",
-	"Context USERLIST",
-	"Context MAILSUM",
-	"Context MIME_ATACH",
-	"Context FILELIST",
-	"Context STRBUF",
-	"Context STRBUFARR",
-	"Context LONGVECTOR",
-	"Context ROOMS",
-	"Context FLOORS",
-	"Context ITERATE",
-	"Context ICAL",
-	"Context DavNamespace",
-	"Context TAB",
-	"Context UNKNOWN"
-};
+HashList *CtxList = NULL;
 
+static CtxType CtxCounter = CTX_NONE;
 
+CtxType CTX_STRBUF = CTX_NONE;
+CtxType CTX_STRBUFARR = CTX_NONE;
+CtxType CTX_LONGVECTOR = CTX_NONE;
+
+CtxType CTX_ITERATE = CTX_NONE;
+CtxType CTX_TAB = CTX_NONE;
+
+void HFreeContextType(void *pCtx)
+{
+	CtxTypeStruct *FreeStruct = (CtxTypeStruct *) pCtx;
+	FreeStrBuf(&FreeStruct->Name);
+	free(FreeStruct);
+}
+void PutContextType(const char *name, long len, CtxType TheCtx)
+{
+	CtxTypeStruct *NewStruct;
+
+	NewStruct = (CtxTypeStruct*) malloc(sizeof(CtxTypeStruct));
+	NewStruct->Name = NewStrBufPlain(name, len);
+	NewStruct->Type = TheCtx;
+
+	Put(CtxList, IKEY(NewStruct->Type), NewStruct, HFreeContextType);
+}
+void RegisterContextType(const char *name, long len, CtxType *TheCtx)
+{
+	if (*TheCtx != CTX_NONE)
+		return;
+
+	*TheCtx = ++CtxCounter;
+	PutContextType(name, len, *TheCtx);
+}
+
+CtxTypeStruct *GetContextType(CtxType Type)
+{
+	void *pv = NULL;
+	GetHash(CtxList, IKEY(Type), &pv);
+	return pv;
+}
+
+const char *UnknownContext = "CTX_UNKNOWN";
+
+const char *ContextName(CtxType ContextType)
+{
+	CtxTypeStruct *pCtx;
+
+	pCtx = GetContextType(ContextType);
+
+	if (pCtx != NULL) 
+		return ChrPtr(pCtx->Name);
+	else
+		return UnknownContext;
+}
+
+void StackDynamicContext(WCTemplputParams *Super, 
+			 WCTemplputParams *Sub, 
+			 void *Context,
+			 CtxType ContextType,
+			 int nArgs,
+			 WCTemplateToken *Tokens, 
+			 WCConditionalFunc ExitCtx, 
+			 long ExitCTXID)
+{
+	memset(Sub, 0, sizeof(WCTemplputParams));
+
+	if (Super != NULL) {
+		Sub->Sub = Super->Sub;
+		Super->Sub = Sub;
+	}
+	if (Sub->Sub != NULL)
+		Sub->Sub->Super = Sub;
+	Sub->Super = Super;
+	
+	Sub->Context = Context;
+	Sub->Filter.ContextType = ContextType;
+	Sub->nArgs = nArgs;
+	Sub->Tokens = Tokens;
+	Sub->ExitCtx = ExitCtx;
+	Sub->ExitCTXID = ExitCTXID;
+}
+
+void UnStackContext(WCTemplputParams *Sub)
+{
+	if (Sub->Super != NULL)
+	{
+		Sub->Super->Sub = Sub->Sub;
+	}
+	if (Sub->Sub != NULL)
+	{
+		Sub->Sub->Super = Sub->Super;
+	}
+}
+void UnStackDynamicContext(StrBuf *Target, WCTemplputParams **TPP)
+{
+	WCTemplputParams *TP = *TPP;
+	WCTemplputParams *Super = TP->Super;
+	TP->ExitCtx(Target, TP);
+	*TPP = Super;
+}
+
+void *GetContextPayload(WCTemplputParams *TP, CtxType ContextType)
+{
+	WCTemplputParams *whichTP = TP;
+
+	if (ContextType == CTX_NONE)
+		return TP->Context;
+
+	while ((whichTP != NULL) && (whichTP->Filter.ContextType != ContextType))
+		whichTP = whichTP->Super;
+
+	return whichTP->Context;	
+}
 
 void DestroySortStruct(void *vSort)
 {
@@ -126,13 +216,6 @@ void DestroySortStruct(void *vSort)
 	free (Sort);
 }
 
-const char *ContextName(int ContextType)
-{
-	if (ContextType < CTX_UNKNOWN)
-		return CtxNames[ContextType];
-	else
-		return CtxNames[CTX_UNKNOWN];
-}
 
 void LogTemplateError (StrBuf *Target, const char *Type, int ErrorPos, WCTemplputParams *TP, const char *Format, ...)
 {
@@ -161,24 +244,20 @@ void LogTemplateError (StrBuf *Target, const char *Type, int ErrorPos, WCTemplpu
 	}
 	if (TP->Tokens != NULL) 
 	{
-		lprintf(1, "%s [%s]  (in '%s' line %ld); %s; [%s]\n", 
-			Type, 
-			Err, 
-			ChrPtr(TP->Tokens->FileName),
-			TP->Tokens->Line, 
-			ChrPtr(Error), 
-			ChrPtr(TP->Tokens->FlatToken));
+		syslog(LOG_WARNING, "%s [%s]  (in '%s' line %ld); %s; [%s]\n", 
+		       Type, 
+		       Err, 
+		       ChrPtr(TP->Tokens->FileName),
+		       TP->Tokens->Line, 
+		       ChrPtr(Error), 
+		       ChrPtr(TP->Tokens->FlatToken));
 	}
 	else 
 	{
-		lprintf(1, "%s: %s;\n", 
-			Type, 
-			ChrPtr(Error));
+		syslog(LOG_WARNING, "%s: %s;\n", 
+		       Type, 
+		       ChrPtr(Error));
 	}
-/*
-	if (Target == NULL) 
-		return;
-*/
 	WCC = WC;
 	if (WCC == NULL) {
 		FreeStrBuf(&Info);
@@ -239,13 +318,10 @@ void LogTemplateError (StrBuf *Target, const char *Type, int ErrorPos, WCTemplpu
 	FreeStrBuf(&Error);
 /*
 	if (dbg_backtrace_template_errors)
-		wc_backtrace(); 
+		wc_backtrace(LOG_DEBUG); 
 */
 }
 
-
-
-
 void LogError (StrBuf *Target, const char *Type, const char *Format, ...)
 {
 	wcsession *WCC;
@@ -260,7 +336,7 @@ void LogError (StrBuf *Target, const char *Type, const char *Format, ...)
 	StrBufVAppendPrintf(Error, Format, arg_ptr);
 	va_end(arg_ptr);
 
-	lprintf(1, ChrPtr(Error));
+	syslog(LOG_WARNING, "%s", ChrPtr(Error));
 
 	WCC = WC;
 	if (WCC->WFBuf == NULL) WCC->WFBuf = NewStrBuf();
@@ -274,7 +350,7 @@ void LogError (StrBuf *Target, const char *Type, const char *Format, ...)
 	FreeStrBuf(&Error);
 /*
 	if (dbg_backtrace_template_errors)
-		wc_backtrace(); 
+		wc_backtrace(LOG_DEBUG); 
 */
 }
 
@@ -285,7 +361,7 @@ void RegisterNS(const char *NSName,
 		int nMaxArgs, 
 		WCHandlerFunc HandlerFunc, 
 		WCPreevalFunc PreevalFunc,
-		int ContextRequired)
+		CtxType ContextRequired)
 {
 	HashHandler *NewHandler;
 	
@@ -294,55 +370,38 @@ void RegisterNS(const char *NSName,
 	NewHandler->Filter.nMinArgs = nMinArgs;
 	NewHandler->Filter.nMaxArgs = nMaxArgs;
 	NewHandler->Filter.ContextType = ContextRequired;
-	NewHandler->Filter.ControlContextType = CTX_NONE;
 
 	NewHandler->PreEvalFunc = PreevalFunc;
 	NewHandler->HandlerFunc = HandlerFunc;	
 	Put(GlobalNS, NSName, len, NewHandler, NULL);
 }
 
-void RegisterControlNS(const char *NSName, 
-		       long len, 
-		       int nMinArgs, 
-		       int nMaxArgs, 
-		       WCHandlerFunc HandlerFunc, 
-		       int ControlContextRequired)
+
+
+int CheckContext(StrBuf *Target, ContextFilter *Need, WCTemplputParams *TP, const char *ErrType)
 {
-	HashHandler *NewHandler;
+	WCTemplputParams *TPP = TP;
 	
-	NewHandler = (HashHandler*) malloc(sizeof(HashHandler));
-	memset(NewHandler, 0, sizeof(HashHandler));
-	NewHandler->Filter.nMinArgs = nMinArgs;
-	NewHandler->Filter.nMaxArgs = nMaxArgs;
-	NewHandler->Filter.ContextType = CTX_NONE;
-	NewHandler->Filter.ControlContextType = ControlContextRequired;
-	NewHandler->HandlerFunc = HandlerFunc;	
-	Put(GlobalNS, NSName, len, NewHandler, NULL);
-}
+	if ((Need != NULL) &&
+	    (Need->ContextType != CTX_NONE) && 
+	    (Need->ContextType != TPP->Filter.ContextType)) {
 
+		while ((TPP != NULL) && 
+		       (Need->ContextType != TPP->Filter.ContextType))
+		{
+			TPP = TPP->Super;
+		}
 
+		if (TPP != NULL)
+			return 1;
 
-int CheckContext(StrBuf *Target, ContextFilter *Need, WCTemplputParams *TP, const char *ErrType)
-{
-	if ((Need->ContextType != CTX_NONE) && 
-	    (Need->ContextType != TP->Filter.ContextType)) {
                 LogTemplateError(
-                        Target, ErrType, ERR_PARM1, TP,
+                        Target, ErrType, ERR_NAME, TP,
 			"  WARNING: requires Context: [%s], have [%s]!", 
 			ContextName(Need->ContextType), 
 			ContextName(TP->Filter.ContextType));
 		return 0;
 	}
-
-	if ((Need->ControlContextType != CTX_NONE) && 
-	    (Need->ControlContextType != TP->Filter.ControlContextType)) {
-                LogTemplateError(
-                        Target, ErrType, ERR_PARM1, TP,
-			"  WARNING: requires Control Context: [%s], have [%s]!", 
-			ContextName(Need->ControlContextType), 
-			ContextName(TP->Filter.ControlContextType));
-		return 0;
-	}
 /*			
 	if (TP->Tokens->nParameters < Need->nMinArgs) {
 		LogTemplateError(Target, ErrType, ERR_NAME, TP,
@@ -394,35 +453,6 @@ void FreeWCTemplate(void *vFreeMe)
 	free(FreeMe);
 }
 
-
-
-/**
- * \brief back end for print_value_of() ... does a server command
- * \param servcmd server command to execute on the citadel server
- */
-void pvo_do_cmd(StrBuf *Target, StrBuf *servcmd) {
-	char buf[SIZ];
-	int len;
-
-	serv_puts(ChrPtr(servcmd));
-	len = serv_getln(buf, sizeof buf);
-
-	switch(buf[0]) {
-		case '2':
-		case '3':
-		case '5':
-			StrBufAppendPrintf(Target, "%s\n", &buf[4]);
-			break;
-		case '1':
-			_fmout(Target, "CENTER");
-			break;
-		case '4':
-			StrBufAppendPrintf(Target, "%s\n", &buf[4]);
-			serv_puts("000");
-			break;
-	}
-}
-
 int HaveTemplateTokenString(StrBuf *Target, 
 			    WCTemplputParams *TP,
 			    int N,
@@ -438,6 +468,7 @@ int HaveTemplateTokenString(StrBuf *Target,
 	case TYPE_STR:
 	case TYPE_BSTR:
 	case TYPE_PREFSTR:
+	case TYPE_ROOMPREFSTR:
 	case TYPE_GETTEXT:
 	case TYPE_SUBTEMPLATE:
 		return 1;
@@ -455,7 +486,6 @@ void GetTemplateTokenString(StrBuf *Target,
 			    long *len)
 {
 	StrBuf *Buf;
-	WCTemplputParams SubTP;
 
 	if (N >= TP->Tokens->nParameters) {
 		LogTemplateError(Target, 
@@ -499,6 +529,19 @@ void GetTemplateTokenString(StrBuf *Target,
 		*Value = ChrPtr(Buf);
 		*len = StrLength(Buf);
 		break;
+	case TYPE_ROOMPREFSTR:
+		if (TP->Tokens->Params[N]->len == 0) {
+			LogTemplateError(Target, 
+					 "TokenParameter", N, TP, 
+					 "Requesting parameter %d; of type PREFSTR, empty lookup string not admitted.", N);
+			*len = 0;
+			*Value = EmptyStr;
+			break;
+		}
+		Buf = get_ROOM_PREFS(TKEY(N));
+		*Value = ChrPtr(Buf);
+		*len = StrLength(Buf);
+		break;
 	case TYPE_LONG:
 		LogTemplateError(Target, 
 				 "TokenParameter", N, TP, 
@@ -523,15 +566,13 @@ void GetTemplateTokenString(StrBuf *Target,
 			break;
 		}
 
-		memset(&SubTP, 0, sizeof(WCTemplputParams *));
-		SubTP.Context = TP->Context;
-		SubTP.Filter.ContextType = TP->Filter.ContextType;
 		Buf = NewStrBuf();
-		DoTemplate(TKEY(N), Buf, &SubTP);
+		DoTemplate(TKEY(N), Buf, TP);
+
 		*Value = ChrPtr(Buf);
 		*len = StrLength(Buf);
 		/* we can't free it here, so we put it into the subst so its discarded later on. */
-		///SVPUTBuf(TKEY(N), Buf, 0);
+		PutRequestLocalMem(Buf, HFreeStrBuf);
 		break;
 
 	default:
@@ -549,7 +590,7 @@ long GetTemplateTokenNumber(StrBuf *Target, WCTemplputParams *TP, int N, long df
 		LogTemplateError(Target, 
 				 "TokenParameter", N, TP, 
 				 "invalid token %d. this shouldn't have come till here.\n", N);
-		wc_backtrace(); 
+		wc_backtrace(LOG_DEBUG); 
 		return 0;
 	}
 
@@ -580,6 +621,19 @@ long GetTemplateTokenNumber(StrBuf *Target, WCTemplputParams *TP, int N, long df
 		if (get_PREF_LONG(TKEY(N), &Ret, dflt))
 			return Ret;
 		return 0;
+	case TYPE_ROOMPREFSTR:
+		LogTemplateError(Target, 
+				 "TokenParameter", N, TP, 
+				 "requesting a prefstring in param %d want a number", N);
+		if (TP->Tokens->Params[N]->len == 0) {
+			LogTemplateError(Target, 
+					 "TokenParameter", N, TP, 
+					 "Requesting parameter %d; of type PREFSTR, empty lookup string not admitted.", N);
+			return 0;
+		}
+		if (get_ROOM_PREFS_LONG(TKEY(N), &Ret, dflt))
+			return Ret;
+		return 0;
 	case TYPE_INTDEFINE:
 	case TYPE_LONG:
 		return TP->Tokens->Params[N]->lvalue;
@@ -612,28 +666,29 @@ long GetTemplateTokenNumber(StrBuf *Target, WCTemplputParams *TP, int N, long df
 }
 
 
-/**
- * \brief puts string into the template and computes which escape methon we should use
- * \param Source the string we should put into the template
- * \param FormatTypeIndex where should we look for escape types if?
+/*
+ * puts string into the template and computes which escape methon we should use
+ * Source = the string we should put into the template
+ * FormatTypeIndex = where should we look for escape types if?
  */
 void StrBufAppendTemplate(StrBuf *Target, 
 			  WCTemplputParams *TP,
 			  const StrBuf *Source, int FormatTypeIndex)
 {
-        wcsession *WCC;
+	const char *pFmt = NULL;
 	char EscapeAs = ' ';
 
 	if ((FormatTypeIndex < TP->Tokens->nParameters) &&
+	    (TP->Tokens->Params[FormatTypeIndex] != NULL) &&
 	    (TP->Tokens->Params[FormatTypeIndex]->Type == TYPE_STR) &&
-	    (TP->Tokens->Params[FormatTypeIndex]->len == 1)) {
-		EscapeAs = *TP->Tokens->Params[FormatTypeIndex]->Start;
+	    (TP->Tokens->Params[FormatTypeIndex]->len >= 1)) {
+		pFmt = TP->Tokens->Params[FormatTypeIndex]->Start;
+		EscapeAs = *pFmt;
 	}
 
 	switch(EscapeAs)
 	{
 	case 'H':
-		WCC = WC;
 		StrEscAppend(Target, Source, NULL, 0, 2);
 		break;
 	case 'X':
@@ -641,18 +696,73 @@ void StrBufAppendTemplate(StrBuf *Target,
 		break;
 	case 'J':
 		StrECMAEscAppend(Target, Source, NULL);
-	  break;
+		break;
 	case 'K':
 		StrHtmlEcmaEscAppend(Target, Source, NULL, 0, 0);
-	  break;
+		break;
 	case 'U':
 		StrBufUrlescAppend(Target, Source, NULL);
 		break;
+	case 'F':
+		if (pFmt != NULL) 	pFmt++;
+		else			pFmt = "JUSTIFY";
+		if (*pFmt == '\0')	pFmt = "JUSTIFY";
+		FmOut(Target, pFmt, Source);
+		break;
 	default:
 		StrBufAppendBuf(Target, Source, 0);
 	}
 }
 
+/*
+ * puts string into the template and computes which escape methon we should use
+ * Source = the string we should put into the template
+ * FormatTypeIndex = where should we look for escape types if?
+ */
+void StrBufAppendTemplateStr(StrBuf *Target, 
+			     WCTemplputParams *TP,
+			     const char *Source, int FormatTypeIndex)
+{
+	const char *pFmt = NULL;
+	char EscapeAs = ' ';
+
+	if ((FormatTypeIndex < TP->Tokens->nParameters) &&
+	    (TP->Tokens->Params[FormatTypeIndex]->Type == TYPE_STR) &&
+	    (TP->Tokens->Params[FormatTypeIndex]->len >= 1)) {
+		pFmt = TP->Tokens->Params[FormatTypeIndex]->Start;
+		EscapeAs = *pFmt;
+	}
+
+	switch(EscapeAs)
+	{
+	case 'H':
+		StrEscAppend(Target, NULL, Source, 0, 2);
+		break;
+	case 'X':
+		StrEscAppend(Target, NULL, Source, 0, 0);
+		break;
+	case 'J':
+		StrECMAEscAppend(Target, NULL, Source);
+	  break;
+	case 'K':
+		StrHtmlEcmaEscAppend(Target, NULL, Source, 0, 0);
+	  break;
+	case 'U':
+		StrBufUrlescAppend(Target, NULL, Source);
+		break;
+/*
+	case 'F':
+		if (pFmt != NULL) 	pFmt++;
+		else			pFmt = "JUSTIFY";
+		if (*pFmt == '\0')	pFmt = "JUSTIFY";
+		FmOut(Target, pFmt, Source);
+		break;
+*/
+	default:
+		StrBufAppendBufPlain(Target, Source, -1, 0);
+	}
+}
+
 
 void PutNewToken(WCTemplate *Template, WCTemplateToken *NewToken)
 {
@@ -716,6 +826,14 @@ int GetNextParameter(StrBuf *Buf,
 			ParamBrace = 1;
 		}
 	}
+	else if (*pch == '.') {
+		Parm->Type = TYPE_ROOMPREFSTR;
+		pch ++;
+		if (*pch == '(') {
+			pch ++;
+			ParamBrace = 1;
+		}
+	}
 	else if (*pch == ';') {
 		Parm->Type = TYPE_PREFINT;
 		pch ++;
@@ -769,7 +887,7 @@ int GetNextParameter(StrBuf *Buf,
 		}
 		pche = pch;
 		if (*pch != quote) {
-			lprintf(1, "Error (in '%s' line %ld); "
+			syslog(LOG_WARNING, "Error (in '%s' line %ld); "
 				"evaluating template param [%s] in Token [%s]\n",
 				ChrPtr(pTmpl->FileName),
 				Tokens->Line,
@@ -783,8 +901,10 @@ int GetNextParameter(StrBuf *Buf,
 		else {
 			StrBufPeek(Buf, pch, -1, '\0');		
 			if (LoadTemplates > 1) {			
-				lprintf(1, "DBG: got param [%s] %ld %ld\n", 
-					pchs, pche - pchs, strlen(pchs));
+				syslog(LOG_DEBUG,
+					"DBG: got param [%s] "SIZE_T_FMT" "SIZE_T_FMT"\n", 
+					pchs, pche - pchs, strlen(pchs)
+				);
 			}
 			Parm->Start = pchs;
 			Parm->len = pche - pchs;
@@ -813,7 +933,7 @@ int GetNextParameter(StrBuf *Buf,
 		else {
 			Parm->lvalue = 0;
 /* TODO whUT?
-			lprintf(1, "Error (in '%s' line %ld); "
+			syslog(LOG_DEBUG, "Error (in '%s' line %ld); "
 				"evaluating long template param [%s] in Token [%s]\n",
 				ChrPtr(pTmpl->FileName),
 				Tokens->Line,
@@ -884,6 +1004,8 @@ int GetNextParameter(StrBuf *Buf,
 					}
 				}
 			}
+			FreeStrBuf(&pToken);
+			FreeStrBuf(&Match);
 		}
 		else if (strchr(Parm->Start, '&') != NULL)
 		{
@@ -920,6 +1042,8 @@ int GetNextParameter(StrBuf *Buf,
 					}
 				}
 			}
+			FreeStrBuf(&Match);
+			FreeStrBuf(&pToken);
 		}
 		else {
 
@@ -1003,7 +1127,7 @@ WCTemplateToken *NewTemplateSubstitute(StrBuf *Buf,
 						     &NewToken->Params[NewToken->nParameters - 1]))
 				{
 					NewToken->HaveParameters = 1;
-					if (NewToken->nParameters > MAXPARAM) {
+					if (NewToken->nParameters >= MAXPARAM) {
 						LogTemplateError(
 							NULL, "Parseerror", ERR_NAME, &TP,
 							"only [%d] Params allowed in Tokens",
@@ -1037,6 +1161,25 @@ WCTemplateToken *NewTemplateSubstitute(StrBuf *Buf,
 	switch (NewToken->Flags) {
 	case 0:
 		/* If we're able to find out more about the token, do it now while its fresh. */
+		pch = NewToken->pName;
+		while (pch <  NewToken->pName + NewToken->NameEnd)
+		{
+			if (((*pch >= 'A') && (*pch <= 'Z')) || 
+			    ((*pch >= '0') && (*pch <= '9')) ||
+			    (*pch == ':') || 
+			    (*pch == '-') ||
+			    (*pch == '_')) 
+				pch ++;
+			else
+			{
+				LogTemplateError(
+					NULL, "Token Name", ERR_NAME, &TP,
+					"contains illegal char: '%c'", 
+					*pch);
+				pch++;
+			}
+
+		}
 		if (GetHash(GlobalNS, NewToken->pName, NewToken->NameEnd, &vVar)) {
 			HashHandler *Handler;
 			Handler = (HashHandler*) vVar;
@@ -1054,13 +1197,17 @@ WCTemplateToken *NewTemplateSubstitute(StrBuf *Buf,
 				if (Handler->PreEvalFunc != NULL)
 					Handler->PreEvalFunc(NewToken);
 			}
+		} else {
+			LogTemplateError(
+				NULL, "Token ", ERR_NAME, &TP,
+				" isn't known to us.");
 		}
 		break;
 	case SV_GETTEXT:
-		if (NewToken->nParameters !=1) {
+		if ((NewToken->nParameters < 1) || (NewToken->nParameters > 2)) {
 			LogTemplateError(                               
 				NULL, "Gettext", ERR_NAME, &TP,
-				"requires exactly 1 parameter, you gave %d params", 
+				"requires 1 or 2 parameter, you gave %d params", 
 				NewToken->nParameters);
 			NewToken->Flags = 0;
 			break;
@@ -1195,27 +1342,72 @@ void *duplicate_template(WCTemplate *OldTemplate)
 	return NewTemplate;
 }
 
+
+void SanityCheckTemplate(StrBuf *Target, WCTemplate *CheckMe)
+{
+	int i = 0;
+	int j;
+	int FoundConditionalEnd;
+
+	for (i = 0; i < CheckMe->nTokensUsed; i++)
+	{
+		switch(CheckMe->Tokens[i]->Flags)
+		{
+		case SV_CONDITIONAL:
+		case SV_NEG_CONDITIONAL:
+			FoundConditionalEnd = 0;
+			if ((CheckMe->Tokens[i]->Params[0]->len == 1) && 
+			    (CheckMe->Tokens[i]->Params[0]->Start[0] == 'X'))
+				break;
+			for (j = i + 1; j < CheckMe->nTokensUsed; j++)
+			{
+				if (((CheckMe->Tokens[j]->Flags == SV_CONDITIONAL) ||
+				     (CheckMe->Tokens[j]->Flags == SV_NEG_CONDITIONAL)) && 
+				    (CheckMe->Tokens[i]->Params[1]->lvalue == 
+				     CheckMe->Tokens[j]->Params[1]->lvalue))
+				{
+					FoundConditionalEnd = 1;
+					break;
+				}
+
+			}
+			if (!FoundConditionalEnd)
+			{
+				WCTemplputParams TP;
+				memset(&TP, 0, sizeof(WCTemplputParams));
+				TP.Tokens = CheckMe->Tokens[i];
+				LogTemplateError(
+					Target, "Token", ERR_PARM1, &TP,
+					"Conditional without Endconditional"
+					);
+			}
+			break;
+		default:
+			break;
+		}
+	}
+}
+
 /**
  * \brief Display a variable-substituted template
  * \param templatename template file to load
  */
-void *load_template(WCTemplate *NewTemplate)
+void *load_template(StrBuf *Target, WCTemplate *NewTemplate)
 {
 	int fd;
 	struct stat statbuf;
 	const char *pS, *pE, *pch, *Err;
 	long Line;
-	int pos;
 
 	fd = open(ChrPtr(NewTemplate->FileName), O_RDONLY);
 	if (fd <= 0) {
-		lprintf(1, "ERROR: could not open template '%s' - %s\n",
+		syslog(LOG_WARNING, "ERROR: could not open template '%s' - %s\n",
 			ChrPtr(NewTemplate->FileName), strerror(errno));
 		return NULL;
 	}
 
 	if (fstat(fd, &statbuf) == -1) {
-		lprintf(1, "ERROR: could not stat template '%s' - %s\n",
+		syslog(LOG_WARNING, "ERROR: could not stat template '%s' - %s\n",
 			ChrPtr(NewTemplate->FileName), strerror(errno));
 		return NULL;
 	}
@@ -1223,9 +1415,8 @@ void *load_template(WCTemplate *NewTemplate)
 	NewTemplate->Data = NewStrBufPlain(NULL, statbuf.st_size + 1);
 	if (StrBufReadBLOB(NewTemplate->Data, &fd, 1, statbuf.st_size, &Err) < 0) {
 		close(fd);
-		lprintf(1, "ERROR: reading template '%s' - %s<br />\n",
+		syslog(LOG_WARNING, "ERROR: reading template '%s' - %s<br>\n",
 			ChrPtr(NewTemplate->FileName), strerror(errno));
-		//FreeWCTemplate(NewTemplate);/////tODO
 		return NULL;
 	}
 	close(fd);
@@ -1237,11 +1428,10 @@ void *load_template(WCTemplate *NewTemplate)
 	pE = pS + StrLength(NewTemplate->Data);
 	while (pch < pE) {
 		const char *pts, *pte;
-		int InQuotes = 0;
-		int InDoubleQuotes = 0;
+		char InQuotes = '\0';
+		void *pv;
 
 		/** Find one <? > */
-		pos = (-1);
 		for (; pch < pE; pch ++) {
 			if ((*pch=='<')&&(*(pch + 1)=='?') &&
 			    !((pch == pS) && /* we must ommit a <?xml */
@@ -1257,23 +1447,38 @@ void *load_template(WCTemplate *NewTemplate)
 
 		/** Found one? parse it. */
 		for (; pch <= pE - 1; pch ++) {
-			if (*pch == '"')
-				InDoubleQuotes = ! InDoubleQuotes;
-			else if (*pch == '\'')
-				InQuotes = ! InQuotes;
-			else if ((!InQuotes  && !InDoubleQuotes) &&
-				 ((*pch!='\\')&&(*(pch + 1)=='>'))) {
-				pch ++;
+			if ((!InQuotes) &&
+			    ((*pch == '\'') || (*pch == '"')))
+			{
+				InQuotes = *pch;
+			}
+			else if (InQuotes && (InQuotes == *pch))
+			{
+				InQuotes = '\0';
+			}
+			else if ((InQuotes) &&
+				 (*pch == '\\') &&
+				 (*(pch + 1) == InQuotes))
+			{
+				pch++;
+			}
+			else if ((!InQuotes) && 
+				 (*pch == '>'))
+			{
 				break;
 			}
 		}
 		if (pch + 1 > pE)
 			continue;
 		pte = pch;
-		PutNewToken(NewTemplate, 
-			    NewTemplateSubstitute(NewTemplate->Data, pS, pts, pte, Line, NewTemplate));
-		pch ++;
+		pv = NewTemplateSubstitute(NewTemplate->Data, pS, pts, pte, Line, NewTemplate);
+		if (pv != NULL) {
+			PutNewToken(NewTemplate, pv);
+			pch ++;
+		}
 	}
+
+	SanityCheckTemplate(NULL, NewTemplate);
 	return NewTemplate;
 }
 
@@ -1286,7 +1491,7 @@ const char* PrintTemplate(void *vSubst)
 
 }
 
-int LoadTemplateDir(const StrBuf *DirName, HashList *wireless, HashList *big, const StrBuf *BaseKey)
+int LoadTemplateDir(const StrBuf *DirName, HashList *big, const StrBuf *BaseKey)
 {
 	int Toplevel;
 	StrBuf *FileName;
@@ -1299,7 +1504,6 @@ int LoadTemplateDir(const StrBuf *DirName, HashList *wireless, HashList *big, co
 	int d_type = 0;
 	int d_namelen;
 	int d_without_ext;
-	int IsMobile;
 	
 	d = (struct dirent *)malloc(offsetof(struct dirent, d_name) + PATH_MAX + 1);
 	if (d == NULL) {
@@ -1321,9 +1525,14 @@ int LoadTemplateDir(const StrBuf *DirName, HashList *wireless, HashList *big, co
 	       (filedir_entry != NULL))
 	{
 		char *MinorPtr;
-		char *PStart;
-#ifdef _DIRENT_HAVE_D_NAMELEN
-		d_namelen = filedir_entry->d_namelen;
+
+#ifdef _DIRENT_HAVE_D_NAMLEN
+		d_namelen = filedir_entry->d_namlen;
+#else
+		d_namelen = strlen(filedir_entry->d_name);
+#endif
+
+#ifdef _DIRENT_HAVE_D_TYPE
 		d_type = filedir_entry->d_type;
 #else
 
@@ -1336,7 +1545,6 @@ int LoadTemplateDir(const StrBuf *DirName, HashList *wireless, HashList *big, co
 #define IFTODT(mode)   (((mode) & 0170000) >> 12)
 #define DTTOIF(dirtype)        ((dirtype) << 12)
 #endif
-		d_namelen = strlen(filedir_entry->d_name);
 		d_type = DT_UNKNOWN;
 #endif
 		d_without_ext = d_namelen;
@@ -1358,7 +1566,7 @@ int LoadTemplateDir(const StrBuf *DirName, HashList *wireless, HashList *big, co
 			char path[PATH_MAX];
 			snprintf(path, PATH_MAX, "%s/%s", 
 				 ChrPtr(DirName), filedir_entry->d_name);
-			if (stat(path, &s) == 0) {
+			if (lstat(path, &s) == 0) {
 				d_type = IFTODT(s.st_mode);
 			}
 		}
@@ -1383,10 +1591,10 @@ int LoadTemplateDir(const StrBuf *DirName, HashList *wireless, HashList *big, co
 				StrBufAppendBufPlain(SubDirectory, HKEY("/"), 0);
 			StrBufAppendBufPlain(SubDirectory, filedir_entry->d_name, d_namelen, 0);
 
-			LoadTemplateDir(SubDirectory, wireless, big, SubKey);
+			LoadTemplateDir(SubDirectory, big, SubKey);
 
 			break;
-		case DT_LNK: /* TODO: check whether its a file or a directory */
+		case DT_LNK: 
 		case DT_REG:
 
 
@@ -1398,12 +1606,6 @@ int LoadTemplateDir(const StrBuf *DirName, HashList *wireless, HashList *big, co
 			    (strcmp(&filedir_entry->d_name[d_without_ext], ".orig") == 0) ||
 			    (strcmp(&filedir_entry->d_name[d_without_ext], ".swp") == 0))
 				continue; /* Ignore backup files... */
-			/* .m.xxx is for mobile useragents! */
-			IsMobile = 0;
-			if (d_without_ext > 2)
-				IsMobile = (filedir_entry->d_name[d_without_ext - 1] == 'm') &&
-					(filedir_entry->d_name[d_without_ext - 2] == '.');
-			PStart = filedir_entry->d_name;
 			StrBufPrintf(FileName, "%s/%s", ChrPtr(DirName),  filedir_entry->d_name);
 			MinorPtr = strchr(filedir_entry->d_name, '.');
 			if (MinorPtr != NULL)
@@ -1417,8 +1619,8 @@ int LoadTemplateDir(const StrBuf *DirName, HashList *wireless, HashList *big, co
 			StrBufAppendBufPlain(Key, filedir_entry->d_name, MinorPtr - filedir_entry->d_name, 0);
 
 			if (LoadTemplates >= 1)
-				lprintf(1, "%s %d %s\n", ChrPtr(FileName), IsMobile, ChrPtr(Key));
-			prepare_template(FileName, Key, (IsMobile)?wireless:big);
+				syslog(LOG_DEBUG, "%s %s\n", ChrPtr(FileName), ChrPtr(Key));
+			prepare_template(FileName, Key, big);
 		default:
 			break;
 		}
@@ -1437,7 +1639,7 @@ void InitTemplateCache(void)
 	int i;
 	StrBuf *Key;
 	StrBuf *Dir;
-	HashList *Templates[4];
+	HashList *Templates[2];
 
 	Dir = NewStrBuf();
 	Key = NewStrBuf();
@@ -1445,14 +1647,12 @@ void InitTemplateCache(void)
 	/* Primary Template set... */
 	StrBufPrintf(Dir, "%s/t", static_dirs[0]);
 	LoadTemplateDir(Dir,
-			WirelessTemplateCache,
 			TemplateCache, 
 			Key);
 
 	/* User local Template set */
 	StrBufPrintf(Dir, "%s/t", static_dirs[1]);
 	LoadTemplateDir(Dir,
-			WirelessLocalTemplateCache,
 			LocalTemplateCache, 
 			Key);
 	
@@ -1460,17 +1660,14 @@ void InitTemplateCache(void)
 	
 	StrBufPrintf(Dir, "%s/dbg", static_dirs[0]);
 	LoadTemplateDir(Dir,
-			WirelessTemplateCache,
 			TemplateCache, 
 			Key);
-	Templates[0] = WirelessTemplateCache;
-	Templates[1] = TemplateCache;
-	Templates[2] = WirelessLocalTemplateCache;
-	Templates[3] = LocalTemplateCache;
+	Templates[0] = TemplateCache;
+	Templates[1] = LocalTemplateCache;
 
 
 	if (LoadTemplates == 0) 
-		for (i=0; i < 4; i++) {
+		for (i=0; i < 2; i++) {
 			const char *Key;
 			long KLen;
 			HashPos *At;
@@ -1484,7 +1681,7 @@ void InitTemplateCache(void)
 					      &vTemplate) && 
 			       (vTemplate != NULL))
 			{
-				load_template((WCTemplate *)vTemplate);
+				load_template(NULL, (WCTemplate *)vTemplate);
 			}
 			DeleteHashPos(&At);
 		}
@@ -1508,15 +1705,16 @@ void InitTemplateCache(void)
  * \param state are we in conditional state?
  * \param ContextType what type of information does context giv us?
  */
-int EvaluateToken(StrBuf *Target, int state, WCTemplputParams *TP)
+int EvaluateToken(StrBuf *Target, int state, WCTemplputParams **TPP)
 {
 	const char *AppendMe;
 	long AppendMeLen;
 	HashHandler *Handler;
 	void *vVar;
+	WCTemplputParams *TP = *TPP;
 	
 /* much output, since pName is not terminated...
-	lprintf(1,"Doing token: %s\n",Token->pName);
+	syslog(LOG_DEBUG,"Doing token: %s\n",Token->pName);
 */
 
 	switch (TP->Tokens->Flags) {
@@ -1524,14 +1722,26 @@ int EvaluateToken(StrBuf *Target, int state, WCTemplputParams *TP)
 		TmplGettext(Target, TP);
 		break;
 	case SV_CONDITIONAL: /** Forward conditional evaluation */
-		return EvaluateConditional(Target, 1, state, TP);
+		Handler = (HashHandler*) TP->Tokens->PreEval;
+		if (!CheckContext(Target, &Handler->Filter, TP, "Conditional")) {
+			return 0;
+		}
+		return EvaluateConditional(Target, 1, state, TPP);
 		break;
 	case SV_NEG_CONDITIONAL: /** Reverse conditional evaluation */
-		return EvaluateConditional(Target, 0, state, TP);
+		Handler = (HashHandler*) TP->Tokens->PreEval;
+		if (!CheckContext(Target, &Handler->Filter, TP, "Conditional")) {
+			return 0;
+		}
+		return EvaluateConditional(Target, 0, state, TPP);
 		break;
 	case SV_CUST_STR_CONDITIONAL: /** Conditional put custom strings from params */
+		Handler = (HashHandler*) TP->Tokens->PreEval;
+		if (!CheckContext(Target, &Handler->Filter, TP, "Conditional")) {
+			return 0;
+		}
 		if (TP->Tokens->nParameters >= 6) {
-			if (EvaluateConditional(Target, 0, state, TP)) {
+			if (EvaluateConditional(Target, 0, state, TPP)) {
 				GetTemplateTokenString(Target, TP, 5, &AppendMe, &AppendMeLen);
 				StrBufAppendBufPlain(Target, 
 						     AppendMe, 
@@ -1545,6 +1755,10 @@ int EvaluateToken(StrBuf *Target, int state, WCTemplputParams *TP)
 						     AppendMeLen,
 						     0);
 			}
+			if (*TPP != TP)
+			{
+				UnStackDynamicContext(Target, TPP);
+			}
 		}
 		else  {
 			LogTemplateError(
@@ -1559,7 +1773,7 @@ int EvaluateToken(StrBuf *Target, int state, WCTemplputParams *TP)
 	case SV_PREEVALUATED:
 		Handler = (HashHandler*) TP->Tokens->PreEval;
 		if (!CheckContext(Target, &Handler->Filter, TP, "Token")) {
-			return -1;
+			return 0;
 		}
 		Handler->HandlerFunc(Target, TP);
 		break;		
@@ -1567,7 +1781,7 @@ int EvaluateToken(StrBuf *Target, int state, WCTemplputParams *TP)
 		if (GetHash(GlobalNS, TP->Tokens->pName, TP->Tokens->NameEnd, &vVar)) {
 			Handler = (HashHandler*) vVar;
 			if (!CheckContext(Target, &Handler->Filter, TP, "Token")) {
-				return -1;
+				return 0;
 			}
 			else {
 				Handler->HandlerFunc(Target, TP);
@@ -1588,22 +1802,27 @@ const StrBuf *ProcessTemplate(WCTemplate *Tmpl, StrBuf *Target, WCTemplputParams
 {
 	WCTemplate *pTmpl = Tmpl;
 	int done = 0;
-	int i, state;
+	int i;
+	TemplState state;
 	const char *pData, *pS;
 	long len;
 	WCTemplputParams TP;
+	WCTemplputParams *TPtr = &TP;
+
+	memset(TPtr, 0, sizeof(WCTemplputParams));
 
 	memcpy(&TP.Filter, &CallingTP->Filter, sizeof(ContextFilter));
 
 	TP.Context = CallingTP->Context;
-	TP.ControlContext = CallingTP->ControlContext;
+	TP.Sub = CallingTP->Sub;
+	TP.Super = CallingTP->Super;
 
 	if (LoadTemplates != 0) {			
 		if (LoadTemplates > 1)
-			lprintf(1, "DBG: ----- loading:  [%s] ------ \n", 
+			syslog(LOG_DEBUG, "DBG: ----- loading:  [%s] ------ \n", 
 				ChrPtr(Tmpl->FileName));
 		pTmpl = duplicate_template(Tmpl);
-		if(load_template(pTmpl) == NULL) {
+		if(load_template(Target, pTmpl) == NULL) {
 			StrBufAppendPrintf(
 				Target, 
 				"<pre>\nError loading Template [%s]\n See Logfile for details\n</pre>\n", 
@@ -1617,7 +1836,7 @@ const StrBuf *ProcessTemplate(WCTemplate *Tmpl, StrBuf *Target, WCTemplputParams
 	pS = pData = ChrPtr(pTmpl->Data);
 	len = StrLength(pTmpl->Data);
 	i = 0;
-	state = 0;
+	state = eNext;
 	while (!done) {
 		if (i >= pTmpl->nTokensUsed) {
 			StrBufAppendBufPlain(Target, 
@@ -1626,28 +1845,56 @@ const StrBuf *ProcessTemplate(WCTemplate *Tmpl, StrBuf *Target, WCTemplputParams
 			done = 1;
 		}
 		else {
+			int TokenRc = 0;
+
 			StrBufAppendBufPlain(
 				Target, pData, 
 				pTmpl->Tokens[i]->pTokenStart - pData, 0);
-			TP.Tokens = pTmpl->Tokens[i];
-			TP.nArgs = pTmpl->Tokens[i]->nParameters;
-			state = EvaluateToken(Target, state, &TP);
+			TPtr->Tokens = pTmpl->Tokens[i];
+			TPtr->nArgs = pTmpl->Tokens[i]->nParameters;
 
-			while ((state != 0) && (i+1 < pTmpl->nTokensUsed)) {
+		        TokenRc = EvaluateToken(Target, TokenRc, &TPtr);
+			if (TokenRc > 0)
+			{
+				state = eSkipTilEnd;
+			}
+			else if (TokenRc < 0)
+			{
+				if ((TPtr != &TP) &&
+				    (TPtr->ExitCTXID == -TokenRc))
+				{
+					UnStackDynamicContext(Target, &TPtr);
+				}
+				TokenRc = 0;
+			}
+
+			while ((state != eNext) && (i+1 < pTmpl->nTokensUsed)) {
 			/* condition told us to skip till its end condition */
 				i++;
-				TP.Tokens = pTmpl->Tokens[i];
-				TP.nArgs = pTmpl->Tokens[i]->nParameters;
+				TPtr->Tokens = pTmpl->Tokens[i];
+				TPtr->nArgs = pTmpl->Tokens[i]->nParameters;
 				if ((pTmpl->Tokens[i]->Flags == SV_CONDITIONAL) ||
-				    (pTmpl->Tokens[i]->Flags == SV_NEG_CONDITIONAL)) {
-					if (state == EvaluateConditional(
-						    Target, 
-						    pTmpl->Tokens[i]->Flags, 
-						    state, 
-						    &TP))
-						state = 0;
+				    (pTmpl->Tokens[i]->Flags == SV_NEG_CONDITIONAL))
+				{
+					int rc;
+				        rc = EvaluateConditional(
+						Target, 
+						pTmpl->Tokens[i]->Flags, 
+						TokenRc, 
+						&TPtr);
+					if (-rc == TokenRc)
+					{
+						TokenRc = 0;
+						state = eNext;
+						if ((TPtr != &TP) &&
+						    (TPtr->ExitCTXID == - rc))
+						{
+							UnStackDynamicContext(Target, &TPtr);
+						}
+					}
 				}
 			}
+
 			pData = pTmpl->Tokens[i++]->pTokenEnd + 1;
 			if (i > pTmpl->nTokensUsed)
 				done = 1;
@@ -1660,6 +1907,8 @@ const StrBuf *ProcessTemplate(WCTemplate *Tmpl, StrBuf *Target, WCTemplputParams
 
 }
 
+
+StrBuf *textPlainType;
 /**
  * \brief Display a variable-substituted template
  * \param templatename template file to load
@@ -1679,36 +1928,35 @@ const StrBuf *DoTemplate(const char *templatename, long len, StrBuf *Target, WCT
 		TP = &LocalTP;
 	}
 
-	if (WC->is_mobile > 0) {
-		Static = WirelessTemplateCache;
-		StaticLocal = WirelessLocalTemplateCache;
-	}
-	else {
-		Static = TemplateCache;
-		StaticLocal = LocalTemplateCache;
-	}
+	Static = TemplateCache;
+	StaticLocal = LocalTemplateCache;
 
 	if (len == 0)
 	{
-		lprintf (1, "Can't to load a template with empty name!\n");
+		syslog(LOG_WARNING, "Can't to load a template with empty name!\n");
 		StrBufAppendPrintf(Target, "<pre>\nCan't to load a template with empty name!\n</pre>");
-		return NULL;
+		return textPlainType;
 	}
 
 	if (!GetHash(StaticLocal, templatename, len, &vTmpl) &&
 	    !GetHash(Static, templatename, len, &vTmpl)) {
-		lprintf (1, "didn't find Template [%s] %ld %ld\n", templatename, len , (long)strlen(templatename));
+		StrBuf *escapedString = NewStrBufPlain(NULL, len);
+		
+		StrHtmlEcmaEscAppend(escapedString, NULL, templatename, 1, 1);
+		syslog(LOG_WARNING, "didn't find Template [%s] %ld %ld\n", ChrPtr(escapedString), len , (long)strlen(templatename));
 		StrBufAppendPrintf(Target, "<pre>\ndidn't find Template [%s] %ld %ld\n</pre>", 
-				   templatename, len, 
+				   ChrPtr(escapedString), len, 
 				   (long)strlen(templatename));
+		WC->isFailure = 1;
 #if 0
 		dbg_PrintHash(Static, PrintTemplate, NULL);
 		PrintHash(Static, VarPrintTransition, PrintTemplate);
 #endif
-		return NULL;
+		FreeStrBuf(&escapedString);
+		return textPlainType;
 	}
 	if (vTmpl == NULL) 
-		return NULL;
+		return textPlainType;
 	return ProcessTemplate(vTmpl, Target, TP);
 
 }
@@ -1737,12 +1985,13 @@ void tmplput_Comment(StrBuf *Target, WCTemplputParams *TP)
 typedef struct _HashIterator {
 	HashList *StaticList;
 	int AdditionalParams;
-	int ContextType;
-	int XPectContextType;
+	CtxType ContextType;
+	CtxType XPectContextType;
 	int Flags;
 	RetrieveHashlistFunc GetHash;
 	HashDestructorFunc Destructor;
 	SubTemplFunc DoSubTemplate;
+	FilterByParamFunc Filter;
 } HashIterator;
 
 void RegisterITERATOR(const char *Name, long len, 
@@ -1751,8 +2000,9 @@ void RegisterITERATOR(const char *Name, long len,
 		      RetrieveHashlistFunc GetHash, 
 		      SubTemplFunc DoSubTempl,
 		      HashDestructorFunc Destructor,
-		      int ContextType, 
-		      int XPectContextType, 
+		      FilterByParamFunc Filter,
+		      CtxType ContextType, 
+		      CtxType XPectContextType, 
 		      int Flags)
 {
 	HashIterator *It;
@@ -1764,6 +2014,7 @@ void RegisterITERATOR(const char *Name, long len,
 	It->GetHash = GetHash;
 	It->DoSubTemplate = DoSubTempl;
 	It->Destructor = Destructor;
+	It->Filter = Filter;
 	It->ContextType = ContextType;
 	It->XPectContextType = XPectContextType;
 	It->Flags = Flags;
@@ -1834,6 +2085,7 @@ void tmpl_iterate_subtmpl(StrBuf *Target, WCTemplputParams *TP)
 	void *vContext;
 	void *vLastContext = NULL;
 	StrBuf *SubBuf;
+	WCTemplputParams IterateTP;
 	WCTemplputParams SubTP;
 	IterateStruct Status;
 
@@ -1842,7 +2094,6 @@ void tmpl_iterate_subtmpl(StrBuf *Target, WCTemplputParams *TP)
 	long StopAt = -1;
 
 	memset(&Status, 0, sizeof(IterateStruct));
-	memcpy (&SubTP, &TP, sizeof(WCTemplputParams));
 	
 	It = (HashIterator*) TP->Tokens->Preeval2;
 	if (It == NULL) {
@@ -1884,10 +2135,12 @@ void tmpl_iterate_subtmpl(StrBuf *Target, WCTemplputParams *TP)
 			if (GetHash(SortHash, SKEY(BSort), &vSortBy) &&
 			    (vSortBy != NULL)) {
 				SortBy = (SortStruct*)vSortBy;
+				/* first check whether its intended for us... */
+				if ((SortBy->ContextType == It->ContextType)&&
 				/** Ok, its us, lets see in which direction we should sort... */
-				if (havebstr("SortOrder")) {
+				    (havebstr("SortOrder"))) {
 					int SortOrder;
-					SortOrder = LBSTR("SortOrder");
+					SortOrder = lbstr("SortOrder");
 					if (SortOrder != 0)
 						DetectGroupChange = 1;
 				}
@@ -1895,42 +2148,54 @@ void tmpl_iterate_subtmpl(StrBuf *Target, WCTemplputParams *TP)
 		}
 	}
 	nMembersUsed = GetCount(List);
-	SubBuf = NewStrBuf();
-	SubTP.Filter.ContextType = It->ContextType;
-	SubTP.Filter.ControlContextType = CTX_ITERATE;
-	SubTP.ControlContext = &Status;
+
+	StackContext (TP, &IterateTP, &Status, CTX_ITERATE, 0, TP->Tokens);
+	{
+		SubBuf = NewStrBuf();
 	
-	if (HAVE_PARAM(2)) {
-		StartAt = GetTemplateTokenNumber(Target, TP, 2, 0);
-	}
-	if (HAVE_PARAM(3)) {
-		StepWidth = GetTemplateTokenNumber(Target, TP, 3, 0);
-	}
-	if (HAVE_PARAM(4)) {
-		StopAt = GetTemplateTokenNumber(Target, TP, 4, -1);
-	}
-	it = GetNewHashPos(List, StepWidth);
-	if (StopAt < 0) {
-		StopAt = GetCount(List);
-	}
-	while (GetNextHashPos(List, it, &Status.KeyLen, &Status.Key, &vContext)) {
-		if ((Status.n >= StartAt) && (Status.n <= StopAt)) {
-			if (DetectGroupChange && Status.n > 0) {
-				Status.GroupChange = SortBy->GroupChange(vContext, vLastContext);
+		if (HAVE_PARAM(2)) {
+			StartAt = GetTemplateTokenNumber(Target, TP, 2, 0);
+		}
+		if (HAVE_PARAM(3)) {
+			StepWidth = GetTemplateTokenNumber(Target, TP, 3, 0);
+		}
+		if (HAVE_PARAM(4)) {
+			StopAt = GetTemplateTokenNumber(Target, TP, 4, -1);
+		}
+		it = GetNewHashPos(List, StepWidth);
+		if (StopAt < 0) {
+			StopAt = GetCount(List);
+		}
+		while (GetNextHashPos(List, it, &Status.KeyLen, &Status.Key, &vContext)) {
+			if ((Status.n >= StartAt) && (Status.n <= StopAt)) {
+
+				if ((It->Filter != NULL) &&
+				    !It->Filter(Status.Key, Status.KeyLen, vContext, Target, TP)) 
+				{
+					continue;
+				}
+
+				if (DetectGroupChange && Status.n > 0) {
+					Status.GroupChange = SortBy->GroupChange(vContext, vLastContext);
+				}
+				Status.LastN = (Status.n + 1) == nMembersUsed;
+				StackContext(&IterateTP, &SubTP, vContext, It->ContextType, 0, NULL);
+				{
+					if (It->DoSubTemplate != NULL)
+						It->DoSubTemplate(SubBuf, &SubTP);
+					DoTemplate(TKEY(1), SubBuf, &SubTP);
+
+					StrBufAppendBuf(Target, SubBuf, 0);
+					FlushStrBuf(SubBuf);
+				}
+				UnStackContext(&SubTP);
+				Status.oddeven = ! Status.oddeven;
+				vLastContext = vContext;
 			}
-			Status.LastN = (Status.n + 1) == nMembersUsed;
-			SubTP.Context = vContext;
-			if (It->DoSubTemplate != NULL)
-				It->DoSubTemplate(SubBuf, &SubTP);
-			DoTemplate(TKEY(1), SubBuf, &SubTP);
-			
-			StrBufAppendBuf(Target, SubBuf, 0);
-			FlushStrBuf(SubBuf);
-			Status.oddeven = ! Status.oddeven;
-			vLastContext = vContext;
+			Status.n++;
 		}
-		Status.n++;
 	}
+	UnStackContext(&IterateTP);
 	FreeStrBuf(&SubBuf);
 	DeleteHashPos(&it);
 	if (It->Destructor != NULL)
@@ -1940,7 +2205,7 @@ void tmpl_iterate_subtmpl(StrBuf *Target, WCTemplputParams *TP)
 
 int conditional_ITERATE_ISGROUPCHANGE(StrBuf *Target, WCTemplputParams *TP)
 {
-	IterateStruct *Ctx = CCTX;
+	IterateStruct *Ctx = CTX(CTX_ITERATE);
 	if (TP->Tokens->nParameters < 3)
 		return 	Ctx->GroupChange;
 
@@ -1949,7 +2214,7 @@ int conditional_ITERATE_ISGROUPCHANGE(StrBuf *Target, WCTemplputParams *TP)
 
 void tmplput_ITERATE_ODDEVEN(StrBuf *Target, WCTemplputParams *TP)
 {
-	IterateStruct *Ctx = CCTX;
+	IterateStruct *Ctx = CTX(CTX_ITERATE);
 	if (Ctx->oddeven)
 		StrBufAppendBufPlain(Target, HKEY("odd"), 0);
 	else
@@ -1959,7 +2224,7 @@ void tmplput_ITERATE_ODDEVEN(StrBuf *Target, WCTemplputParams *TP)
 
 void tmplput_ITERATE_KEY(StrBuf *Target, WCTemplputParams *TP)
 {
-	IterateStruct *Ctx = CCTX;
+	IterateStruct *Ctx = CTX(CTX_ITERATE);
 
 	StrBufAppendBufPlain(Target, Ctx->Key, Ctx->KeyLen, 0);
 }
@@ -1967,19 +2232,19 @@ void tmplput_ITERATE_KEY(StrBuf *Target, WCTemplputParams *TP)
 
 void tmplput_ITERATE_LASTN(StrBuf *Target, WCTemplputParams *TP)
 {
-	IterateStruct *Ctx = CCTX;
+	IterateStruct *Ctx = CTX(CTX_ITERATE);
 	StrBufAppendPrintf(Target, "%d", Ctx->n);
 }
 
 int conditional_ITERATE_FIRSTN(StrBuf *Target, WCTemplputParams *TP)
 {
-	IterateStruct *Ctx = CCTX;
+	IterateStruct *Ctx = CTX(CTX_ITERATE);
 	return Ctx->n == 0;
 }
 
 int conditional_ITERATE_LASTN(StrBuf *Target, WCTemplputParams *TP)
 {
-	IterateStruct *Ctx = CCTX;
+	IterateStruct *Ctx = CTX(CTX_ITERATE);
 	return Ctx->LastN;
 }
 
@@ -1988,53 +2253,52 @@ int conditional_ITERATE_LASTN(StrBuf *Target, WCTemplputParams *TP)
 /*-----------------------------------------------------------------------------
  *                      Conditionals
  */
-int EvaluateConditional(StrBuf *Target, int Neg, int state, WCTemplputParams *TP)
+int EvaluateConditional(StrBuf *Target, int Neg, int state, WCTemplputParams **TPP)
 {
 	ConditionalStruct *Cond;
+	int rc = 0;
+	int res;
+	WCTemplputParams *TP = *TPP;
 
 	if ((TP->Tokens->Params[0]->len == 1) &&
 	    (TP->Tokens->Params[0]->Start[0] == 'X'))
-		return (state != 0)?TP->Tokens->Params[1]->lvalue:0;
+	{
+		return - (TP->Tokens->Params[1]->lvalue);
+	}
 	    
 	Cond = (ConditionalStruct *) TP->Tokens->PreEval;
 	if (Cond == NULL) {
 		LogTemplateError(
 			Target, "Conditional", ERR_PARM1, TP,
 			"unknown!");
-		return 1;
+		return 0;
 	}
 
 	if (!CheckContext(Target, &Cond->Filter, TP, "Conditional")) {
 		return 0;
 	}
 
-	if (Cond->CondF(Target, TP) == Neg)
-		return TP->Tokens->Params[1]->lvalue;
-	return 0;
-}
+	res = Cond->CondF(Target, TP);
+	if (res == Neg)
+		rc = TP->Tokens->Params[1]->lvalue;
 
-void RegisterConditional(const char *Name, long len, 
-			 int nParams,
-			 WCConditionalFunc CondF, 
-			 int ContextRequired)
-{
-	ConditionalStruct *Cond;
+	if (LoadTemplates > 5) 
+		syslog(LOG_DEBUG, "<%s> : %d %d==%d\n", 
+			ChrPtr(TP->Tokens->FlatToken), 
+			rc, res, Neg);
 
-	Cond = (ConditionalStruct*)malloc(sizeof(ConditionalStruct));
-	memset(Cond, 0, sizeof(ConditionalStruct));
-	Cond->PlainName = Name;
-	Cond->Filter.nMaxArgs = nParams;
-	Cond->Filter.nMinArgs = nParams;
-	Cond->CondF = CondF;
-	Cond->Filter.ContextType = ContextRequired;
-	Cond->Filter.ControlContextType = CTX_NONE;
-	Put(Conditionals, Name, len, Cond, NULL);
+	if (TP->Sub != NULL)
+	{
+		*TPP = TP->Sub;
+	}
+	return rc;
 }
 
-void RegisterControlConditional(const char *Name, long len, 
+void RegisterContextConditional(const char *Name, long len, 
 				int nParams,
 				WCConditionalFunc CondF, 
-				int ControlContextRequired)
+				WCConditionalFunc ExitCtxCond,
+				int ContextRequired)
 {
 	ConditionalStruct *Cond;
 
@@ -2044,8 +2308,8 @@ void RegisterControlConditional(const char *Name, long len,
 	Cond->Filter.nMaxArgs = nParams;
 	Cond->Filter.nMinArgs = nParams;
 	Cond->CondF = CondF;
-	Cond->Filter.ContextType = CTX_NONE;
-	Cond->Filter.ControlContextType = ControlContextRequired;
+	Cond->CondExitCtx = ExitCtxCond;
+	Cond->Filter.ContextType = ContextRequired;
 	Put(Conditionals, Name, len, Cond, NULL);
 }
 
@@ -2099,11 +2363,11 @@ HashList *Defines;
  */
 void tmplput_ContextString(StrBuf *Target, WCTemplputParams *TP)
 {
-	StrBufAppendTemplate(Target, TP, (StrBuf*)CTX, 0);
+	StrBufAppendTemplate(Target, TP, (StrBuf*)CTX(CTX_STRBUF), 0);
 }
 int ConditionalContextStr(StrBuf *Target, WCTemplputParams *TP)
 {
-	StrBuf *TokenText = (StrBuf*) CTX;
+	StrBuf *TokenText = (StrBuf*) CTX((CTX_STRBUF));
 	const char *CompareToken;
 	long len;
 
@@ -2113,7 +2377,7 @@ int ConditionalContextStr(StrBuf *Target, WCTemplputParams *TP)
 
 void tmplput_ContextStringArray(StrBuf *Target, WCTemplputParams *TP)
 {
-	HashList *Arr = (HashList*) CTX;
+	HashList *Arr = (HashList*) CTX(CTX_STRBUFARR);
 	void *pV;
 	int val;
 
@@ -2125,7 +2389,7 @@ void tmplput_ContextStringArray(StrBuf *Target, WCTemplputParams *TP)
 }
 int ConditionalContextStrinArray(StrBuf *Target, WCTemplputParams *TP)
 {
-	HashList *Arr = (HashList*) CTX;
+	HashList *Arr = (HashList*) CTX(CTX_STRBUFARR);
 	void *pV;
 	int val;
 	const char *CompareToken;
@@ -2167,12 +2431,14 @@ void tmpl_do_boxed(StrBuf *Target, WCTemplputParams *TP)
 		}
 	}
 	/* else TODO error? logging? */
-	memcpy (&SubTP, TP, sizeof(WCTemplputParams));
-	SubTP.Context = Headline;
-	SubTP.Filter.ContextType = CTX_STRBUF;
-	DoTemplate(HKEY("beginbox"), Target, &SubTP);
+
+	StackContext (TP, &SubTP, Headline, CTX_STRBUF, 0, NULL);
+	{
+		DoTemplate(HKEY("box_begin"), Target, &SubTP);
+	}
+	UnStackContext(&SubTP);
 	DoTemplate(TKEY(0), Target, TP);
-	DoTemplate(HKEY("endbox"), Target, TP);
+	DoTemplate(HKEY("box_end"), Target, TP);
 	FreeStrBuf(&Headline);
 }
 
@@ -2193,7 +2459,6 @@ int preeval_do_tabbed(WCTemplateToken *Token)
 	long len;
 	int i, nTabs;
 
-
 	memset(&TPP, 0, sizeof(WCTemplputParams));
 	TP = &TPP;
 	TP->Tokens = Token;
@@ -2256,7 +2521,6 @@ void tmpl_do_tabbed(StrBuf *Target, WCTemplputParams *TP)
 	WCTemplputParams SubTP;
 
 	memset(&TS, 0, sizeof(tab_struct));
-	memcpy (&SubTP, &TP, sizeof(WCTemplputParams));
 
 	nTabs = ntabs = TP->Tokens->nParameters / 2;
 	TabNames = (StrBuf **) malloc(ntabs * sizeof(StrBuf*));
@@ -2283,33 +2547,34 @@ void tmpl_do_tabbed(StrBuf *Target, WCTemplputParams *TP)
 			nTabs --;
 		}
 	}
-	memcpy (&SubTP, TP, sizeof(WCTemplputParams));
-	SubTP.Filter.ControlContextType = CTX_TAB;
-	SubTP.ControlContext = &TS;
-
-	StrTabbedDialog(Target, nTabs, TabNames);
-	for (i = 0; i < ntabs; i++) {
-		memset(&TS, 0, sizeof(tab_struct));
-		TS.CurrentTab = i;
-		TS.TabTitle = TabNames[i];
-		StrBeginTab(Target, i, nTabs, TabNames);
-		DoTemplate(TKEY(i * 2 + 1), Target, &SubTP);
-		StrEndTab(Target, i, nTabs);
+	StackContext (TP, &SubTP, &TS, CTX_TAB, 0, NULL);
+	{
+		StrTabbedDialog(Target, nTabs, TabNames);
+		for (i = 0; i < ntabs; i++) {
+			memset(&TS, 0, sizeof(tab_struct));
+			TS.CurrentTab = i;
+			TS.TabTitle = TabNames[i];
+			StrBeginTab(Target, i, nTabs, TabNames);
+			DoTemplate(TKEY(i * 2 + 1), Target, &SubTP);
+			StrEndTab(Target, i, nTabs);
+		}
+		for (i = 0; i < ntabs; i++) 
+			FreeStrBuf(&TabNames[i]);
+		free(TabNames);
 	}
-	for (i = 0; i < ntabs; i++) 
-		FreeStrBuf(&TabNames[i]);
+	UnStackContext(&SubTP);
 }
 
 void tmplput_TAB_N(StrBuf *Target, WCTemplputParams *TP)
 {
-	tab_struct *Ctx = CCTX;
+	tab_struct *Ctx = CTX(CTX_TAB);
 
 	StrBufAppendPrintf(Target, "%d", Ctx->CurrentTab);
 }
 
 void tmplput_TAB_TITLE(StrBuf *Target, WCTemplputParams *TP)
 {
-	tab_struct *Ctx = CCTX;
+	tab_struct *Ctx = CTX(CTX_TAB);
 	StrBufAppendTemplate(Target, TP, Ctx->TabTitle, 0);
 }
 
@@ -2323,7 +2588,7 @@ void RegisterSortFunc(const char *name, long len,
 		      CompareFunc Forward, 
 		      CompareFunc Reverse, 
 		      CompareFunc GroupChange, 
-		      long ContextType)
+		      CtxType ContextType)
 {
 	SortStruct *NewSort;
 
@@ -2339,7 +2604,7 @@ void RegisterSortFunc(const char *name, long len,
 	NewSort->GroupChange = GroupChange;
 	NewSort->ContextType = ContextType;
 	if (ContextType == CTX_NONE) {
-		lprintf(1, "sorting requires a context. CTX_NONE won't make it.\n");
+		syslog(LOG_WARNING, "sorting requires a context. CTX_NONE won't make it.\n");
 		exit(1);
 	}
 		
@@ -2350,7 +2615,6 @@ CompareFunc RetrieveSort(WCTemplputParams *TP,
 			 const char *OtherPrefix, long OtherPrefixLen,
 			 const char *Default, long ldefault, long DefaultDirection)
 {
-	int isdefault = 0;
 	const StrBuf *BSort = NULL;
 	SortStruct *SortBy;
 	void *vSortBy;
@@ -2384,13 +2648,12 @@ CompareFunc RetrieveSort(WCTemplputParams *TP,
 
 	if (!GetHash(SortHash, SKEY(BSort), &vSortBy) || 
 	    (vSortBy == NULL)) {
-		isdefault = 1;
 		if (!GetHash(SortHash, Default, ldefault, &vSortBy) || 
 		    (vSortBy == NULL)) {
 			LogTemplateError(
 				NULL, "Sorting", ERR_PARM1, TP,
 				"Illegal default sort: [%s]", Default);
-			wc_backtrace();
+			wc_backtrace(LOG_WARNING);
 		}
 	}
 	SortBy = (SortStruct*)vSortBy;
@@ -2400,7 +2663,7 @@ CompareFunc RetrieveSort(WCTemplputParams *TP,
 
 	/** Ok, its us, lets see in which direction we should sort... */
 	if (havebstr("SortOrder")) {
-		SortOrder = LBSTR("SortOrder");
+		SortOrder = lbstr("SortOrder");
 	}
 	else { /** Try to fallback to our remembered values... */
 		StrBuf *Buf = NULL;
@@ -2439,9 +2702,9 @@ enum {
 };
 
 ConstStr SortIcons[] = {
-	{HKEY("static/sort_none.gif")},
-	{HKEY("static/up_pointer.gif")},
-	{HKEY("static/down_pointer.gif")},
+	{HKEY("static/webcit_icons/sort_none.gif")},
+	{HKEY("static/webcit_icons/up_pointer.gif")},
+	{HKEY("static/webcit_icons/down_pointer.gif")},
 };
 
 ConstStr SortNextOrder[] = {
@@ -2492,7 +2755,7 @@ int GetSortMetric(WCTemplputParams *TP, SortStruct **Next, SortStruct **Param, l
 
 	/** Ok, its us, lets see in which direction we should sort... */
 	if (havebstr("SortOrder")) {
-		*SortOrder = LBSTR("SortOrder");
+		*SortOrder = lbstr("SortOrder");
 	}
 	else { /** Try to fallback to our remembered values... */
 		if ((*Param)->PrefPrepend == NULL) {
@@ -2598,7 +2861,7 @@ void tmplput_SORT_ORDER(StrBuf *Target, WCTemplputParams *TP)
 
 void tmplput_long_vector(StrBuf *Target, WCTemplputParams *TP)
 {
-	long *LongVector = (long*) CTX;
+	long *LongVector = (long*) CTX(CTX_LONGVECTOR);
 
 	if ((TP->Tokens->Params[0]->Type == TYPE_LONG) && 
 	    (TP->Tokens->Params[0]->lvalue <= LongVector[0]))
@@ -2635,13 +2898,13 @@ void dbg_print_longvector(long *LongVector)
 			StrBufAppendPrintf(Buf, "%d: %ld]\n", i, LongVector[i]);
 
 	}
-	lprintf(1, ChrPtr(Buf));
+	syslog(LOG_DEBUG, "%s", ChrPtr(Buf));
 	FreeStrBuf(&Buf);
 }
 
 int ConditionalLongVector(StrBuf *Target, WCTemplputParams *TP)
 {
-	long *LongVector = (long*) CTX;
+	long *LongVector = (long*) CTX(CTX_LONGVECTOR);
 
 	if ((TP->Tokens->Params[2]->Type == TYPE_LONG) && 
 	    (TP->Tokens->Params[2]->lvalue <= LongVector[0])&&
@@ -2681,6 +2944,9 @@ void
 InitModule_SUBST
 (void)
 {
+	RegisterCTX(CTX_TAB);
+	RegisterCTX(CTX_ITERATE);
+
 	memset(&NoCtx, 0, sizeof(WCTemplputParams));
 	RegisterNamespace("--", 0, 2, tmplput_Comment, NULL, CTX_NONE);
 	RegisterNamespace("SORT:ICON", 1, 2, tmplput_SORT_ICON, NULL, CTX_NONE);
@@ -2691,31 +2957,31 @@ InitModule_SUBST
 	RegisterNamespace("ITERATE", 2, 100, tmpl_iterate_subtmpl, preeval_iterate, CTX_NONE);
 	RegisterNamespace("DOBOXED", 1, 2, tmpl_do_boxed, NULL, CTX_NONE);
 	RegisterNamespace("DOTABBED", 2, 100, tmpl_do_tabbed, preeval_do_tabbed, CTX_NONE);
-	RegisterControlNS(HKEY("TAB:N"), 0, 0, tmplput_TAB_N, CTX_TAB);
-	RegisterControlNS(HKEY("TAB:SUBJECT"), 0, 1, tmplput_TAB_TITLE, CTX_TAB);
+	RegisterNamespace("TAB:N", 0, 0, tmplput_TAB_N, NULL, CTX_TAB);
+	RegisterNamespace("TAB:SUBJECT", 0, 1, tmplput_TAB_TITLE, NULL, CTX_TAB);
 
 
 	RegisterNamespace("LONGVECTOR", 1, 1, tmplput_long_vector, NULL, CTX_LONGVECTOR);
 
 
-	RegisterConditional(HKEY("COND:CONTEXTSTR"), 3, ConditionalContextStr, CTX_STRBUF);
-	RegisterConditional(HKEY("COND:CONTEXTSTRARR"), 4, ConditionalContextStrinArray, CTX_STRBUFARR);
-	RegisterConditional(HKEY("COND:LONGVECTOR"), 4, ConditionalLongVector, CTX_LONGVECTOR);
+	RegisterConditional("COND:CONTEXTSTR", 3, ConditionalContextStr, CTX_STRBUF);
+	RegisterConditional("COND:CONTEXTSTRARR", 4, ConditionalContextStrinArray, CTX_STRBUFARR);
+	RegisterConditional("COND:LONGVECTOR", 4, ConditionalLongVector, CTX_LONGVECTOR);
 
 
-	RegisterControlConditional(HKEY("COND:ITERATE:ISGROUPCHANGE"), 2, 
-				   conditional_ITERATE_ISGROUPCHANGE, 
-				   CTX_ITERATE);
-	RegisterControlConditional(HKEY("COND:ITERATE:LASTN"), 2, 
-				   conditional_ITERATE_LASTN, 
-				   CTX_ITERATE);
-	RegisterControlConditional(HKEY("COND:ITERATE:FIRSTN"), 2, 
-				   conditional_ITERATE_FIRSTN, 
-				   CTX_ITERATE);
+	RegisterConditional("COND:ITERATE:ISGROUPCHANGE", 2, 
+			    conditional_ITERATE_ISGROUPCHANGE, 
+			    CTX_ITERATE);
+	RegisterConditional("COND:ITERATE:LASTN", 2, 
+			    conditional_ITERATE_LASTN, 
+			    CTX_ITERATE);
+	RegisterConditional("COND:ITERATE:FIRSTN", 2, 
+			    conditional_ITERATE_FIRSTN, 
+			    CTX_ITERATE);
 
-	RegisterControlNS(HKEY("ITERATE:ODDEVEN"), 0, 0, tmplput_ITERATE_ODDEVEN, CTX_ITERATE);
-	RegisterControlNS(HKEY("ITERATE:KEY"), 0, 0, tmplput_ITERATE_KEY, CTX_ITERATE);
-	RegisterControlNS(HKEY("ITERATE:N"), 0, 0, tmplput_ITERATE_LASTN, CTX_ITERATE);
+	RegisterNamespace("ITERATE:ODDEVEN", 0, 0, tmplput_ITERATE_ODDEVEN, NULL, CTX_ITERATE);
+	RegisterNamespace("ITERATE:KEY", 0, 0, tmplput_ITERATE_KEY, NULL, CTX_ITERATE);
+	RegisterNamespace("ITERATE:N", 0, 0, tmplput_ITERATE_LASTN, NULL, CTX_ITERATE);
 	RegisterNamespace("CURRENTFILE", 0, 1, tmplput_CURRENT_FILE, NULL, CTX_NONE);
 	RegisterNamespace("DEF:STR", 1, 1, tmplput_DefStr, NULL, CTX_NONE);
 	RegisterNamespace("DEF:VAL", 1, 1, tmplput_DefVal, NULL, CTX_NONE);
@@ -2729,16 +2995,21 @@ void
 ServerStartModule_SUBST
 (void)
 {
-	WirelessTemplateCache = NewHash(1, NULL);
-	WirelessLocalTemplateCache = NewHash(1, NULL);
+	textPlainType = NewStrBufPlain(HKEY("text/plain"));
 	LocalTemplateCache = NewHash(1, NULL);
 	TemplateCache = NewHash(1, NULL);
-
 	GlobalNS = NewHash(1, NULL);
 	Iterators = NewHash(1, NULL);
 	Conditionals = NewHash(1, NULL);
 	SortHash = NewHash(1, NULL);
 	Defines = NewHash(1, NULL);
+	CtxList = NewHash(1, NULL);
+	
+	PutContextType(HKEY("CTX_NONE"), 0);
+
+	RegisterCTX(CTX_STRBUF);
+	RegisterCTX(CTX_STRBUFARR);
+	RegisterCTX(CTX_LONGVECTOR);
 }
 
 void
@@ -2752,16 +3023,17 @@ void
 ServerShutdownModule_SUBST
 (void)
 {
-	DeleteHash(&WirelessTemplateCache);
-	DeleteHash(&WirelessLocalTemplateCache);
+	FreeStrBuf(&textPlainType);
+
 	DeleteHash(&TemplateCache);
 	DeleteHash(&LocalTemplateCache);
-
+	
 	DeleteHash(&GlobalNS);
 	DeleteHash(&Iterators);
 	DeleteHash(&Conditionals);
 	DeleteHash(&SortHash);
 	DeleteHash(&Defines);
+	DeleteHash(&CtxList);
 }