X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=webcit%2Fsubst.c;h=8bc65275fd066bab4513bfadf56136bba748d664;hb=fcb8c4169baa629eb3c1a4979c7c8c32f1560389;hp=31be4b4a8a016399b0b8da15ee98caf110367ce4;hpb=47dc3a711fc3bf4de8a416748a51ba23af468a36;p=citadel.git

diff --git a/webcit/subst.c b/webcit/subst.c
index 31be4b4a8..8bc65275f 100644
--- a/webcit/subst.c
+++ b/webcit/subst.c
@@ -1,6 +1,3 @@
-/*
- * $Id$
- */
 #include "sysdep.h"
 
 
@@ -34,7 +31,7 @@ HashList *Defines;
 
 int DumpTemplateI18NStrings = 0;
 int LoadTemplates = 0;
-int dbg_bactrace_template_errors = 0;
+int dbg_backtrace_template_errors = 0;
 WCTemplputParams NoCtx;
 StrBuf *I18nDump = NULL;
 
@@ -76,7 +73,7 @@ typedef struct _HashHandler {
 	WCHandlerFunc HandlerFunc;
 }HashHandler;
 
-void *load_template(StrBuf *filename, StrBuf *Key, HashList *PutThere);
+void *load_template(WCTemplate *NewTemplate);
 int EvaluateConditional(StrBuf *Target, int Neg, int state, WCTemplputParams *TP);
 
 
@@ -105,12 +102,15 @@ const char *CtxNames[]  = {
 	"Context MIME_ATACH",
 	"Context FILELIST",
 	"Context STRBUF",
+	"Context STRBUFARR",
 	"Context LONGVECTOR",
 	"Context ROOMS",
 	"Context FLOORS",
 	"Context ITERATE",
 	"Context ICAL",
 	"Context DavNamespace",
+	"Context TAB",
+	"Context VCARD",
 	"Context UNKNOWN"
 };
 
@@ -135,7 +135,6 @@ const char *ContextName(int ContextType)
 void LogTemplateError (StrBuf *Target, const char *Type, int ErrorPos, WCTemplputParams *TP, const char *Format, ...)
 {
 	wcsession *WCC;
-	StrBuf *Header;
 	StrBuf *Error;
 	StrBuf *Info;
         va_list arg_ptr;
@@ -149,19 +148,13 @@ void LogTemplateError (StrBuf *Target, const char *Type, int ErrorPos, WCTemplpu
 	va_end(arg_ptr);
 
 	switch (ErrorPos) {
-	default:
 	case ERR_NAME: /* the main token name... */ 
 		Err = (TP->Tokens!= NULL)? TP->Tokens->pName:"";
 		break;
-	case ERR_PARM1:
-		Err = ((TP->Tokens!= NULL) && 
-		       (TP->Tokens->nParameters > 0))? 
-			TP->Tokens->Params[0]->Start : "";
-		break;
-	case ERR_PARM2:
+	default:
 		Err = ((TP->Tokens!= NULL) && 
-		       (TP->Tokens->nParameters > 1))? 
-			TP->Tokens->Params[1]->Start : "";
+		       (TP->Tokens->nParameters > ErrorPos - 1))? 
+			TP->Tokens->Params[ErrorPos - 1]->Start : "";
 		break;
 	}
 	if (TP->Tokens != NULL) 
@@ -191,7 +184,7 @@ void LogTemplateError (StrBuf *Target, const char *Type, int ErrorPos, WCTemplpu
 		return; 
 	}
 
-	Header = NewStrBuf();
+	if (WCC->WFBuf == NULL) WCC->WFBuf = NewStrBuf();
 	if (TP->Tokens != NULL) 
 	{
 		/* deprecated: 
@@ -212,7 +205,7 @@ void LogTemplateError (StrBuf *Target, const char *Type, int ErrorPos, WCTemplpu
 			     ChrPtr(TP->Tokens->FlatToken));
 
 
-		SerializeJson(Header, WildFireException(SKEY(TP->Tokens->FileName),
+		SerializeJson(WCC->WFBuf, WildFireException(SKEY(TP->Tokens->FileName),
 							TP->Tokens->Line,
 							Info,
 							1), 1);
@@ -222,7 +215,7 @@ void LogTemplateError (StrBuf *Target, const char *Type, int ErrorPos, WCTemplpu
 						      Error,
 						      eERROR), 1);
 */
-		WildFireSerializePayload(Header, WCC->HBuf, &WCC->Hdr->nWildfireHeaders, NULL);
+		
 	}
 	else
 	{
@@ -238,14 +231,12 @@ void LogTemplateError (StrBuf *Target, const char *Type, int ErrorPos, WCTemplpu
 			     Err, 
 			     ChrPtr(Error), 
 			     ChrPtr(TP->Tokens->FlatToken));
-		SerializeJson(Header, WildFireException(HKEY(__FILE__), __LINE__, Info, 1), 1);
-		WildFireSerializePayload(Header, WCC->HBuf, &WCC->Hdr->nWildfireHeaders, NULL);
+		SerializeJson(WCC->WFBuf, WildFireException(HKEY(__FILE__), __LINE__, Info, 1), 1);
 	}
-	FreeStrBuf(&Header);
 	FreeStrBuf(&Info);
 	FreeStrBuf(&Error);
 /*
-	if (dbg_bactrace_template_errors)
+	if (dbg_backtrace_template_errors)
 		wc_backtrace(); 
 */
 }
@@ -256,7 +247,6 @@ void LogTemplateError (StrBuf *Target, const char *Type, int ErrorPos, WCTemplpu
 void LogError (StrBuf *Target, const char *Type, const char *Format, ...)
 {
 	wcsession *WCC;
-	StrBuf *Header;
 	StrBuf *Error;
 	StrBuf *Info;
         va_list arg_ptr;
@@ -271,20 +261,17 @@ void LogError (StrBuf *Target, const char *Type, const char *Format, ...)
 	lprintf(1, ChrPtr(Error));
 
 	WCC = WC;
-	Header = NewStrBuf();
+	if (WCC->WFBuf == NULL) WCC->WFBuf = NewStrBuf();
 
+	SerializeJson(WCC->WFBuf, WildFireException(Type, strlen(Type),
+						    0,
+						    Info,
+						    1), 1);
 
-	SerializeJson(Header, WildFireException(Type, strlen(Type),
-						0,
-						Info,
-						1), 1);
-	WildFireSerializePayload(Header, WCC->HBuf, &WCC->Hdr->nWildfireHeaders, NULL);
-	
-	FreeStrBuf(&Header);
 	FreeStrBuf(&Info);
 	FreeStrBuf(&Error);
 /*
-	if (dbg_bactrace_template_errors)
+	if (dbg_backtrace_template_errors)
 		wc_backtrace(); 
 */
 }
@@ -406,338 +393,6 @@ void FreeWCTemplate(void *vFreeMe)
 }
 
 
