X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=webcit%2Fsubst.c;h=05f03c6b925d0bf658915418d88a16ef26cbe57b;hb=47bcaaabae789a2f20de958b84714ff2e23dc5bb;hp=690a21f7a8da58548b6b79125d73b0516027d3c6;hpb=efa5c510f812880225d8c7690a72233333504e88;p=citadel.git

diff --git a/webcit/subst.c b/webcit/subst.c
index 690a21f7a..05f03c6b9 100644
--- a/webcit/subst.c
+++ b/webcit/subst.c
@@ -29,7 +29,7 @@ HashList *LocalTemplateCache;
 
 HashList *GlobalNS;
 HashList *Iterators;
-HashList *Contitionals;
+HashList *Conditionals;
 
 int LoadTemplates = 0;
 
@@ -463,25 +463,116 @@ void pvo_do_cmd(StrBuf *Target, StrBuf *servcmd) {
 	}
 }
 
+
+/**
+ * \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?
+ */
+void StrBufAppendTemplate(StrBuf *Target, 
+			  int nArgs, 
+			  WCTemplateToken *Tokens,
+			  void *Context, int ContextType,
+			  const StrBuf *Source, int FormatTypeIndex)
+{
+        struct wcsession *WCC;
+	StrBuf *Buf;
+	char EscapeAs = ' ';
+
+	if ((FormatTypeIndex < Tokens->nParameters) &&
+	    (Tokens->Params[FormatTypeIndex]->Type == TYPE_STR) &&
+	    (Tokens->Params[FormatTypeIndex]->len == 1)) {
+		EscapeAs = *Tokens->Params[FormatTypeIndex]->Start;
+	}
+
+	switch(EscapeAs)
+	{
+	case 'H':
+		WCC = WC;
+		Buf = NewStrBufPlain(NULL, StrLength(Buf));
+		StrBuf_RFC822_to_Utf8(Buf, 
+				      Source, 
+				      (WCC!=NULL)? WCC->DefaultCharset : NULL, 
+				      NULL);
+		StrEscAppend(Target, Buf, NULL, 0, 0);
+		FreeStrBuf(&Buf);
+		break;
+	case 'X':
+		StrEscAppend(Target, Source, NULL, 0, 0);
+		break;
+	default:
+		StrBufAppendBuf(Target, Source, 0);
+	}
+}
+
+
+void GetTemplateTokenString(WCTemplateToken *Tokens,
+			    int N, 
+			    const char **Value, 
+			    long *len)
+{
+	StrBuf *Buf;
+
+	if (Tokens->nParameters < N) {
+		*Value = "";
+		*len = 0;
+		return;
+	}
+
+	switch (Tokens->Params[N]->Type) {
+
+	case TYPE_STR:
+		*Value = Tokens->Params[N]->Start;
+		*len = Tokens->Params[N]->len;
+		break;
+	case TYPE_BSTR:
+		Buf = (StrBuf*) SBstr(Tokens->Params[N]->Start, 
+				      Tokens->Params[N]->len);
+		*Value = ChrPtr(Buf);
+		*len = StrLength(Buf);
+		break;
+	case TYPE_PREFSTR:
+		get_PREFERENCE(
+			Tokens->Params[N]->Start, 
+			Tokens->Params[N]->len, 
+			&Buf);
+		*Value = ChrPtr(Buf);
+		*len = StrLength(Buf);
+		break;
+	case TYPE_LONG:
+	case TYPE_PREFINT:
+		break; ///todo: string to text?
+	case TYPE_GETTEXT:
+		*Value = _(Tokens->Params[N]->Start);
+		*len = strlen(*Value);
+		break;
+	default:
+		break;
+//todo log error
+	}
+}
+
+
+
 /**
  * \brief Print the value of a variable
  * \param keyname get a key to print
  */
