X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=webcit%2Fsubst.c;h=b54e921ee9946b3c1c738ad9576f96dd26bb83ab;hb=HEAD;hp=a4d8d2aaf06d490e9f835c5e288fb3e36e5e4c87;hpb=e3fa51f18bc8922c12161cdccba6e6b2a84c3a27;p=citadel.git diff --git a/webcit/subst.c b/webcit/subst.c index a4d8d2aaf..f6725cd58 100644 --- a/webcit/subst.c +++ b/webcit/subst.c @@ -1,14 +1,12 @@ -/* - * $Id$ - */ -#include "sysdep.h" - +// This is a template substitution engine, which began with good intentions, but ended up becoming +// more complex and unmaintainable than what it replaced. We are barely hanging on with this until +// webcit-ng replaces webcit classic. +#include "sysdep.h" #include #include #include #include - #include #include #include @@ -17,12 +15,10 @@ #define SHOW_ME_VAPPEND_PRINTF #include "webcit.h" -#include "webserver.h" + extern char *static_dirs[PATH_MAX]; /* Disk representation */ -HashList *WirelessTemplateCache; -HashList *WirelessLocalTemplateCache; HashList *TemplateCache; HashList *LocalTemplateCache; @@ -34,7 +30,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; @@ -48,6 +44,7 @@ const char EmptyStr[]=""; #define SV_PREEVALUATED 6 + /* * Dynamic content for variable substitution in templates */ @@ -76,8 +73,13 @@ typedef struct _HashHandler { WCHandlerFunc HandlerFunc; }HashHandler; -void *load_template(StrBuf *filename, StrBuf *Key, HashList *PutThere); -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,33 +90,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 LONGVECTOR", - "Context ROOMS", - "Context FLOORS", - "Context ITERATE", - "Context ICAL", - "Context DavNamespace", - "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) { @@ -124,18 +217,9 @@ 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, ...) { - wcsession *WCC; - StrBuf *Header; StrBuf *Error; StrBuf *Info; va_list arg_ptr; @@ -149,49 +233,38 @@ 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) { - 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) { + if (WC == NULL) { FreeStrBuf(&Info); FreeStrBuf(&Error); return; } - Header = NewStrBuf(); + if (WC->WFBuf == NULL) WC->WFBuf = NewStrBuf(); if (TP->Tokens != NULL) { /* deprecated: @@ -212,51 +285,25 @@ void LogTemplateError (StrBuf *Target, const char *Type, int ErrorPos, WCTemplpu ChrPtr(TP->Tokens->FlatToken)); - SerializeJson(Header, WildFireException(SKEY(TP->Tokens->FileName), + SerializeJson(WC->WFBuf, WildFireException(SKEY(TP->Tokens->FileName), TP->Tokens->Line, Info, 1), 1); -/* - SerializeJson(Header, WildFireMessage(SKEY(TP->Tokens->FileName), - TP->Tokens->Line, - Error, - eERROR), 1); -*/ - WildFireSerializePayload(Header, WCC->HBuf, &WCC->Hdr->nWildfireHeaders, NULL); } - else - { - /* deprecated. - StrBufAppendPrintf( - Target, - "
\n%s: %s\n
\n", - Type, - ChrPtr(Error)); - */ + else { StrBufPrintf(Info, "%s [%s] %s; [%s]", Type, 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(WC->WFBuf, WildFireException(HKEY(__FILE__), __LINE__, Info, 1), 1); } - FreeStrBuf(&Header); FreeStrBuf(&Info); FreeStrBuf(&Error); -/* - if (dbg_bactrace_template_errors) - wc_backtrace(); -*/ } - - -void LogError (StrBuf *Target, const char *Type, const char *Format, ...) -{ - wcsession *WCC; - StrBuf *Header; +void LogError (StrBuf *Target, const char *Type, const char *Format, ...) { StrBuf *Error; StrBuf *Info; va_list arg_ptr; @@ -268,25 +315,17 @@ 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; - Header = NewStrBuf(); + if (WC->WFBuf == NULL) WC->WFBuf = NewStrBuf(); + SerializeJson(WC->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) - wc_backtrace(); -*/ } @@ -296,7 +335,7 @@ void RegisterNS(const char *NSName, int nMaxArgs, WCHandlerFunc HandlerFunc, WCPreevalFunc PreevalFunc, - int ContextRequired) + CtxType ContextRequired) { HashHandler *NewHandler; @@ -305,78 +344,42 @@ 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, - "needs at least %ld params, have %ld", - Need->nMinArgs, - TP->Tokens->nParameters); - return 0; - - } - else if (TP->Tokens->nParameters > Need->nMaxArgs) { - LogTemplateError(Target, ErrType, ERR_NAME, TP, - "just needs %ld params, you gave %ld", - Need->nMaxArgs, - TP->Tokens->nParameters); - return 0; - - } -*/ return 1; } -void FreeToken(WCTemplateToken **Token) -{ +void FreeToken(WCTemplateToken **Token) { int i; FreeStrBuf(&(*Token)->FlatToken); if ((*Token)->HaveParameters) @@ -387,9 +390,7 @@ void FreeToken(WCTemplateToken **Token) } - -void FreeWCTemplate(void *vFreeMe) -{ +void FreeWCTemplate(void *vFreeMe) { int i; WCTemplate *FreeMe = (WCTemplate*)vFreeMe; @@ -405,375 +406,34 @@ void FreeWCTemplate(void *vFreeMe) free(FreeMe); } - -/* - * 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) +int HaveTemplateTokenString(StrBuf *Target, + WCTemplputParams *TP, + int N, + const char **Value, + long *len) { - 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); + if (N >= TP->Tokens->nParameters) { + return 0; } -} - -/* - * 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: + switch (TP->Tokens->Params[N]->Type) { + case TYPE_INTDEFINE: + case TYPE_STR: + case TYPE_BSTR: + case TYPE_PREFSTR: + case TYPE_ROOMPREFSTR: + case TYPE_GETTEXT: + case TYPE_SUBTEMPLATE: return 1; - case WCS_FUNCTION: - case WCS_STRBUF_REF: - case WCS_LONG: + case TYPE_LONG: + case TYPE_PREFINT: 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 - * \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; - } -} - -void GetTemplateTokenString(StrBuf *Target, - WCTemplputParams *TP, - int N, - const char **Value, - long *len) -{ +void GetTemplateTokenString(StrBuf *Target, WCTemplputParams *TP, int N, const char **Value, long *len) { StrBuf *Buf; - WCTemplputParams SubTP; if (N >= TP->Tokens->nParameters) { LogTemplateError(Target, @@ -817,6 +477,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, @@ -841,15 +514,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: @@ -860,14 +531,13 @@ void GetTemplateTokenString(StrBuf *Target, } } -long GetTemplateTokenNumber(StrBuf *Target, WCTemplputParams *TP, int N, long dflt) -{ +long GetTemplateTokenNumber(StrBuf *Target, WCTemplputParams *TP, int N, long dflt) { long Ret; if (N >= TP->Tokens->nParameters) { 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; } @@ -898,6 +568,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; @@ -930,167 +613,105 @@ long GetTemplateTokenNumber(StrBuf *Target, WCTemplputParams *TP, int N, long df } - -/** - * \brief Print the value of a variable - * \param keyname get a key to print +/* + * 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 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) +void StrBufAppendTemplate(StrBuf *Target, + WCTemplputParams *TP, + const StrBuf *Source, int FormatTypeIndex) { - wcsession *WCC = WC; - wcsubst *ptr; - void *vVar; + const char *pFmt = NULL; + char EscapeAs = ' '; - 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); - } + if ((FormatTypeIndex < TP->Tokens->nParameters) && + (TP->Tokens->Params[FormatTypeIndex] != NULL) && + (TP->Tokens->Params[FormatTypeIndex]->Type == TYPE_STR) && + (TP->Tokens->Params[FormatTypeIndex]->len >= 1)) { + pFmt = TP->Tokens->Params[FormatTypeIndex]->Start; + EscapeAs = *pFmt; } - 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); + switch(EscapeAs) + { + case 'H': + StrEscAppend(Target, Source, NULL, 0, 2); + break; + case 'X': + if (!IsEmptyStr(ChrPtr(Source))) { + StrEscAppend(Target, Source, NULL, 0, 0); + if (pFmt[1]) { + StrBufAppendBufPlain(Target, pFmt, -1, 1); + } } + break; + case 'J': + StrECMAEscAppend(Target, Source, NULL); + break; + case 'K': + StrHtmlEcmaEscAppend(Target, Source, NULL, 0, 0); + 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); } - 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 - * \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) +void StrBufAppendTemplateStr(StrBuf *Target, + WCTemplputParams *TP, + const char *Source, int FormatTypeIndex) { - wcsession *WCC; + const char *pFmt = NULL; char EscapeAs = ' '; if ((FormatTypeIndex < TP->Tokens->nParameters) && (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); + StrEscAppend(Target, NULL, Source, 0, 2); break; case 'X': - StrEscAppend(Target, Source, NULL, 0, 0); + StrEscAppend(Target, NULL, Source, 0, 0); break; case 'J': - StrECMAEscAppend(Target, Source, NULL); + StrECMAEscAppend(Target, NULL, Source); break; case 'K': - StrHtmlEcmaEscAppend(Target, Source, NULL, 0, 0); + StrHtmlEcmaEscAppend(Target, NULL, Source, 0, 0); break; case 'U': - StrBufUrlescAppend(Target, Source, NULL); + 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: - StrBufAppendBuf(Target, Source, 0); + StrBufAppendBufPlain(Target, Source, -1, 0); } } @@ -1101,16 +722,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 +746,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 +760,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; @@ -1150,6 +778,14 @@ TemplateParam *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 ++; @@ -1203,7 +839,7 @@ TemplateParam *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, @@ -1211,13 +847,16 @@ TemplateParam *GetNextParameter(StrBuf *Buf, *pCh); pch ++; free(Parm); - return NULL; + *pParm = NULL; + return 0; } 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; @@ -1246,7 +885,7 @@ TemplateParam *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, @@ -1254,7 +893,8 @@ TemplateParam *GetNextParameter(StrBuf *Buf, *pCh); */ free(Parm); - return NULL; + *pParm = NULL; + return 0; } } while ((*pch == ' ' )|| @@ -1263,13 +903,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 +921,118 @@ TemplateParam *GetNextParameter(StrBuf *Buf, Parm->lvalue = *PVal; } - else + else if (strchr(Parm->Start, '|') != NULL) { - LogTemplateError(NULL, "Define", ERR_PARM1, TP, + 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) + { + 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,47 +1042,52 @@ 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) { + if (NewToken->nParameters >= MAXPARAM) { LogTemplateError( NULL, "Parseerror", ERR_NAME, &TP, "only [%d] Params allowed in Tokens", MAXPARAM); - free(Param); FreeToken(&NewToken); return NULL; } - NewToken->Params[NewToken->nParameters++] = Param; } else break; } @@ -1374,6 +1113,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; @@ -1391,13 +1149,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; @@ -1414,6 +1176,22 @@ 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: @@ -1467,12 +1245,11 @@ WCTemplateToken *NewTemplateSubstitute(StrBuf *Buf, -/** - * \brief Display a variable-substituted template - * \param templatename template file to load +/* + * Display a variable-substituted template + * templatename template file to load */ -void *prepare_template(StrBuf *filename, StrBuf *Key, HashList *PutThere) -{ +void *prepare_template(StrBuf *filename, StrBuf *Key, HashList *PutThere) { WCTemplate *NewTemplate; NewTemplate = (WCTemplate *) malloc(sizeof(WCTemplate)); @@ -1488,53 +1265,105 @@ 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; } -/** - * \brief Display a variable-substituted template - * \param templatename template file to load +/* + * Display a variable-substituted template + * templatename template file to load + */ +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; +} + + +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; + } + } +} + +/* + * Display a variable-substituted template + * templatename template file to load */ -void *load_template(StrBuf *filename, StrBuf *Key, HashList *PutThere) +void *load_template(StrBuf *Target, 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)); + 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", - ChrPtr(filename), strerror(errno)); + syslog(LOG_WARNING, "ERROR: could not stat template '%s' - %s\n", + 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
\n", - ChrPtr(filename), strerror(errno)); + syslog(LOG_WARNING, "ERROR: reading template '%s' - %s
\n", + ChrPtr(NewTemplate->FileName), strerror(errno)); return NULL; } close(fd); @@ -1546,11 +1375,10 @@ void *load_template(StrBuf *filename, StrBuf *Key, HashList *PutThere) 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 '))) { - 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 ++; + } } - if (LoadTemplates == 0) - Put(PutThere, ChrPtr(Key), StrLength(Key), NewTemplate, FreeWCTemplate); + + SanityCheckTemplate(NULL, NewTemplate); return NewTemplate; } @@ -1597,7 +1438,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; @@ -1610,7 +1451,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) { @@ -1632,9 +1472,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 @@ -1647,7 +1492,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; @@ -1669,7 +1513,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); } } @@ -1694,10 +1538,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: @@ -1709,11 +1553,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! */ - 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) @@ -1727,11 +1566,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)); - if (LoadTemplates == 0) - load_template(FileName, Key, (IsMobile)?wireless:big); - else - prepare_template(FileName, Key, (IsMobile)?wireless:big); + syslog(LOG_DEBUG, "%s %s\n", ChrPtr(FileName), ChrPtr(Key)); + prepare_template(FileName, Key, big); default: break; } @@ -1747,33 +1583,43 @@ int LoadTemplateDir(const StrBuf *DirName, HashList *wireless, HashList *big, co void InitTemplateCache(void) { + int i; StrBuf *Key; StrBuf *Dir; + HashList *Templates[2]; Dir = NewStrBuf(); Key = NewStrBuf(); /* Primary Template set... */ StrBufPrintf(Dir, "%s/t", static_dirs[0]); - LoadTemplateDir(Dir, - WirelessTemplateCache, - TemplateCache, - Key); + LoadTemplateDir(Dir, TemplateCache, Key); /* User local Template set */ StrBufPrintf(Dir, "%s/t", static_dirs[1]); - LoadTemplateDir(Dir, - WirelessLocalTemplateCache, - LocalTemplateCache, - Key); + LoadTemplateDir(Dir, LocalTemplateCache, Key); /* Debug Templates, just to be loaded while debugging. */ StrBufPrintf(Dir, "%s/dbg", static_dirs[0]); - LoadTemplateDir(Dir, - WirelessTemplateCache, - TemplateCache, - Key); + LoadTemplateDir(Dir, TemplateCache, Key); + Templates[0] = TemplateCache; + Templates[1] = LocalTemplateCache; + + + if (LoadTemplates == 0) + for (i=0; i < 2; 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(NULL, (WCTemplate *)vTemplate); + } + DeleteHashPos(&At); + } FreeStrBuf(&Dir); @@ -1794,15 +1640,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) { @@ -1810,32 +1657,40 @@ 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, - AppendMeLen, - 0); + StrBufAppendBufPlain(Target, AppendMe, AppendMeLen, 0); } else{ GetTemplateTokenString(Target, TP, 4, &AppendMe, &AppendMeLen); - StrBufAppendBufPlain(Target, - AppendMe, - AppendMeLen, - 0); + StrBufAppendBufPlain(Target, AppendMe, AppendMeLen, 0); + } + if (*TPP != TP) + { + UnStackDynamicContext(Target, TPP); } } else { - LogTemplateError( - Target, "Conditional", ERR_NAME, TP, - "needs at least 6 Params!"); + LogTemplateError( Target, "Conditional", ERR_NAME, TP, "needs at least 6 Params!"); } break; case SV_SUBTEMPL: @@ -1845,7 +1700,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; @@ -1853,14 +1708,16 @@ 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); } } 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; @@ -1872,27 +1729,31 @@ 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 = load_template(Tmpl->FileName, NULL, NULL); - if(pTmpl == NULL) { - StrBufAppendPrintf( - Target, + pTmpl = duplicate_template(Tmpl); + if(load_template(Target, pTmpl) == NULL) { + StrBufAppendPrintf( Target, "
\nError loading Template [%s]\n See Logfile for details\n
\n", ChrPtr(Tmpl->FileName)); + FreeWCTemplate(pTmpl); return NULL; } @@ -1901,37 +1762,54 @@ 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, - pData, - len - (pData - pS), 0); + StrBufAppendBufPlain(Target, pData, len - (pData - pS), 0); done = 1; } else { - 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); - - while ((state != 0) && (i+1 < pTmpl->nTokensUsed)) { + int TokenRc = 0; + + StrBufAppendBufPlain( Target, pData, pTmpl->Tokens[i]->pTokenStart - pData, 0); + TPtr->Tokens = pTmpl->Tokens[i]; + TPtr->nArgs = pTmpl->Tokens[i]->nParameters; + + 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; @@ -1944,6 +1822,8 @@ const StrBuf *ProcessTemplate(WCTemplate *Tmpl, StrBuf *Target, WCTemplputParams } + +StrBuf *textPlainType; /** * \brief Display a variable-substituted template * \param templatename template file to load @@ -1963,52 +1843,69 @@ 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"); + if (len == 0) { + syslog(LOG_WARNING, "Can't to load a template with empty name!\n"); StrBufAppendPrintf(Target, "
\nCan't to load a template with empty name!\n
"); - 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, "
\ndidn't find Template [%s] %ld %ld\n
", - 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); } + +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); + FreeStrBuf(&Comment); + } +} + /*----------------------------------------------------------------------------- * Iterators */ 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, @@ -2017,8 +1914,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; @@ -2030,6 +1928,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; @@ -2049,7 +1948,9 @@ int preeval_iterate(WCTemplateToken *Token) { WCTemplputParams TPP; WCTemplputParams *TP; + void *vTmpl; void *vIt; + HashIterator *It; memset(&TPP, 0, sizeof(WCTemplputParams)); TP = &TPP; @@ -2060,7 +1961,29 @@ int preeval_iterate(WCTemplateToken *Token) "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; } @@ -2076,6 +1999,7 @@ void tmpl_iterate_subtmpl(StrBuf *Target, WCTemplputParams *TP) void *vContext; void *vLastContext = NULL; StrBuf *SubBuf; + WCTemplputParams IterateTP; WCTemplputParams SubTP; IterateStruct Status; @@ -2084,7 +2008,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) { @@ -2097,7 +2020,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; } @@ -2105,9 +2028,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 ; } @@ -2126,10 +2049,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; } @@ -2137,42 +2062,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) @@ -2182,7 +2119,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; @@ -2191,7 +2128,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 @@ -2201,114 +2138,100 @@ 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); } +void tmplput_ITERATE_N_DIV(StrBuf *Target, WCTemplputParams *TP) +{ + IterateStruct *Ctx = CTX(CTX_ITERATE); + long div; + long divisor = GetTemplateTokenNumber(Target, TP, 0, 1); +///TODO divisor == 0 -> log error exit + div = Ctx->n / divisor; + StrBufAppendPrintf(Target, "%ld", div); +} -void tmplput_ITERATE_LASTN(StrBuf *Target, WCTemplputParams *TP) +void tmplput_ITERATE_N(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; } +int conditional_ITERATE_ISMOD(StrBuf *Target, WCTemplputParams *TP) +{ + IterateStruct *Ctx = CTX(CTX_ITERATE); + + long divisor = GetTemplateTokenNumber(Target, TP, 2, 1); + long expectRemainder = GetTemplateTokenNumber(Target, TP, 3, 0); + + return Ctx->n % divisor == expectRemainder; +} + /*----------------------------------------------------------------------------- * 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; -} - -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; -} + 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; @@ -2318,8 +2241,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); } @@ -2333,6 +2256,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; /*----------------------------------------------------------------------------- @@ -2340,11 +2296,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; @@ -2352,6 +2308,36 @@ int ConditionalContextStr(StrBuf *Target, WCTemplputParams *TP) return strcmp(ChrPtr(TokenText), CompareToken) == 0; } +void tmplput_ContextStringArray(StrBuf *Target, WCTemplputParams *TP) +{ + HashList *Arr = (HashList*) CTX(CTX_STRBUFARR); + 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(CTX_STRBUFARR); + 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 */ @@ -2378,12 +2364,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); } @@ -2391,10 +2379,81 @@ 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)); nTabs = ntabs = TP->Tokens->nParameters / 2; TabNames = (StrBuf **) malloc(ntabs * sizeof(StrBuf*)); @@ -2421,15 +2480,36 @@ void tmpl_do_tabbed(StrBuf *Target, WCTemplputParams *TP) nTabs --; } } - - StrTabbedDialog(Target, nTabs, TabNames); - for (i = 0; i < ntabs; i++) { - StrBeginTab(Target, i, nTabs); - DoTemplate(TKEY(i * 2 + 1), Target, TP); - 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); } + UnStackContext(&SubTP); +} + +void tmplput_TAB_N(StrBuf *Target, WCTemplputParams *TP) +{ + tab_struct *Ctx = CTX(CTX_TAB); + + StrBufAppendPrintf(Target, "%d", Ctx->CurrentTab); } +void tmplput_TAB_TITLE(StrBuf *Target, WCTemplputParams *TP) +{ + tab_struct *Ctx = CTX(CTX_TAB); + StrBufAppendTemplate(Target, TP, Ctx->TabTitle, 0); +} /*----------------------------------------------------------------------------- * Sorting-API @@ -2441,7 +2521,7 @@ void RegisterSortFunc(const char *name, long len, CompareFunc Forward, CompareFunc Reverse, CompareFunc GroupChange, - long ContextType) + CtxType ContextType) { SortStruct *NewSort; @@ -2457,7 +2537,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); } @@ -2468,7 +2548,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; @@ -2502,13 +2581,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; @@ -2518,7 +2596,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; @@ -2557,9 +2635,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[] = { @@ -2610,7 +2688,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) { @@ -2716,7 +2794,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])) @@ -2753,13 +2831,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])&& @@ -2799,33 +2877,53 @@ 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); 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); + 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:SUBST"), 3, ConditionalVar, CTX_NONE); - RegisterConditional(HKEY("COND:CONTEXTSTR"), 3, ConditionalContextStr, CTX_STRBUF); - RegisterConditional(HKEY("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); - - 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); + + + RegisterConditional("COND:CONTEXTSTR", 3, ConditionalContextStr, CTX_STRBUF); + RegisterConditional("COND:CONTEXTSTRARR", 4, ConditionalContextStrinArray, CTX_STRBUFARR); + RegisterConditional("COND:LONGVECTOR", 4, ConditionalLongVector, CTX_LONGVECTOR); + + + 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); + RegisterConditional("COND:ITERATE:ISMOD", 3, + conditional_ITERATE_ISMOD, + 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_N, NULL, CTX_ITERATE); + RegisterNamespace("ITERATE:N:DIV", 1, 1, tmplput_ITERATE_N_DIV, 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); + + } @@ -2834,16 +2932,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 @@ -2857,16 +2960,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); } @@ -2881,14 +2985,13 @@ void SessionAttachModule_SUBST (wcsession *sess) { - sess->vars = NewHash(1,NULL); } void SessionDetachModule_SUBST (wcsession *sess) { - DeleteHash(&sess->vars); + FreeStrBuf(&sess->WFBuf); } void