-/*
- * debugging function to print array to log
- */
-void VarPrintTransition(void *vVar1, void *vVar2, int odd){}
-
-/*
- * debugging function to print array to log
- */
-void VarPrintEntry(const char *Key, void *vSubst, int odd)
-{
-	wcsubst *ptr;
-	lprintf(1,"Subst[%s] : ", Key);
-	ptr = (wcsubst*) vSubst;
-
-	switch(ptr->wcs_type) {
-	case WCS_STRING:
-		lprintf(1, "  -> %s\n", ChrPtr(ptr->wcs_value));
-		break;
-	case WCS_SERVCMD:
-		lprintf(1, "  -> Server [%s]\n", ChrPtr(ptr->wcs_value));
-		break;
-	case WCS_FUNCTION:
-		lprintf(1, "  -> function at [%0xd]\n", ptr->wcs_function);
-		break;
-	default:
-		lprintf(1,"  WARNING: invalid type: [%ld]!\n", ptr->wcs_type);
-	}
-}
-
-
-
-/*
- * Clear out the list of substitution variables local to this session
- */
-void clear_substs(wcsession *wc) {
-
-	if (wc->vars != NULL) {
-		DeleteHash(&wc->vars);
-	}
-}
-
-/*
- * Clear out the list of substitution variables local to this session
- */
-void clear_local_substs(void) {
-	clear_substs (WC);
-}
-
-int NeedNewBuf(type)
-{
-	switch(type) {
-	case WCS_STRING:
-	case WCS_SERVCMD:
-	case WCS_STRBUF:
-		return 1;
-	case WCS_FUNCTION:
-	case WCS_STRBUF_REF:
-	case WCS_LONG:
-	default:
-		return 0;
-	}
-}
-
-void FlushPayload(wcsubst *ptr, int reusestrbuf, int type)
-{
-	int NeedNew = NeedNewBuf(type);
-	switch(ptr->wcs_type) {
-	case WCS_STRING:
-	case WCS_SERVCMD:
-	case WCS_STRBUF:
-		if (reusestrbuf && NeedNew) {
-			FlushStrBuf(ptr->wcs_value);
-		}
-		else {
-			
-			FreeStrBuf(&ptr->wcs_value);
-			ptr->wcs_value = NULL;
-		}
-		break;
-	case WCS_FUNCTION:
-		ptr->wcs_function = NULL;
-		if (reusestrbuf && NeedNew)
-			ptr->wcs_value = NewStrBuf();
-		break;
-	case WCS_STRBUF_REF:
-		ptr->wcs_value = NULL;
-		if (reusestrbuf && NeedNew)
-			ptr->wcs_value = NewStrBuf();
-		break;
-	case WCS_LONG:
-		ptr->lvalue = 0;
-		if (reusestrbuf && NeedNew)
-			ptr->wcs_value = NewStrBuf();
-		break;
-	default:
-		if (reusestrbuf && NeedNew)
-			ptr->wcs_value = NewStrBuf();
-		break;
-	}
-}
-
-
-/*
- * destructor; kill one entry.
- */
-void deletevar(void *data)
-{
-	wcsubst *ptr = (wcsubst*)data;
-	FlushPayload(ptr, 0, ptr->wcs_type);
-	free(ptr);	
-}
-
-
-wcsubst *NewSubstVar(const char *keyname, int keylen, int type)
-{
-	wcsubst* ptr;
-	wcsession *WCC = WC;
-
-	ptr = (wcsubst *) malloc(sizeof(wcsubst));
-	memset(ptr, 0, sizeof(wcsubst));
-
-	ptr->wcs_type = type;
-	safestrncpy(ptr->wcs_key, keyname, sizeof ptr->wcs_key);
-	Put(WCC->vars, keyname, keylen, ptr,  deletevar);
-
-	switch(ptr->wcs_type) {
-	case WCS_STRING:
-	case WCS_SERVCMD:
-		ptr->wcs_value = NewStrBuf();
-		break;
-	case WCS_STRBUF:
-	case WCS_FUNCTION:
-	case WCS_STRBUF_REF:
-	case WCS_LONG:
-	default:
-		break;
-	}
-	return ptr;
-}
-
-
-/*
- * Add a substitution variable (local to this session) (strlen version...)
- * keyname the replacementstring to substitute
- * keytype the kind of the key
- * format the format string ala printf
- * ... the arguments to substitute in the formatstring
- */
-void SVPRINTF(char *keyname, int keytype, const char *format,...)
-{
-	va_list arg_ptr;
-	void *vPtr;
-	wcsubst *ptr = NULL;
-	size_t keylen;
-	wcsession *WCC = WC;
-	
-	keylen = strlen(keyname);
-	/*
-	 * First look if we're doing a replacement of
-	 * an existing key
-	 */
-	/*PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/
-	if (GetHash(WCC->vars, keyname, keylen, &vPtr)) {
-		ptr = (wcsubst*)vPtr;
-		FlushPayload(ptr, keytype, keytype);
-		ptr->wcs_type = keytype;
-	}
-	else 	/** Otherwise allocate a new one */
-	{
-		ptr = NewSubstVar(keyname, keylen, keytype);
-	}
-
-	/* Format the string */
-	va_start(arg_ptr, format);
-	StrBufVAppendPrintf(ptr->wcs_value, format, arg_ptr);
-	va_end(arg_ptr);
-}
-
-/*
- * Add a substitution variable (local to this session)
- * keyname the replacementstring to substitute
- * keytype the kind of the key
- * format the format string ala printf
- * ... the arguments to substitute in the formatstring
- */
-void svprintf(char *keyname, size_t keylen, int keytype, const char *format,...)
-{
-	va_list arg_ptr;
-	void *vPtr;
-	wcsubst *ptr = NULL;
-	wcsession *WCC = WC;
-		
-	/*
-	 * First look if we're doing a replacement of
-	 * an existing key
-	 */
-	/*PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/
-	if (GetHash(WCC->vars, keyname, keylen, &vPtr)) {
-		ptr = (wcsubst*)vPtr;
-		FlushPayload(ptr, 1, keytype);
-		ptr->wcs_type = keytype;
-	}
-	else 	/** Otherwise allocate a new one */
-	{
-		ptr = NewSubstVar(keyname, keylen, keytype);
-	}
-
-	/** Format the string and save it */
-	va_start(arg_ptr, format);
-	StrBufVAppendPrintf(ptr->wcs_value, format, arg_ptr);
-	va_end(arg_ptr);
-}
-
-/*
- * Add a substitution variable (local to this session)
- * keyname the replacementstring to substitute
- * keytype the kind of the key
- * format the format string ala printf
- * ... the arguments to substitute in the formatstring
- */
-void SVPut(char *keyname, size_t keylen, int keytype, char *Data)
-{
-	void *vPtr;
-	wcsubst *ptr = NULL;
-	wcsession *WCC = WC;
-
-	
-	/*
-	 * First look if we're doing a replacement of
-	 * an existing key
-	 */
-	/*PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/
-	if (GetHash(WCC->vars, keyname, keylen, &vPtr)) {
-		ptr = (wcsubst*)vPtr;
-		FlushPayload(ptr, 1, keytype);
-		ptr->wcs_type = keytype;
-	}
-	else 	/** Otherwise allocate a new one */
-	{
-		ptr = NewSubstVar(keyname, keylen, keytype);
-	}
-	StrBufAppendBufPlain(ptr->wcs_value, Data, -1, 0);
-}
-
-/**
- * \brief Add a substitution variable (local to this session)
- * \param keyname the replacementstring to substitute
- * \param keytype the kind of the key
- * \param format the format string ala printf
- * \param ... the arguments to substitute in the formatstring
- */
-void SVPutLong(char *keyname, size_t keylen, long Data)
-{
-	void *vPtr;
-	wcsubst *ptr = NULL;
-	wcsession *WCC = WC;
-
-	
-	/**
-	 * First look if we're doing a replacement of
-	 * an existing key
-	 */
-	/*PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/
-	if (GetHash(WCC->vars, keyname, keylen, &vPtr)) {
-		ptr = (wcsubst*)vPtr;
-		FlushPayload(ptr, 1, WCS_LONG);
-		ptr->wcs_type = WCS_LONG;
-	}
-	else 	/** Otherwise allocate a new one */
-	{
-		ptr = NewSubstVar(keyname, keylen, WCS_LONG);
-	}
-	ptr->lvalue = Data;
-}
-
-/**
- * \brief Add a substitution variable (local to this session) that does a callback
- * \param keyname the keystring to substitute
- * \param fcn_ptr the function callback to give the substitution string
- */
-void SVCallback(char *keyname, size_t keylen, WCHandlerFunc fcn_ptr)
-{
-	wcsubst *ptr;
-	void *vPtr;
-	wcsession *WCC = WC;
-
-	/**
-	 * First look if we're doing a replacement of
-	 * an existing key
-	 */
-	/*PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/
-	if (GetHash(WCC->vars, keyname, keylen, &vPtr)) {
-		ptr = (wcsubst*)vPtr;
-		FlushPayload(ptr, 1, WCS_FUNCTION);
-		ptr->wcs_type = WCS_FUNCTION;
-	}
-	else 	/** Otherwise allocate a new one */
-	{
-		ptr = NewSubstVar(keyname, keylen, WCS_FUNCTION);
-	}
-
-	ptr->wcs_function = fcn_ptr;
-}
-inline void SVCALLBACK(char *keyname, WCHandlerFunc fcn_ptr)
-{
-	SVCallback(keyname, strlen(keyname), fcn_ptr);
-}
-
-
-
-void SVPUTBuf(const char *keyname, int keylen, const StrBuf *Buf, int ref)
-{
-	wcsubst *ptr;
-	void *vPtr;
-	wcsession *WCC = WC;
-
-	/**
-	 * First look if we're doing a replacement of
-	 * an existing key
-	 */
-	/*PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/
-	if (GetHash(WCC->vars, keyname, keylen, &vPtr)) {
-		ptr = (wcsubst*)vPtr;
-		FlushPayload(ptr, 0, (ref)?WCS_STRBUF_REF:WCS_STRBUF);
-		ptr->wcs_type = (ref)?WCS_STRBUF_REF:WCS_STRBUF;
-	}
-	else 	/** Otherwise allocate a new one */
-	{
-		ptr = NewSubstVar(keyname, keylen, (ref)?WCS_STRBUF_REF:WCS_STRBUF);
-	}
-	ptr->wcs_value = (StrBuf*)Buf;
-}
 
 /**
  * \brief back end for print_value_of() ... does a server command
@@ -766,6 +421,31 @@ void pvo_do_cmd(StrBuf *Target, StrBuf *servcmd) {
 	}
 }
 
+int HaveTemplateTokenString(StrBuf *Target, 
+			    WCTemplputParams *TP,
+			    int N,
+			    const char **Value, 
+			    long *len)
+{
+	if (N >= TP->Tokens->nParameters) {
+		return 0;
+	}
+
+	switch (TP->Tokens->Params[N]->Type) {
+	case TYPE_INTDEFINE:
+	case TYPE_STR:
+	case TYPE_BSTR:
+	case TYPE_PREFSTR:
+	case TYPE_GETTEXT:
+	case TYPE_SUBTEMPLATE:
+		return 1;
+	case TYPE_LONG:
+	case TYPE_PREFINT:
+	default:
+		return 0;
+	}
+}
+
 void GetTemplateTokenString(StrBuf *Target, 
 			    WCTemplputParams *TP,
 			    int N,
@@ -849,7 +529,7 @@ void GetTemplateTokenString(StrBuf *Target,
 		*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:
@@ -930,129 +610,6 @@ long GetTemplateTokenNumber(StrBuf *Target, WCTemplputParams *TP, int N, long df
 }
 
 
-
-/**
- * \brief Print the value of a variable
- * \param keyname get a key to print
- */
-void print_value_of(StrBuf *Target, WCTemplputParams *TP)
- 
-{
-	wcsession *WCC = WC;
-	wcsubst *ptr;
-	void *vVar;
-
-	/*if (WCC->vars != NULL) PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/
-	/* TODO: depricated! */
-	if (TP->Tokens->pName[0] == '=') {
-		DoTemplate(TP->Tokens->pName+1, TP->Tokens->NameEnd - 1, NULL, &NoCtx);
-	}
-/*/////TODO: if param[1] == "U" -> urlescape
-/// X -> escputs */
-	/** Page-local variables */
-	if ((WCC->vars!= NULL) && GetHash(WCC->vars, TP->Tokens->pName, TP->Tokens->NameEnd, &vVar)) {
-		ptr = (wcsubst*) vVar;
-		switch(ptr->wcs_type) {
-		case WCS_STRING:
-			StrBufAppendBuf(Target, ptr->wcs_value, 0);
-			break;
-		case WCS_SERVCMD:
-			pvo_do_cmd(Target, ptr->wcs_value);
-			break;
-		case WCS_FUNCTION:
-			(*ptr->wcs_function) (Target, TP);
-			break;
-		case WCS_STRBUF:
-		case WCS_STRBUF_REF:
-			StrBufAppendBuf(Target, ptr->wcs_value, 0);
-			break;
-		case WCS_LONG:
-			StrBufAppendPrintf(Target, "%ld", ptr->lvalue);
-			break;
-		default:
-			LogTemplateError(
-                                Target, "Subst", ERR_NAME, TP,
-				"WARNING: invalid value in SV-Hash at %s!", TP->Tokens->pName);
-		}
-	}
-	else {
-		LogTemplateError(
-			Target, "Token", ERR_NAME, TP,
-			"didn't find Handler \"%s\"", TP->Tokens->pName);
-		wc_backtrace();
-	}
-}
-
-int CompareSubstToToken(TemplateParam *ParamToCompare, TemplateParam *ParamToLookup)
-{
-	wcsession *WCC = WC;
-	wcsubst *ptr;
-	void *vVar;
-
-	if ((WCC->vars!= NULL) && GetHash(WCC->vars, ParamToLookup->Start, 
-					  ParamToLookup->len, &vVar)) {
-		ptr = (wcsubst*) vVar;
-		switch(ptr->wcs_type) {
-		case WCS_STRING:
-		case WCS_STRBUF:
-		case WCS_STRBUF_REF:
-			if (ParamToCompare->Type == TYPE_STR)
-				return ((ParamToCompare->len == StrLength(ptr->wcs_value)) &&
-					(strcmp(ParamToCompare->Start, ChrPtr(ptr->wcs_value)) == 0));
-			else
-				return ParamToCompare->lvalue == StrTol(ptr->wcs_value);
-			break;
-		case WCS_SERVCMD:
-			return 1; 
-			break;
-		case WCS_FUNCTION:
-			return 1;
-		case WCS_LONG:
-			if (ParamToCompare->Type == TYPE_STR)
-				return 0;
-			else 
-				return ParamToCompare->lvalue == ptr->lvalue;
-			break;
-		default:
-			lprintf(1,"WARNING: invalid value in SV-Hash at %s!\n", 
-				ParamToLookup->Start);
-		}
-	}
-	return 0;
-}
-
-int CompareSubstToStrBuf(StrBuf *Compare, TemplateParam *ParamToLookup)
-{
-	wcsession *WCC = WC;
-	wcsubst *ptr;
-	void *vVar;
-
-	if ((WCC->vars!= NULL) && GetHash(WCC->vars, ParamToLookup->Start, 
-					  ParamToLookup->len, &vVar)) {
-		ptr = (wcsubst*) vVar;
-		switch(ptr->wcs_type) {
-		case WCS_STRING:
-		case WCS_STRBUF:
-		case WCS_STRBUF_REF:
-			return ((StrLength(Compare) == StrLength(ptr->wcs_value)) &&
-				(strcmp(ChrPtr(Compare), ChrPtr(ptr->wcs_value)) == 0));
-		case WCS_SERVCMD:
-			return 1; 
-			break;
-		case WCS_FUNCTION:
-			return 1;
-		case WCS_LONG:
-			return StrTol(Compare) == ptr->lvalue;
-		default:
-			lprintf(1,"WARNING: invalid value in SV-Hash at %s!\n", 
-				ParamToLookup->Start);
-		}
-	}
-	return 0;
-}
-
-
-
 /**
  * \brief puts string into the template and computes which escape methon we should use
  * \param Source the string we should put into the template
@@ -1101,16 +658,22 @@ void PutNewToken(WCTemplate *Template, WCTemplateToken *NewToken)
 		if (Template->TokenSpace <= 0) {
 			Template->Tokens = (WCTemplateToken**)malloc(
 				sizeof(WCTemplateToken*) * 10);
-			memset(Template->Tokens, 0, sizeof(WCTemplateToken*));
+			memset(Template->Tokens, 0, sizeof(WCTemplateToken*) * 10);
 			Template->TokenSpace = 10;
 		}
 		else {
 			WCTemplateToken **NewTokens;
-			NewTokens= (WCTemplateToken**)malloc(
-				sizeof(WCTemplateToken*) * 
-				Template->TokenSpace * 2);
-			memcpy(NewTokens, Template->Tokens, 
+
+			NewTokens= (WCTemplateToken**) malloc(
+				sizeof(WCTemplateToken*) * Template->TokenSpace * 2);
+
+			memset(NewTokens, 
+			       0, sizeof(WCTemplateToken*) * Template->TokenSpace * 2);
+
+			memcpy(NewTokens, 
+			       Template->Tokens, 
 			       sizeof(WCTemplateToken*) * Template->nTokensUsed);
+
 			free(Template->Tokens);
 			Template->TokenSpace *= 2;
 			Template->Tokens = NewTokens;
@@ -1119,12 +682,13 @@ void PutNewToken(WCTemplate *Template, WCTemplateToken *NewToken)
 	Template->Tokens[(Template->nTokensUsed)++] = NewToken;
 }
 
-TemplateParam *GetNextParameter(StrBuf *Buf, 
-				const char **pCh, 
-				const char *pe, 
-				WCTemplateToken *Tokens, 
-				WCTemplate *pTmpl, 
-				WCTemplputParams *TP)
+int GetNextParameter(StrBuf *Buf, 
+		     const char **pCh, 
+		     const char *pe, 
+		     WCTemplateToken *Tokens, 
+		     WCTemplate *pTmpl, 
+		     WCTemplputParams *TP, 
+		     TemplateParam **pParm)
 {
 	const char *pch = *pCh;
 	const char *pchs, *pche;
@@ -1132,7 +696,7 @@ TemplateParam *GetNextParameter(StrBuf *Buf,
 	char quote = '\0';
 	int ParamBrace = 0;
 
-	Parm = (TemplateParam *) malloc(sizeof(TemplateParam));
+	*pParm = Parm = (TemplateParam *) malloc(sizeof(TemplateParam));
 	memset(Parm, 0, sizeof(TemplateParam));
 	Parm->Type = TYPE_STR;
 
@@ -1211,7 +775,8 @@ TemplateParam *GetNextParameter(StrBuf *Buf,
 				*pCh);
 			pch ++;
 			free(Parm);
-			return NULL;
+			*pParm = NULL;
+			return 0;
 		}
 		else {
 			StrBufPeek(Buf, pch, -1, '\0');		
@@ -1254,7 +819,8 @@ TemplateParam *GetNextParameter(StrBuf *Buf,
 				*pCh);
 				*/
 			free(Parm);