-void print_value_of(StrBuf *Target, WCTemplateToken *Token, void *Context, int ContextType) {
+void print_value_of(StrBuf *Target, WCTemplateToken *Tokens, void *Context, int ContextType) {
 	struct wcsession *WCC = WC;
 	wcsubst *ptr;
 	void *vVar;
 
 	/*if (WCC->vars != NULL) PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/
 	/// TODO: debricated!
-	if (Token->pName[0] == '=') {
-		DoTemplate(Token->pName+1, Token->NameEnd - 1, NULL, NULL, 0);
+	if (Tokens->pName[0] == '=') {
+		DoTemplate(Tokens->pName+1, Tokens->NameEnd - 1, NULL, NULL, 0);
 	}
 
 //////TODO: if param[1] == "U" -> urlescape
 /// X -> escputs
 	/** Page-local variables */
-	if ((WCC->vars!= NULL) && GetHash(WCC->vars, Token->pName, Token->NameEnd, &vVar)) {
+	if ((WCC->vars!= NULL) && GetHash(WCC->vars, Tokens->pName, Tokens->NameEnd, &vVar)) {
 		ptr = (wcsubst*) vVar;
 		switch(ptr->wcs_type) {
 		case WCS_STRING:
@@ -491,7 +582,7 @@ void print_value_of(StrBuf *Target, WCTemplateToken *Token, void *Context, int C
 			pvo_do_cmd(Target, ptr->wcs_value);
 			break;
 		case WCS_FUNCTION:
-			(*ptr->wcs_function) (Target, Token->nParameters, Token, Context, ContextType);
+			(*ptr->wcs_function) (Target, Tokens->nParameters, Tokens, Context, ContextType);
 			break;
 		case WCS_STRBUF:
 		case WCS_STRBUF_REF:
@@ -501,18 +592,19 @@ void print_value_of(StrBuf *Target, WCTemplateToken *Token, void *Context, int C
 			StrBufAppendPrintf(Target, "%ld", ptr->lvalue);
 			break;
 		default:
-			lprintf(1,"WARNING: invalid value in SV-Hash at %s!\n", Token->pName);
-			StrBufAppendPrintf(Target, "<pre>WARNING: \ninvalid value in SV-Hash at %s!\n</pre>", Token->pName);
+			lprintf(1,"WARNING: invalid value in SV-Hash at %s!\n", Tokens->pName);
+			StrBufAppendPrintf(Target, "<pre>WARNING: \ninvalid value in SV-Hash at %s!\n</pre>", Tokens->pName);
 		}
 	}
-	else
+	else {
 		lprintf(1, "didn't find Handler [%s] (in '%s' line %ld); "
 			" [%s]\n", 
-			Token->pName,
-			ChrPtr(Token->FileName),
-			Token->Line,
-			ChrPtr(Token->FlatToken));
-
+			Tokens->pName,
+			ChrPtr(Tokens->FileName),
+			Tokens->Line,
+			ChrPtr(Tokens->FlatToken));
+		wc_backtrace();
+	}
 }
 
 int CompareSubstToToken(TemplateParam *ParamToCompare, TemplateParam *ParamToLookup)
@@ -607,18 +699,40 @@ void PutNewToken(WCTemplate *Template, WCTemplateToken *NewToken)
 	Template->Tokens[(Template->nTokensUsed)++] = NewToken;
 }
 
-TemplateParam *GetNextParameter(StrBuf *Buf, const char **pCh, const char *pe, WCTemplateToken *Token, WCTemplate *pTmpl)
+TemplateParam *GetNextParameter(StrBuf *Buf, const char **pCh, const char *pe, WCTemplateToken *Tokens, WCTemplate *pTmpl)
 {
 	const char *pch = *pCh;
 	const char *pchs, *pche;
 	TemplateParam *Parm = (TemplateParam *) malloc(sizeof(TemplateParam));
 	char quote = '\0';
 	
+
+	Parm->Type = TYPE_STR;
+
 	/* Skip leading whitespaces */
 	while ((*pch == ' ' )||
 	       (*pch == '\t')||
 	       (*pch == '\r')||
 	       (*pch == '\n')) pch ++;
+
+	if (*pch == ':') {
+		Parm->Type = TYPE_PREFSTR;
+		pch ++;
+	}
+	else if (*pch == ';') {
+		Parm->Type = TYPE_PREFINT;
+		pch ++;
+	}
+	else if (*pch == '_') {
+		Parm->Type = TYPE_GETTEXT;
+		pch ++;
+	}
+	else if (*pch == 'B') {
+		Parm->Type = TYPE_BSTR;
+		pch ++;
+	}
+
+
 	if (*pch == '"')
 		quote = '"';
 	else if (*pch == '\'')
@@ -626,7 +740,6 @@ TemplateParam *GetNextParameter(StrBuf *Buf, const char **pCh, const char *pe, W
 	if (quote != '\0') {
 		pch ++;
 		pchs = pch;
-		Parm->Type = TYPE_STR;
 		while (pch <= pe &&
 		       ((*pch != quote) ||
 			( (pch > pchs) && (*(pch - 1) == '\\'))
@@ -638,8 +751,8 @@ TemplateParam *GetNextParameter(StrBuf *Buf, const char **pCh, const char *pe, W
 			lprintf(1, "Error (in '%s' line %ld); "
 				"evaluating template param [%s] in Token [%s]\n",
 				ChrPtr(pTmpl->FileName),
-				Token->Line,
-				ChrPtr(Token->FlatToken),
+				Tokens->Line,
+				ChrPtr(Tokens->FlatToken),
 				*pCh);
 			pch ++;
 			free(Parm);
@@ -676,8 +789,8 @@ TemplateParam *GetNextParameter(StrBuf *Buf, const char **pCh, const char *pe, W
 			lprintf(1, "Error (in '%s' line %ld); "
 				"evaluating long template param [%s] in Token [%s]\n",
 				ChrPtr(pTmpl->FileName),
-				Token->Line,
-				ChrPtr(Token->FlatToken),
+				Tokens->Line,
+				ChrPtr(Tokens->FlatToken),
 				*pCh);
 			free(Parm);
 			return NULL;
@@ -700,6 +813,7 @@ WCTemplateToken *NewTemplateSubstitute(StrBuf *Buf,
 				       long Line,
 				       WCTemplate *pTmpl)
 {
+	void *vVar;
 	const char *pch;
 	TemplateParam *Param;
 	WCTemplateToken *NewToken = (WCTemplateToken*)malloc(sizeof(WCTemplateToken));
@@ -727,6 +841,13 @@ WCTemplateToken *NewTemplateSubstitute(StrBuf *Buf,
 			StrBufPeek(Buf, pch, -1, '\0');
 			NewToken->NameEnd = pch - NewToken->pName;
 			pch ++;
+			if (*(pTmplEnd - 1) != ')') {
+				lprintf(1, "Warning, Non welformed Token; missing right parenthesis (in '%s' line %ld); "
+					"[%s]\n", 
+					ChrPtr(pTmpl->FileName),
+					NewToken->Line,
+					ChrPtr(NewToken->FlatToken));
+			}
 			while (pch < pTmplEnd - 1) {
 				Param = GetNextParameter(Buf, &pch, pTmplEnd - 1, NewToken, pTmpl);
 				if (Param != NULL) {
@@ -750,29 +871,24 @@ WCTemplateToken *NewTemplateSubstitute(StrBuf *Buf,
 			   (NewToken->HaveParameters == 1))
 			   
 			{
-				if ((NewToken->nParameters == 1) &&
-				    (*(NewToken->pName) == '_'))
+				if (*(NewToken->pName) == '_')
 					NewToken->Flags = SV_GETTEXT;
-				else if ((NewToken->nParameters == 1) &&
-					 (*(NewToken->pName) == '='))
+				else if (*(NewToken->pName) == '=')
 					NewToken->Flags = SV_SUBTEMPL;
-				else if ((NewToken->nParameters >= 2) &&
-					 (*(NewToken->pName) == '%'))
+				else if (*(NewToken->pName) == '%')
 					NewToken->Flags = SV_CUST_STR_CONDITIONAL;
-				else if ((NewToken->nParameters >= 2) &&
-					 (*(NewToken->pName) == '?'))
+				else if (*(NewToken->pName) == '?')
 					NewToken->Flags = SV_CONDITIONAL;
-				else if ((NewToken->nParameters >=2) &&
-					 (*(NewToken->pName) == '!'))
+				else if (*(NewToken->pName) == '!')
 					NewToken->Flags = SV_NEG_CONDITIONAL;
 			}
 		}
 		else pch ++;		
 	}
 	
-	if (NewToken->Flags == 0) {
+	switch (NewToken->Flags) {
+	case 0:
 		/* If we're able to find out more about the token, do it now while its fresh. */
-		void *vVar;
 		if (GetHash(GlobalNS, NewToken->pName, NewToken->NameEnd, &vVar)) {
 			HashHandler *Handler;
 			Handler = (HashHandler*) vVar;
@@ -790,188 +906,262 @@ WCTemplateToken *NewTemplateSubstitute(StrBuf *Buf,
 				NewToken->PreEval = Handler;
 				NewToken->Flags = SV_PREEVALUATED;		
 			}
-		}		
+		}
+		break;
+	case SV_GETTEXT:
+		if (NewToken->nParameters !=1) {
+			lprintf(1, "Gettext (in '%s' line %ld); "
+				"requires exactly 1 parameter, you gave %ld params [%s]\n", 
+				ChrPtr(pTmpl->FileName),
+				NewToken->Line,
+				NewToken->nParameters, 
+				ChrPtr(NewToken->FlatToken));
+			NewToken->Flags = 0;
+			break;
+		}
+		break;
+	case SV_SUBTEMPL:
+		if (NewToken->nParameters != 1) {
+			lprintf(1, "Subtemplates (in '%s' line %ld); "
+				"require exactly 1 parameter, you gave %ld params [%s]\n", 
+				ChrPtr(pTmpl->FileName),
+				NewToken->Line,
+				NewToken->nParameters, 
+				ChrPtr(NewToken->FlatToken));
+			break;
+		}
+		break;
+	case SV_CUST_STR_CONDITIONAL:
+	case SV_CONDITIONAL:
+	case SV_NEG_CONDITIONAL:
+		if (NewToken->nParameters <2) {
+			lprintf(1, "Conditional (in '%s' line %ld); "
+				"require at least 2 parameters, you gave %ld params [%s]\n", 
+				ChrPtr(pTmpl->FileName),
+				NewToken->Line,
+				NewToken->nParameters, 
+				ChrPtr(NewToken->FlatToken));
+			NewToken->Flags = 0;
+			break;
+		}
+		if (!GetHash(Conditionals, 
+			     NewToken->Params[0]->Start,
+			     NewToken->Params[0]->len,
+			     &vVar) || 
+		    (vVar == NULL)) {
+			if ((NewToken->Params[0]->len == 1) &&
+			    (NewToken->Params[0]->Start[0] == 'X'))
+				break;
+			lprintf(1, "Conditional [%s] (in '%s' line %ld); Not found![%s]\n", 
+				NewToken->Params[0]->Start,
+				ChrPtr(pTmpl->FileName),
+				NewToken->Line,
+				ChrPtr(NewToken->FlatToken));
+/*
+			NewToken->Error = NewStrBuf();
+			StrBufAppendPrintf(
+				NewToken->Error, 
+				"<pre>\nConditional [%s] (in '%s' line %ld); Not found!\n[%s]\n</pre>\n", 
+				NewToken->Params[0]->Start,
+				ChrPtr(pTmpl->FileName),
+				NewToken->Line,
+				ChrPtr(NewToken->FlatToken));
+*/
+		}
+		else {
+			NewToken->PreEval = vVar;
+		}
+		break;
 	}
-
 	return NewToken;
 }
 
 
 
-int EvaluateConditional(StrBuf *Target, WCTemplateToken *Token, WCTemplate *pTmpl, void *Context, int Neg, int state, int ContextType)
+int EvaluateConditional(StrBuf *Target, WCTemplateToken *Tokens, WCTemplate *pTmpl, void *Context, int Neg, int state, int ContextType)
 {
-	void *vConditional = NULL;
 	ConditionalStruct *Cond;
 
-	if ((Token->Params[0]->len == 1) &&
-	    (Token->Params[0]->Start[0] == 'X'))
-		return (state != 0)?Token->Params[1]->lvalue:0;
-
-	if (!GetHash(Contitionals, 
-		 Token->Params[0]->Start,
-		 Token->Params[0]->len,
-		 &vConditional) || 
-	    (vConditional == NULL)) {
-		lprintf(1, "Conditional [%s] (in '%s' line %ld); Not found![%s]\n", 
-			Token->Params[0]->Start,
-			ChrPtr(pTmpl->FileName),
-			Token->Line,
-			ChrPtr(Token->FlatToken));
-		StrBufAppendPrintf(
-			Target, 
-			"<pre>\nConditional [%s] (in '%s' line %ld); Not found!\n[%s]\n</pre>\n", 
-			Token->Params[0]->Start,
+	if ((Tokens->Params[0]->len == 1) &&
+	    (Tokens->Params[0]->Start[0] == 'X'))
+		return (state != 0)?Tokens->Params[1]->lvalue:0;
+	    
+	Cond = (ConditionalStruct *) Tokens->PreEval;
+	if (Cond == NULL) {
+		lprintf(1, "Conditional [%s] (in '%s' line %ld); unknown![%s]\n", 
+			Tokens->Params[0]->Start,
 			ChrPtr(pTmpl->FileName),
-			Token->Line,
-			ChrPtr(Token->FlatToken));
-		return 0;
+			Tokens->Line,
+			ChrPtr(Tokens->FlatToken));
+		return 1;
 	}
-	    
-	Cond = (ConditionalStruct *) vConditional;
 
-	if (Token->nParameters < Cond->nParams) {
+	if (Tokens->nParameters < Cond->nParams) {
 		lprintf(1, "Conditional [%s] (in '%s' line %ld); needs %ld Params![%s]\n", 
-			Token->Params[0]->Start,
+			Tokens->Params[0]->Start,
 			ChrPtr(pTmpl->FileName),
-			Token->Line,
+			Tokens->Line,
 			Cond->nParams,
-			ChrPtr(Token->FlatToken));
+			ChrPtr(Tokens->FlatToken));
 		StrBufAppendPrintf(
 			Target, 
 			"<pre>\nConditional [%s] (in '%s' line %ld); needs %ld Params!\n[%s]\n</pre>\n", 
-			Token->Params[0]->Start,
+			Tokens->Params[0]->Start,
 			ChrPtr(pTmpl->FileName),
-			Token->Line,
+			Tokens->Line,
 			Cond->nParams,
-			ChrPtr(Token->FlatToken));
+			ChrPtr(Tokens->FlatToken));
 		return 0;
 	}
-	if (Cond->CondF(Token, Context, ContextType) == Neg)
-		return Token->Params[1]->lvalue;
+	if (Cond->CondF(Tokens, Context, ContextType) == Neg)
+		return Tokens->Params[1]->lvalue;
 	return 0;
 }
 
-int EvaluateToken(StrBuf *Target, WCTemplateToken *Token, WCTemplate *pTmpl, void *Context, int state, int ContextType)
+/**
+ * \brief executes one token
+ * \param Target buffer to append to
+ * \param Token da to  process.
+ * \param Template we're iterating
+ * \param Context Contextpoointer to pass in
+ * \param state are we in conditional state?
+ * \param ContextType what type of information does context giv us?
+ */
+int EvaluateToken(StrBuf *Target, WCTemplateToken *Tokens, WCTemplate *pTmpl, void *Context, int state, int ContextType)
 {
 	HashHandler *Handler;
 	void *vVar;
 // much output, since pName is not terminated...
 //	lprintf(1,"Doing token: %s\n",Token->pName);
 
-	switch (Token->Flags) {
+	switch (Tokens->Flags) {
 	case SV_GETTEXT:
-		TmplGettext(Target, Token->nParameters, Token);
+		TmplGettext(Target, Tokens->nParameters, Tokens);
 		break;
 	case SV_CONDITIONAL: /** Forward conditional evaluation */
-		return EvaluateConditional(Target, Token, pTmpl, Context, 1, state, ContextType);
+		return EvaluateConditional(Target, Tokens, pTmpl, Context, 1, state, ContextType);
 		break;
 	case SV_NEG_CONDITIONAL: /** Reverse conditional evaluation */
-		return EvaluateConditional(Target, Token, pTmpl, Context, 0, state, ContextType);
+		return EvaluateConditional(Target, Tokens, pTmpl, Context, 0, state, ContextType);
 		break;
 	case SV_CUST_STR_CONDITIONAL: /** Conditional put custom strings from params */
-		if (Token->nParameters >= 6) {
-			if (EvaluateConditional(Target, Token, pTmpl, Context, 0, state, ContextType))
+		if (Tokens->nParameters >= 6) {
+			if (EvaluateConditional(Target, Tokens, pTmpl, Context, 0, state, ContextType))
 				StrBufAppendBufPlain(Target, 
-						     Token->Params[5]->Start,
-						     Token->Params[5]->len,
+						     Tokens->Params[5]->Start,
+						     Tokens->Params[5]->len,
 						     0);
 			else
 				StrBufAppendBufPlain(Target, 
-						     Token->Params[4]->Start,
-						     Token->Params[4]->len,
+						     Tokens->Params[4]->Start,
+						     Tokens->Params[4]->len,
 						     0);
 		}
+		else  {
+			lprintf(1, "Conditional [%s] (in '%s' line %ld); needs at least 6 Params![%s]\n", 
+				Tokens->Params[0]->Start,
+				ChrPtr(pTmpl->FileName),
+				Tokens->Line,
+				ChrPtr(Tokens->FlatToken));
+			StrBufAppendPrintf(
+				Target, 
+				"<pre>\nConditional [%s] (in '%s' line %ld); needs 6 Params!\n[%s]\n</pre>\n", 
+				Tokens->Params[0]->Start,
+				ChrPtr(pTmpl->FileName),
+				Tokens->Line,
+				ChrPtr(Tokens->FlatToken));
+		}
 		break;
 	case SV_SUBTEMPL:
-		if (Token->nParameters == 1)
-			DoTemplate(Token->Params[0]->Start, Token->Params[0]->len, NULL, NULL, ContextType);
+		if (Tokens->nParameters == 1)
+			DoTemplate(Tokens->Params[0]->Start, Tokens->Params[0]->len, NULL, NULL, ContextType);
 		break;
 	case SV_PREEVALUATED:
-		Handler = (HashHandler*) Token->PreEval;
+		Handler = (HashHandler*) Tokens->PreEval;
 		if ((Handler->ContextRequired != CTX_NONE) &&
 		    (Handler->ContextRequired != ContextType)) {
 			lprintf(1, "Handler [%s] (in '%s' line %ld); "
 				"requires context of type %ld, have %ld [%s]\n", 
-				Token->pName,
+				Tokens->pName,
 				ChrPtr(pTmpl->FileName),
-				Token->Line,
+				Tokens->Line,
 				Handler->ContextRequired, 
 				ContextType,
-				ChrPtr(Token->FlatToken));
+				ChrPtr(Tokens->FlatToken));
 			StrBufAppendPrintf(
 				Target, 
 				"<pre>\nHandler [%s] (in '%s' line %ld);"
 				" requires context of type %ld, have %ld!\n[%s]\n</pre>\n", 
-				Token->pName,
+				Tokens->pName,
 				ChrPtr(pTmpl->FileName),
-				Token->Line,
+				Tokens->Line,
 				Handler->ContextRequired, 
 				ContextType,
-				ChrPtr(Token->FlatToken));
+				ChrPtr(Tokens->FlatToken));
 			return -1;
 
 		}
 		Handler->HandlerFunc(Target, 
-				     Token->nParameters,
-				     Token,
+				     Tokens->nParameters,
+				     Tokens,
 				     Context, 
 				     ContextType); 
 		break;		
 	default:
-		if (GetHash(GlobalNS, Token->pName, Token->NameEnd, &vVar)) {
+		if (GetHash(GlobalNS, Tokens->pName, Tokens->NameEnd, &vVar)) {
 			Handler = (HashHandler*) vVar;
 			if ((Handler->ContextRequired != CTX_NONE) &&
 			    (Handler->ContextRequired != ContextType)) {
 				lprintf(1, "Handler [%s] (in '%s' line %ld); "
 					"requires context of type %ld, have %ld [%s]\n", 
-					Token->pName,
+					Tokens->pName,
 					ChrPtr(pTmpl->FileName),
-					Token->Line,
+					Tokens->Line,
 					Handler->ContextRequired, 
 					ContextType,
-					ChrPtr(Token->FlatToken));
+					ChrPtr(Tokens->FlatToken));
 				StrBufAppendPrintf(
 					Target, 
 					"<pre>\nHandler [%s] (in '%s' line %ld);"
 					" requires context of type %ld, have %ld!\n[%s]\n</pre>\n", 
-					Token->pName,
+					Tokens->pName,
 					ChrPtr(pTmpl->FileName),
-					Token->Line,
+					Tokens->Line,
 					Handler->ContextRequired, 
 					ContextType,
-					ChrPtr(Token->FlatToken));
+					ChrPtr(Tokens->FlatToken));
 				return -1;
 			}
-			else if ((Token->nParameters < Handler->nMinArgs) || 
-				 (Token->nParameters > Handler->nMaxArgs)) {
+			else if ((Tokens->nParameters < Handler->nMinArgs) || 
+				 (Tokens->nParameters > Handler->nMaxArgs)) {
 				lprintf(1, "Handler [%s] (in '%s' line %ld); "
 					"doesn't work with %ld params [%s]\n", 
-					Token->pName,
+					Tokens->pName,
 					ChrPtr(pTmpl->FileName),
-					Token->Line,
-					Token->nParameters, 
-					ChrPtr(Token->FlatToken));
+					Tokens->Line,
+					Tokens->nParameters, 
+					ChrPtr(Tokens->FlatToken));
 				StrBufAppendPrintf(
 					Target, 
 					"<pre>\nHandler [%s] (in '%s' line %ld);"
 					" doesn't work with %ld params!\n[%s]\n</pre>\n", 
-					Token->pName,
+					Tokens->pName,
 					ChrPtr(pTmpl->FileName),
-					Token->Line,
-					Token->nParameters,
-					ChrPtr(Token->FlatToken));
+					Tokens->Line,
+					Tokens->nParameters,
+					ChrPtr(Tokens->FlatToken));
 			}
 			else {
 				Handler->HandlerFunc(Target, 
-						     Token->nParameters,
-						     Token,
+						     Tokens->nParameters,
+						     Tokens,
 						     Context, 
 						     ContextType); /*TODO: subset of that */
 				
 			}
 		}
 		else {
-			print_value_of(Target, Token, Context, ContextType);
+			print_value_of(Target, Tokens, Context, ContextType);
 		}
 	}
 	return 0;
@@ -989,6 +1179,7 @@ void ProcessTemplate(WCTemplate *Tmpl, StrBuf *Target, void *Context, int Contex
 		if (LoadTemplates > 1)
 			lprintf(1, "DBG: ----- loading:  [%s] ------ \n", 
 				ChrPtr(Tmpl->FileName));
+
 		pTmpl = load_template(Tmpl->FileName, NULL, NULL);
 		if(pTmpl == NULL) {
 			StrBufAppendPrintf(
@@ -1245,8 +1436,8 @@ int LoadTemplateDir(const char *DirName, HashList *wireless, HashList *big)
 			*MinorPtr = '\0';
 		StrBufPlain(Tag, filedir_entry->d_name, MinorPtr - filedir_entry->d_name);
 
-
-		lprintf(1, "%s %d %s\n",ChrPtr(FileName), IsMobile, ChrPtr(Tag));
+		if (LoadTemplates > 1)
+			lprintf(1, "%s %d %s\n",ChrPtr(FileName), IsMobile, ChrPtr(Tag));
 		if (LoadTemplates == 0)
 			load_template(FileName, Tag, (IsMobile)?wireless:big);
 		else
@@ -1269,52 +1460,6 @@ void InitTemplateCache(void)
 			LocalTemplateCache);
 }
 
-void tmplput_serv_ip(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void *Context, int ContextType)
-{
-	StrBufAppendPrintf(Target, "%d", WC->ctdl_pid);
-}
-
-void tmplput_serv_nodename(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void *Context, int ContextType)
-{
-	StrEscAppend(Target, NULL, serv_info.serv_nodename, 0, 0);
-}
-
-void tmplput_serv_humannode(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void *Context, int ContextType)
-{
-	StrEscAppend(Target, NULL, serv_info.serv_humannode, 0, 0);
-}
-
-void tmplput_serv_fqdn(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void *Context, int ContextType)
-{
-	StrEscAppend(Target, NULL, serv_info.serv_fqdn, 0, 0);
-}
-
-void tmmplput_serv_software(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void *Context, int ContextType)
-{
-	StrEscAppend(Target, NULL, serv_info.serv_software, 0, 0);
-}
-
-void tmplput_serv_rev_level(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void *Context, int ContextType)
-{
-	StrBufAppendPrintf(Target, "%d.%02d",
-			    serv_info.serv_rev_level / 100,
-			    serv_info.serv_rev_level % 100);
-}
-
-void tmmplput_serv_bbs_city(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void *Context, int ContextType)
-{
-	StrEscAppend(Target, NULL, serv_info.serv_bbs_city, 0, 0);
-}
-
-void tmplput_current_user(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void *Context, int ContextType)
-{
-	StrEscAppend(Target, NULL, WC->wc_fullname, 0, 0);
-}
-
-void tmplput_current_room(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void *Context, int ContextType)
-{
-	StrEscAppend(Target, NULL, WC->wc_roomname, 0, 0);
-}
 
 
 typedef struct _HashIterator {
@@ -1504,25 +1649,53 @@ void RegisterConditional(const char *Name, long len,
 			 int ContextRequired)
 {
 	ConditionalStruct *Cond = (ConditionalStruct*)malloc(sizeof(ConditionalStruct));
+	Cond->PlainName = Name;
 	Cond->nParams = nParams;
 	Cond->CondF = CondF;
 	Cond->ContextRequired = ContextRequired;
-	Put(Contitionals, Name, len, Cond, NULL);
+	Put(Conditionals, Name, len, Cond, NULL);
+}
+
+
+void tmplput_ContextString(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void *Context, int ContextType)
+{
+	StrBufAppendTemplate(Target, nArgs, Tokens, Context, ContextType, (StrBuf*)Context, 0);
+}
+int ConditionalContextStr(WCTemplateToken *Tokens, void *Context, int ContextType)
+{
+	StrBuf *TokenText = (StrBuf*) Context;
+	const char *CompareToken;
+	long len;
+
+	GetTemplateTokenString(Tokens, 2, &CompareToken, &len);
+	return strcmp(ChrPtr(TokenText), CompareToken) == 0;
 }
 
+
 void tmpl_do_boxed(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void *Context, int ContextType)
 {
+	StrBuf *Headline;
 	if (nArgs == 2) {
-		StrBuf *Headline = NewStrBuf();
-		DoTemplate(Tokens->Params[1]->Start, 
-			   Tokens->Params[1]->len,
-			   Headline, 
-			   Context, 
-			   ContextType);
-		SVPutBuf("BOXTITLE", Headline, 0);
+		if (Tokens->Params[1]->Type == TYPE_STR) {
+			Headline = NewStrBuf();
+			DoTemplate(Tokens->Params[1]->Start, 
+				   Tokens->Params[1]->len,
+				   Headline, 
+				   Context, 
+				   ContextType);
+		}
+		else {
+			const char *Ch;
+			long len;
+			GetTemplateTokenString(Tokens, 
+					       1,
+					       &Ch,
+					       &len);
+			Headline = NewStrBufPlain(Ch, len);
+		}
 	}
 	
-	DoTemplate(HKEY("beginbox"), Target, Context, ContextType);
+	DoTemplate(HKEY("beginbox"), Target, Headline, CTX_STRBUF);
 	DoTemplate(Tokens->Params[0]->Start, 
 		   Tokens->Params[0]->len,
 		   Target, 
@@ -1531,6 +1704,7 @@ void tmpl_do_boxed(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void *Con
 	DoTemplate(HKEY("endbox"), Target, Context, ContextType);
 }
 
+
 void tmpl_do_tabbed(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void *Context, int ContextType)
 {
 	StrBuf **TabNames;
@@ -1571,20 +1745,12 @@ void
 InitModule_SUBST
 (void)
 {
-	RegisterNamespace("SERV:PID", 0, 0, tmplput_serv_ip, CTX_NONE);
-	RegisterNamespace("SERV:NODENAME", 0, 0, tmplput_serv_nodename, CTX_NONE);
-	RegisterNamespace("SERV:HUMANNODE", 0, 0, tmplput_serv_humannode, CTX_NONE);
-	RegisterNamespace("SERV:FQDN", 0, 0, tmplput_serv_fqdn, CTX_NONE);
-	RegisterNamespace("SERV:SOFTWARE", 0, 0, tmmplput_serv_software, CTX_NONE);
-	RegisterNamespace("SERV:REV_LEVEL", 0, 0, tmplput_serv_rev_level, CTX_NONE);
-	RegisterNamespace("SERV:BBS_CITY", 0, 0, tmmplput_serv_bbs_city, CTX_NONE);
-///	RegisterNamespace("SERV:LDAP_SUPP", 0, 0, tmmplput_serv_ldap_enabled, 0);
-	RegisterNamespace("CURRENT_USER", 0, 0, tmplput_current_user, CTX_NONE);
-	RegisterNamespace("CURRENT_ROOM", 0, 0, tmplput_current_room, CTX_NONE);
+	RegisterNamespace("CONTEXTSTR", 0, 1, tmplput_ContextString, CTX_STRBUF);
 	RegisterNamespace("ITERATE", 2, 100, tmpl_iterate_subtmpl, CTX_NONE);
 	RegisterNamespace("DOBOXED", 1, 2, tmpl_do_boxed, CTX_NONE);
 	RegisterNamespace("DOTABBED", 2, 100, tmpl_do_tabbed, CTX_NONE);
 	RegisterConditional(HKEY("COND:SUBST"), 3, ConditionalVar, CTX_NONE);
+	RegisterConditional(HKEY("COND:CONTEXTSTR"), 3, ConditionalContextStr, CTX_STRBUF);
 }
 
 /*@}*/