"Context MIME_ATACH",
"Context FILELIST",
"Context STRBUF",
+ "Context STRBUFARR",
"Context LONGVECTOR",
"Context ROOMS",
"Context FLOORS",
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;
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)
return;
}
- Header = NewStrBuf();
+ if (WCC->WFBuf == NULL) WCC->WFBuf = NewStrBuf();
if (TP->Tokens != NULL)
{
/* deprecated:
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);
Error,
eERROR), 1);
*/
- WildFireSerializePayload(Header, WCC->HBuf, &WCC->Hdr->nWildfireHeaders, NULL);
+
}
else
{
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);
/*
void LogError (StrBuf *Target, const char *Type, const char *Format, ...)
{
wcsession *WCC;
- StrBuf *Header;
StrBuf *Error;
StrBuf *Info;
va_list arg_ptr;
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);
/*
clear_substs (WC);
}
-int NeedNewBuf(type)
+int NeedNewBuf(int type)
{
switch(type) {
case WCS_STRING:
}
}
+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,
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;
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;
*pCh);
pch ++;
free(Parm);
- return NULL;
+ *pParm = NULL;
+ return 0;
}
else {
StrBufPeek(Buf, pch, -1, '\0');
*pCh);
*/
free(Parm);
- return NULL;
+ *pParm = NULL;
+ return 0;
}
}
while ((*pch == ' ' )||
}
else
{
- LogTemplateError(NULL, "Define", ERR_PARM1, TP,
+ LogTemplateError(NULL, "Define",
+ Tokens->nParameters,
+ TP,
"%s isn't known!!",
Parm->Start);
}}
/* 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", ERR_PARM1, TP,
- "referenced here doesn't exist");
+ LogTemplateError(NULL,
+ "SubTemplate",
+ Tokens->nParameters,
+ TP,
+ "referenced here doesn't exist");
}}
break;
}
*pCh = pch;
- return Parm;
+ return 1;
}
WCTemplateToken *NewTemplateSubstitute(StrBuf *Buf,
{
void *vVar;
const char *pch;
- TemplateParam *Param;
WCTemplateToken *NewToken;
WCTemplputParams TP;
"Warning, Non welformed Token; missing right parenthesis");
}
while (pch < pTokenEnd - 1) {
- Param = GetNextParameter(Buf, &pch, pTokenEnd - 1, NewToken, pTmpl, &TP);
- if (Param != NULL) {
+ NewToken->nParameters++;
+ if (GetNextParameter(Buf,
+ &pch,
+ pTokenEnd - 1,
+ NewToken,
+ pTmpl,
+ &TP,
+ &NewToken->Params[NewToken->nParameters - 1]))
+ {
NewToken->HaveParameters = 1;
if (NewToken->nParameters > MAXPARAM) {
LogTemplateError(
"only [%d] Params allowed in Tokens",
MAXPARAM);
- free(Param);
FreeToken(&NewToken);
return NULL;
}
- NewToken->Params[NewToken->nParameters++] = Param;
}
else break;
}
WCTemplputParams *TP;
void *vTmpl;
void *vIt;
+ HashIterator *It;
memset(&TPP, 0, sizeof(WCTemplputParams));
TP = &TPP;
"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 - 1);
+ }
+
+
return 1;
}
return;
}
- if (TP->Tokens->nParameters < It->AdditionalParams + 2) {
+ if (TP->Tokens->nParameters <= It->AdditionalParams + 2) {
LogTemplateError(
Target, "Iterator", ERR_PARM1, TP,
"doesn't work with %d params",
- TP->Tokens->nParameters);
+ TP->Tokens->nParameters - 1);
return;
}
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;
/*-----------------------------------------------------------------------------
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
*/
/*-----------------------------------------------------------------------------
* Tabbed-API
*/
+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)
{
DoTemplate(TKEY(i * 2 + 1), Target, TP);
StrEndTab(Target, i, nTabs);
}
+ for (i = 0; i < ntabs; i++)
+ FreeStrBuf(&TabNames[i]);
}
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_STRBUF);
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);
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,
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);
+
+
}
(wcsession *sess)
{
DeleteHash(&sess->vars);
+ FreeStrBuf(&sess->WFBuf);
}
void