-			return NULL;
+			*pParm = NULL;
+			return 0;
 		}
 	}
 	while ((*pch == ' ' )||
@@ -1263,13 +829,16 @@ TemplateParam *GetNextParameter(StrBuf *Buf,
 	       (*pch == ',' )||
 	       (*pch == '\n')) pch ++;
 
-	if (DumpTemplateI18NStrings && (Parm->Type == TYPE_GETTEXT)) {
-		StrBufAppendPrintf(I18nDump, "_(\"%s\");\n", Parm->Start);
-	}
-	if (Parm->Type == TYPE_INTDEFINE)
+	switch (Parm->Type)
 	{
+	case TYPE_GETTEXT:
+		if (DumpTemplateI18NStrings) {
+			StrBufAppendPrintf(I18nDump, "_(\"%s\");\n", Parm->Start);
+		}
+		break;
+	case TYPE_INTDEFINE: {
 		void *vPVal;
-
+		
 		if (GetHash(Defines, Parm->Start, Parm->len, &vPVal) &&
 		    (vPVal != NULL))
 		{
@@ -1278,27 +847,118 @@ TemplateParam *GetNextParameter(StrBuf *Buf,
 		
 			Parm->lvalue = *PVal;
 		}
-		else 
+		else if (strchr(Parm->Start, '|') != NULL)
+		{
+			const char *Pos;
+			StrBuf *pToken;
+			StrBuf *Match;
+
+			Parm->MaskBy = eOR;
+			pToken = NewStrBufPlain (Parm->Start, Parm->len);
+			Match = NewStrBufPlain (NULL, Parm->len);
+			Pos = ChrPtr(pToken);
+			
+			while ((Pos != NULL) && (Pos != StrBufNOTNULL))
+			{
+				StrBufExtract_NextToken(Match, pToken, &Pos, '|');
+				StrBufTrim(Match);
+				if (StrLength (Match) > 0)
+				{
+					if (GetHash(Defines, SKEY(Match), &vPVal) &&
+					    (vPVal != NULL))
+					{
+						long *PVal;
+						PVal = (long*) vPVal;
+						
+						Parm->lvalue |= *PVal;
+					}
+					else {
+						LogTemplateError(NULL, "Define", 
+								 Tokens->nParameters,
+								 TP,
+								 "%s isn't known!!",
+								 ChrPtr(Match));
+
+					}
+				}
+			}
+			FreeStrBuf(&pToken);
+			FreeStrBuf(&Match);
+		}
+		else if (strchr(Parm->Start, '&') != NULL)
 		{
-			LogTemplateError(NULL, "Define", ERR_PARM1, TP,
+			const char *Pos;
+			StrBuf *pToken;
+			StrBuf *Match;
+
+			Parm->MaskBy = eAND;
+			pToken = NewStrBufPlain (Parm->Start, Parm->len);
+			Match = NewStrBufPlain (NULL, Parm->len);
+			Pos = ChrPtr(pToken);
+			
+			while ((Pos != NULL) && (Pos != StrBufNOTNULL))
+			{
+				StrBufExtract_NextToken(Match, pToken, &Pos, '&');
+				StrBufTrim(Match);
+				if (StrLength (Match) > 0)
+				{
+					if (GetHash(Defines, SKEY(Match), &vPVal) &&
+					    (vPVal != NULL))
+					{
+						long *PVal;
+						PVal = (long*) vPVal;
+						
+						Parm->lvalue |= *PVal;
+					}
+					else {
+						LogTemplateError(NULL, "Define", 
+								 Tokens->nParameters,
+								 TP,
+								 "%s isn't known!!",
+								 ChrPtr(Match));
+
+					}
+				}
+			}
+			FreeStrBuf(&Match);
+			FreeStrBuf(&pToken);
+		}
+		else {
+
+
+			LogTemplateError(NULL, "Define", 
+					 Tokens->nParameters,
+					 TP,
 					 "%s isn't known!!",
 					 Parm->Start);
-		}
+		}}
+		break;
+	case TYPE_SUBTEMPLATE:{
+		void *vTmpl;
+		/* well, we don't check the mobile stuff here... */
+		if (!GetHash(LocalTemplateCache, Parm->Start, Parm->len, &vTmpl) &&
+		    !GetHash(TemplateCache, Parm->Start, Parm->len, &vTmpl)) {
+			LogTemplateError(NULL, 
+					 "SubTemplate", 
+					 Tokens->nParameters,
+					 TP,
+					 "referenced here doesn't exist");
+		}}
+		break;
 	}
 	*pCh = pch;
-	return Parm;
+	return 1;
 }
 
 WCTemplateToken *NewTemplateSubstitute(StrBuf *Buf, 
 				       const char *pStart, 
-				       const char *pTmplStart, 
-				       const char *pTmplEnd, 
+				       const char *pTokenStart, 
+				       const char *pTokenEnd, 
 				       long Line,
 				       WCTemplate *pTmpl)
 {
 	void *vVar;
 	const char *pch;
-	TemplateParam *Param;
 	WCTemplateToken *NewToken;
 	WCTemplputParams TP;
 
@@ -1308,35 +968,42 @@ WCTemplateToken *NewTemplateSubstitute(StrBuf *Buf,
 	NewToken->FileName = pTmpl->FileName; /* to print meaningfull log messages... */
 	NewToken->Flags = 0;
 	NewToken->Line = Line + 1;
-	NewToken->pTokenStart = pTmplStart;
-	NewToken->TokenStart = pTmplStart - pStart;
-	NewToken->TokenEnd =  (pTmplEnd - pStart) - NewToken->TokenStart;
-	NewToken->pTokenEnd = pTmplEnd;
+	NewToken->pTokenStart = pTokenStart;
+	NewToken->TokenStart = pTokenStart - pStart;
+	NewToken->TokenEnd =  (pTokenEnd - pStart) - NewToken->TokenStart;
+	NewToken->pTokenEnd = pTokenEnd;
 	NewToken->NameEnd = NewToken->TokenEnd - 2;
 	NewToken->PreEval = NULL;
-	NewToken->FlatToken = NewStrBufPlain(pTmplStart + 2, pTmplEnd - pTmplStart - 2);
+	NewToken->FlatToken = NewStrBufPlain(pTokenStart + 2, pTokenEnd - pTokenStart - 2);
 	StrBufShrinkToFit(NewToken->FlatToken, 1);
 
-	StrBufPeek(Buf, pTmplStart, + 1, '\0');
-	StrBufPeek(Buf, pTmplEnd, -1, '\0');
-	pch = NewToken->pName = pTmplStart + 2;
+	StrBufPeek(Buf, pTokenStart, + 1, '\0');
+	StrBufPeek(Buf, pTokenEnd, -1, '\0');
+	pch = NewToken->pName = pTokenStart + 2;
 
 	NewToken->HaveParameters = 0;;
 	NewToken->nParameters = 0;
 
-	while (pch < pTmplEnd - 1) {
+	while (pch < pTokenEnd - 1) {
 		if (*pch == '(') {
 			StrBufPeek(Buf, pch, -1, '\0');
 			NewToken->NameEnd = pch - NewToken->pName;
 			pch ++;
-			if (*(pTmplEnd - 1) != ')') {
+			if (*(pTokenEnd - 1) != ')') {
 				LogTemplateError(
 					NULL, "Parseerror", ERR_NAME, &TP, 
 					"Warning, Non welformed Token; missing right parenthesis");
 			}
-			while (pch < pTmplEnd - 1) {
-				Param = GetNextParameter(Buf, &pch, pTmplEnd - 1, NewToken, pTmpl, &TP);
-				if (Param != NULL) {
+			while (pch < pTokenEnd - 1) {
+				NewToken->nParameters++;
+				if (GetNextParameter(Buf, 
+						     &pch, 
+						     pTokenEnd - 1, 
+						     NewToken, 
+						     pTmpl, 
+						     &TP, 
+						     &NewToken->Params[NewToken->nParameters - 1]))
+				{
 					NewToken->HaveParameters = 1;
 					if (NewToken->nParameters > MAXPARAM) {
 						LogTemplateError(
@@ -1344,11 +1011,9 @@ WCTemplateToken *NewTemplateSubstitute(StrBuf *Buf,
 							"only [%d] Params allowed in Tokens",
 							MAXPARAM);
 
-						free(Param);
 						FreeToken(&NewToken);
 						return NULL;
 					}
-					NewToken->Params[NewToken->nParameters++] = Param;
 				}
 				else break;
 			}
@@ -1414,13 +1079,29 @@ WCTemplateToken *NewTemplateSubstitute(StrBuf *Buf,
 				NewToken->nParameters);
 			break;
 		}
+		else {
+			void *vTmpl;
+			/* well, we don't check the mobile stuff here... */
+			if (!GetHash(LocalTemplateCache, 
+				     NewToken->Params[0]->Start, 
+				     NewToken->Params[0]->len, 
+				     &vTmpl) &&
+			    !GetHash(TemplateCache, 
+				     NewToken->Params[0]->Start, 
+				     NewToken->Params[0]->len, 
+				     &vTmpl)) {
+				LogTemplateError(
+					NULL, "SubTemplate", ERR_PARM1, &TP,
+					"doesn't exist");
+			}
+		}
 		break;
 	case SV_CUST_STR_CONDITIONAL:
 	case SV_CONDITIONAL:
 	case SV_NEG_CONDITIONAL:
 		if (NewToken->nParameters <2) {
 			LogTemplateError(
-				NULL, "Conditional", ERR_NAME, &TP,
+				NULL, "Conditional", ERR_PARM1, &TP,
 				"require at least 2 parameters, you gave %d params", 
 				NewToken->nParameters);
 			NewToken->Flags = 0;
@@ -1428,7 +1109,7 @@ WCTemplateToken *NewTemplateSubstitute(StrBuf *Buf,
 		}
 		if (NewToken->Params[1]->lvalue == 0) {
 			LogTemplateError(
-				NULL, "Conditional", ERR_NAME, &TP,
+				NULL, "Conditional", ERR_PARM1, &TP,
 				"Conditional ID (Parameter 1) mustn't be 0!");
 			NewToken->Flags = 0;
 			break;
@@ -1442,7 +1123,7 @@ WCTemplateToken *NewTemplateSubstitute(StrBuf *Buf,
 			    (NewToken->Params[0]->Start[0] == 'X'))
 				break;
 			LogTemplateError(
-				NULL, "Conditional", ERR_NAME, &TP,
+				NULL, "Conditional", ERR_PARM1, &TP,
 				"Not found!");
 /*
 			NewToken->Error = NewStrBuf();
@@ -1488,6 +1169,10 @@ void *prepare_template(StrBuf *filename, StrBuf *Key, HashList *PutThere)
 		StrBufAppendBufPlain(NewTemplate->MimeType, HKEY("; charset=utf-8"), 0);
 	}
 
+	if (strstr(ChrPtr(NewTemplate->MimeType), "text") != NULL) {
+		StrBufAppendBufPlain(NewTemplate->MimeType, HKEY("; charset=utf-8"), 0);
+	}
+
 	Put(PutThere, ChrPtr(Key), StrLength(Key), NewTemplate, FreeWCTemplate);
 	return NewTemplate;
 }
@@ -1496,45 +1181,53 @@ void *prepare_template(StrBuf *filename, StrBuf *Key, HashList *PutThere)
  * \brief Display a variable-substituted template
  * \param templatename template file to load
  */
-void *load_template(StrBuf *filename, StrBuf *Key, HashList *PutThere)
+void *duplicate_template(WCTemplate *OldTemplate)
+{
+	WCTemplate *NewTemplate;
+
+	NewTemplate = (WCTemplate *) malloc(sizeof(WCTemplate));
+	memset(NewTemplate, 0, sizeof(WCTemplate));
+	NewTemplate->Data = NULL;
+	NewTemplate->FileName = NewStrBufDup(OldTemplate->FileName);
+	StrBufShrinkToFit(NewTemplate->FileName, 1);
+	NewTemplate->nTokensUsed = 0;
+	NewTemplate->TokenSpace = 0;
+	NewTemplate->Tokens = NULL;
+	NewTemplate->MimeType = NewStrBufDup(OldTemplate->MimeType);
+	return NewTemplate;
+}
+
+/**
+ * \brief Display a variable-substituted template
+ * \param templatename template file to load
+ */
+void *load_template(WCTemplate *NewTemplate)
 {
 	int fd;
 	struct stat statbuf;
 	const char *pS, *pE, *pch, *Err;
 	long Line;
 	int pos;
-	WCTemplate *NewTemplate;
 
-	fd = open(ChrPtr(filename), O_RDONLY);
+	fd = open(ChrPtr(NewTemplate->FileName), O_RDONLY);
 	if (fd <= 0) {
 		lprintf(1, "ERROR: could not open template '%s' - %s\n",
-			ChrPtr(filename), strerror(errno));
+			ChrPtr(NewTemplate->FileName), strerror(errno));
 		return NULL;
 	}
 
 	if (fstat(fd, &statbuf) == -1) {
 		lprintf(1, "ERROR: could not stat template '%s' - %s\n",
-			ChrPtr(filename), strerror(errno));
+			ChrPtr(NewTemplate->FileName), strerror(errno));
 		return NULL;
 	}
 
-	NewTemplate = (WCTemplate *) malloc(sizeof(WCTemplate));
-	memset(NewTemplate, 0, sizeof(WCTemplate));
-	NewTemplate->Data = NewStrBufPlain(NULL, statbuf.st_size);
-	NewTemplate->FileName = NewStrBufDup(filename);
-	NewTemplate->nTokensUsed = 0;
-	NewTemplate->TokenSpace = 0;
-	NewTemplate->Tokens = NULL;
-	NewTemplate->MimeType = NewStrBufPlain(GuessMimeByFilename (SKEY(NewTemplate->FileName)), -1);
-	if (strstr(ChrPtr(NewTemplate->MimeType), "text") != NULL) {
-		StrBufAppendBufPlain(NewTemplate->MimeType, HKEY("; charset=utf-8"), 0);
-	}
-
+	NewTemplate->Data = NewStrBufPlain(NULL, statbuf.st_size + 1);
 	if (StrBufReadBLOB(NewTemplate->Data, &fd, 1, statbuf.st_size, &Err) < 0) {
 		close(fd);
-		FreeWCTemplate(NewTemplate);
-		lprintf(1, "ERROR: reading template '%s' - %s<br />\n",
-			ChrPtr(filename), strerror(errno));
+		lprintf(1, "ERROR: reading template '%s' - %s<br>\n",
+			ChrPtr(NewTemplate->FileName), strerror(errno));
+		//FreeWCTemplate(NewTemplate);/////tODO
 		return NULL;
 	}
 	close(fd);
@@ -1583,8 +1276,6 @@ void *load_template(StrBuf *filename, StrBuf *Key, HashList *PutThere)
 			    NewTemplateSubstitute(NewTemplate->Data, pS, pts, pte, Line, NewTemplate));
 		pch ++;
 	}
-	if (LoadTemplates == 0)
-		Put(PutThere, ChrPtr(Key), StrLength(Key), NewTemplate, FreeWCTemplate);
 	return NewTemplate;
 }
 
@@ -1626,7 +1317,7 @@ int LoadTemplateDir(const StrBuf *DirName, HashList *wireless, HashList *big, co
 	Toplevel = StrLength(BaseKey) == 0;
 	SubDirectory = NewStrBuf();
 	SubKey = NewStrBuf();
-	FileName = NewStrBuf();
+	FileName = NewStrBufPlain(NULL, PATH_MAX);
 	Key = NewStrBuf();
 	while ((readdir_r(filedir, d, &filedir_entry) == 0) &&
 	       (filedir_entry != NULL))
@@ -1678,7 +1369,7 @@ int LoadTemplateDir(const StrBuf *DirName, HashList *wireless, HashList *big, co
 		case DT_DIR:
 			/* Skip directories we are not interested in... */
 			if (strcmp(filedir_entry->d_name, ".svn") == 0)
-				break;
+				continue;
 
 			FlushStrBuf(SubKey);
 			if (!Toplevel) {
@@ -1705,9 +1396,12 @@ int LoadTemplateDir(const StrBuf *DirName, HashList *wireless, HashList *big, co
 				d_without_ext --;
 			if ((d_without_ext == 0) || (d_namelen < 3))
 				continue;
-			if ((d_namelen > 1) && filedir_entry->d_name[d_namelen - 1] == '~')
+			if (((d_namelen > 1) && filedir_entry->d_name[d_namelen - 1] == '~') ||
+			    (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] == '.');
@@ -1724,12 +1418,9 @@ 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)
+			if (LoadTemplates >= 1)
 				lprintf(1, "%s %d %s\n", ChrPtr(FileName), IsMobile, ChrPtr(Key));
-			if (LoadTemplates == 0)
-				load_template(FileName, Key, (IsMobile)?wireless:big);
-			else
-				prepare_template(FileName, Key, (IsMobile)?wireless:big);
+			prepare_template(FileName, Key, (IsMobile)?wireless:big);
 		default:
 			break;
 		}
@@ -1745,8 +1436,10 @@ int LoadTemplateDir(const StrBuf *DirName, HashList *wireless, HashList *big, co
 
 void InitTemplateCache(void)
 {
+	int i;
 	StrBuf *Key;
 	StrBuf *Dir;
+	HashList *Templates[4];
 
 	Dir = NewStrBuf();
 	Key = NewStrBuf();
@@ -1772,6 +1465,31 @@ void InitTemplateCache(void)
 			WirelessTemplateCache,
 			TemplateCache, 
 			Key);
+	Templates[0] = WirelessTemplateCache;
+	Templates[1] = TemplateCache;
+	Templates[2] = WirelessLocalTemplateCache;
+	Templates[3] = LocalTemplateCache;
+
+
+	if (LoadTemplates == 0) 
+		for (i=0; i < 4; i++) {
+			const char *Key;
+			long KLen;
+			HashPos *At;
+			void *vTemplate;
+
+			At = GetNewHashPos(Templates[i], 0);
+			while (GetNextHashPos(Templates[i], 
+					      At, 
+					      &KLen,
+					      &Key, 
+					      &vTemplate) && 
+			       (vTemplate != NULL))
+			{
+				load_template((WCTemplate *)vTemplate);
+			}
+			DeleteHashPos(&At);
+		}
 
 
 	FreeStrBuf(&Dir);
@@ -1858,7 +1576,9 @@ int EvaluateToken(StrBuf *Target, int state, WCTemplputParams *TP)
 			}
 		}
 		else {
-			print_value_of(Target, TP);
+			LogTemplateError(
+				Target, "Token UNKNOWN", ERR_NAME, TP,
+				"You've specified a token that isn't known to webcit.!");
 		}
 	}
 	return 0;
@@ -1884,13 +1604,13 @@ const StrBuf *ProcessTemplate(WCTemplate *Tmpl, StrBuf *Target, WCTemplputParams
 		if (LoadTemplates > 1)
 			lprintf(1, "DBG: ----- loading:  [%s] ------ \n", 
 				ChrPtr(Tmpl->FileName));
-
-		pTmpl = load_template(Tmpl->FileName, NULL, NULL);
-		if(pTmpl == NULL) {
+		pTmpl = duplicate_template(Tmpl);
+		if(load_template(pTmpl) == NULL) {
 			StrBufAppendPrintf(
 				Target, 
 				"<pre>\nError loading Template [%s]\n See Logfile for details\n</pre>\n", 
 				ChrPtr(Tmpl->FileName));
+			FreeWCTemplate(pTmpl);
 			return NULL;
 		}
 
@@ -1995,6 +1715,24 @@ const StrBuf *DoTemplate(const char *templatename, long len, StrBuf *Target, WCT
 
 }
 
+
+void tmplput_Comment(StrBuf *Target, WCTemplputParams *TP)
+{
+	if (LoadTemplates != 0)
+	{
+		StrBuf *Comment;
+		const char *pch;
+		long len;
+
+		GetTemplateTokenString(Target, TP, 0, &pch, &len);
+		Comment = NewStrBufPlain(pch, len);
+		StrBufAppendBufPlain(Target, HKEY("<!--"), 0);
+		StrBufAppendTemplate(Target, TP, Comment, 1);
+		StrBufAppendBufPlain(Target, HKEY("-->"), 0);
+		FreeStrBuf(&Comment);
+	}
+}
+
 /*-----------------------------------------------------------------------------
  *                      Iterators
  */
@@ -2047,18 +1785,42 @@ int preeval_iterate(WCTemplateToken *Token)
 {
 	WCTemplputParams TPP;
 	WCTemplputParams *TP;
+	void *vTmpl;
 	void *vIt;
+	HashIterator *It;
 
 	memset(&TPP, 0, sizeof(WCTemplputParams));
 	TP = &TPP;
 	TP->Tokens = Token;
 	if (!GetHash(Iterators, TKEY(0), &vIt)) {
 		LogTemplateError(
-			NULL, "Iterator", ERR_NAME, TP,
+			NULL, "Iterator", ERR_PARM1, TP,
 			"not found");
 		return 0;
 	}
+	if (TP->Tokens->Params[1]->Type != TYPE_SUBTEMPLATE) {
+		LogTemplateError(NULL, "Iterator", ERR_PARM1, TP,
+				 "Need token with type Subtemplate as param 1, have %s", 
+				 TP->Tokens->Params[1]->Start);
+	}
+	
+	/* well, we don't check the mobile stuff here... */
+	if (!GetHash(LocalTemplateCache, TKEY(1), &vTmpl) &&
+	    !GetHash(TemplateCache, TKEY(1), &vTmpl)) {
+		LogTemplateError(NULL, "SubTemplate", ERR_PARM1, TP,
+				 "referenced here doesn't exist");
+	}
 	Token->Preeval2 = vIt;
+	It = (HashIterator *) vIt;
+
+	if (TP->Tokens->nParameters < It->AdditionalParams + 2) {
+		LogTemplateError(                               
+			NULL, "Iterator", ERR_PARM1, TP,
+			"doesn't work with %d params", 
+			TP->Tokens->nParameters);
+	}
+
+
 	return 1;
 }
 
@@ -2095,7 +1857,7 @@ void tmpl_iterate_subtmpl(StrBuf *Target, WCTemplputParams *TP)
 		LogTemplateError(                               
 			Target, "Iterator", ERR_PARM1, TP,
 			"doesn't work with %d params", 
-			TP->Tokens->nParameters);
+			TP->Tokens->nParameters - 1);
 		return;
 	}
 
@@ -2103,9 +1865,9 @@ void tmpl_iterate_subtmpl(StrBuf *Target, WCTemplputParams *TP)
 	    (It->XPectContextType != TP->Filter.ContextType)) {
 		LogTemplateError(
 			Target, "Iterator", ERR_PARM1, TP,
-			"requires context of type %d, have %d", 
-			It->XPectContextType, 
-			TP->Filter.ContextType);
+			"requires context of type %s, have %s", 
+			ContextName(It->XPectContextType), 
+			ContextName(TP->Filter.ContextType));
 		return ;
 		
 	}
@@ -2124,8 +1886,10 @@ 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");
 					if (SortOrder != 0)
@@ -2253,38 +2017,6 @@ int EvaluateConditional(StrBuf *Target, int Neg, int state, WCTemplputParams *TP
 	return 0;
 }
 
-int ConditionalVar(StrBuf *Target, WCTemplputParams *TP)
-{
-	void *vsubst;
-	wcsubst *subst;
-	
-	if (!GetHash(WC->vars, TKEY(2), &vsubst))
-		return 0;
-	subst = (wcsubst*) vsubst;
-	
-	switch(subst->wcs_type) {
-	case WCS_FUNCTION:
-		return (subst->wcs_function!=NULL);
-	case WCS_SERVCMD:
-		lprintf(1, "  -> Server [%s]\n", subst->wcs_value);/* TODO */
-		return 1;
-	case WCS_STRING:
-	case WCS_STRBUF:
-	case WCS_STRBUF_REF:
-		if (TP->Tokens->nParameters < 4)
-			return 1;
-		return (strcmp(TP->Tokens->Params[3]->Start, ChrPtr(subst->wcs_value)) == 0);
-	case WCS_LONG:
-		if (TP->Tokens->nParameters < 4)
-			return (subst->lvalue != 0);
-		return (subst->lvalue == TP->Tokens->Params[3]->lvalue);
-	default:
-		lprintf(1,"  WARNING: invalid type: [%ld]!\n", subst->wcs_type);
-		return -1;
-	}
-	return 0;
-}
-
 void RegisterConditional(const char *Name, long len, 
 			 int nParams,
 			 WCConditionalFunc CondF, 
@@ -2331,6 +2063,39 @@ void RegisterTokenParamDefine(const char *Name, long len,
 	Put(Defines, Name, len, PVal, NULL);
 }
 
+long GetTokenDefine(const char *Name, long len, 
+		    long DefValue)
+{
+	void *vPVal;
+
+	if (GetHash(Defines, Name, len, &vPVal) &&
+	     (vPVal != NULL))
+	 {
+		 return *(long*) vPVal;
+	 }
+	 else
+	 {
+		 return DefValue;
+	 }
+}
+
+void tmplput_DefStr(StrBuf *Target, WCTemplputParams *TP)
+{
+	const char *Str;
+	long len;
+	GetTemplateTokenString(Target, TP, 2, &Str, &len);
+	
+	StrBufAppendBufPlain(Target, Str, len, 0);
+}
+
+void tmplput_DefVal(StrBuf *Target, WCTemplputParams *TP)
+{
+	int val;
+
+	val = GetTemplateTokenNumber(Target, TP, 0, 0);
+	StrBufAppendPrintf(Target, "%d", val);
+}
+
 HashList *Defines;
 
 /*-----------------------------------------------------------------------------
@@ -2350,6 +2115,36 @@ int ConditionalContextStr(StrBuf *Target, WCTemplputParams *TP)
 	return strcmp(ChrPtr(TokenText), CompareToken) == 0;
 }
 
+void tmplput_ContextStringArray(StrBuf *Target, WCTemplputParams *TP)
+{
+	HashList *Arr = (HashList*) CTX;
+	void *pV;
+	int val;
+
+	val = GetTemplateTokenNumber(Target, TP, 0, 0);
+	if (GetHash(Arr, IKEY(val), &pV) && 
+	    (pV != NULL)) {
+		StrBufAppendTemplate(Target, TP, (StrBuf*)pV, 1);
+	}
+}
+int ConditionalContextStrinArray(StrBuf *Target, WCTemplputParams *TP)
+{
+	HashList *Arr = (HashList*) CTX;
+	void *pV;
+	int val;
+	const char *CompareToken;
+	long len;
+
+	GetTemplateTokenString(Target, TP, 2, &CompareToken, &len);
+	val = GetTemplateTokenNumber(Target, TP, 0, 0);
+	if (GetHash(Arr, IKEY(val), &pV) && 
+	    (pV != NULL)) {
+		return strcmp(ChrPtr((StrBuf*)pV), CompareToken) == 0;
+	}
+	else
+		return 0;
+}
+
 /*-----------------------------------------------------------------------------
  *                      Boxed-API
  */
@@ -2389,10 +2184,83 @@ void tmpl_do_boxed(StrBuf *Target, WCTemplputParams *TP)
  *                      Tabbed-API
  */
 
+typedef struct _tab_struct {
+	long CurrentTab;
+	StrBuf *TabTitle;
+} tab_struct;
+
+int preeval_do_tabbed(WCTemplateToken *Token)
+{
+	WCTemplputParams TPP;
+	WCTemplputParams *TP;
+	const char *Ch;
+	long len;
+	int i, nTabs;
+
+
+	memset(&TPP, 0, sizeof(WCTemplputParams));
+	TP = &TPP;
+	TP->Tokens = Token;
+	nTabs = TP->Tokens->nParameters / 2 - 1;
+	if (TP->Tokens->nParameters % 2 != 0)
+	{
+		LogTemplateError(NULL, "TabbedApi", ERR_PARM1, TP,
+				 "need even number of arguments");
+		return 0;
+
+	}
+	else for (i = 0; i < nTabs; i++) {
+		if (!HaveTemplateTokenString(NULL, 
+					     TP, 
+					     i * 2,
+					     &Ch,
+					     &len) || 
+		    (TP->Tokens->Params[i * 2]->len == 0))
+		{
+			LogTemplateError(NULL, "TabbedApi", ERR_PARM1, TP,
+					 "Tab-Subject %d needs to be able to produce a string, have %s", 
+					 i, TP->Tokens->Params[i * 2]->Start);
+			return 0;
+		}
+		if (!HaveTemplateTokenString(NULL, 
+					     TP, 
+					     i * 2 + 1,
+					     &Ch,
+					     &len) || 
+		    (TP->Tokens->Params[i * 2 + 1]->len == 0))
+		{
+			LogTemplateError(NULL, "TabbedApi", ERR_PARM1, TP,
+					 "Tab-Content %d needs to be able to produce a string, have %s", 
+					 i, TP->Tokens->Params[i * 2 + 1]->Start);
+			return 0;
+		}
+	}
+
+	if (!HaveTemplateTokenString(NULL, 
+				     TP, 
+				     i * 2 + 1,
+				     &Ch,
+				     &len) || 
+	    (TP->Tokens->Params[i * 2 + 1]->len == 0))
+	{
+		LogTemplateError(NULL, "TabbedApi", ERR_PARM1, TP,
+				 "Tab-Content %d needs to be able to produce a string, have %s", 
+				 i, TP->Tokens->Params[i * 2 + 1]->Start);
+		return 0;
+	}
+	return 1;
+}
+
+
 void tmpl_do_tabbed(StrBuf *Target, WCTemplputParams *TP)
 {
 	StrBuf **TabNames;
 	int i, ntabs, nTabs;
+	tab_struct TS;
+	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*));
@@ -2419,15 +2287,35 @@ 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++) {
-		StrBeginTab(Target, i, nTabs);
-		DoTemplate(TKEY(i * 2 + 1), Target, TP);
+		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]);
+}
+
+void tmplput_TAB_N(StrBuf *Target, WCTemplputParams *TP)
+{
+	tab_struct *Ctx = CCTX;
+
+	StrBufAppendPrintf(Target, "%d", Ctx->CurrentTab);
 }
 
+void tmplput_TAB_TITLE(StrBuf *Target, WCTemplputParams *TP)
+{
+	tab_struct *Ctx = CCTX;
+	StrBufAppendTemplate(Target, TP, Ctx->TabTitle, 0);
+}
 
 /*-----------------------------------------------------------------------------
  *                      Sorting-API
@@ -2798,18 +2686,27 @@ InitModule_SUBST
 (void)
 {
 	memset(&NoCtx, 0, sizeof(WCTemplputParams));
+	RegisterNamespace("--", 0, 2, tmplput_Comment, NULL, CTX_NONE);
 	RegisterNamespace("SORT:ICON", 1, 2, tmplput_SORT_ICON, NULL, CTX_NONE);
 	RegisterNamespace("SORT:ORDER", 1, 2, tmplput_SORT_ORDER, NULL, CTX_NONE);
 	RegisterNamespace("SORT:NEXT", 1, 2, tmplput_SORT_NEXT, NULL, CTX_NONE);
 	RegisterNamespace("CONTEXTSTR", 0, 1, tmplput_ContextString, NULL, CTX_STRBUF);
+	RegisterNamespace("CONTEXTSTRARR", 1, 2, tmplput_ContextStringArray, NULL, CTX_STRBUFARR);
 	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, 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("LONGVECTOR", 1, 1, tmplput_long_vector, NULL, CTX_LONGVECTOR);
-	RegisterConditional(HKEY("COND:SUBST"), 3, ConditionalVar, CTX_NONE);
+
+
 	RegisterConditional(HKEY("COND:CONTEXTSTR"), 3, ConditionalContextStr, CTX_STRBUF);
+	RegisterConditional(HKEY("COND:CONTEXTSTRARR"), 4, ConditionalContextStrinArray, CTX_STRBUFARR);
 	RegisterConditional(HKEY("COND:LONGVECTOR"), 4, ConditionalLongVector, CTX_LONGVECTOR);
 
+
 	RegisterControlConditional(HKEY("COND:ITERATE:ISGROUPCHANGE"), 2, 
 				   conditional_ITERATE_ISGROUPCHANGE, 
 				   CTX_ITERATE);
@@ -2824,6 +2721,10 @@ InitModule_SUBST
 	RegisterControlNS(HKEY("ITERATE:KEY"), 0, 0, tmplput_ITERATE_KEY, CTX_ITERATE);
 	RegisterControlNS(HKEY("ITERATE:N"), 0, 0, tmplput_ITERATE_LASTN, 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);
+
+
 
 
 }
@@ -2879,14 +2780,13 @@ void
 SessionAttachModule_SUBST
 (wcsession *sess)
 {
-	sess->vars = NewHash(1,NULL);
 }
 
 void
 SessionDetachModule_SUBST
 (wcsession *sess)
 {
-	DeleteHash(&sess->vars);
+	FreeStrBuf(&sess->WFBuf);
 }
 
 void