X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=webcit%2Fsubst.c;h=4e08db7ace058e6464fdd11db346d417f143a139;hb=f5c1330914acc193f96892efc191a32ee537dfb5;hp=1de23b6ae5e67ffb899d09b0a8324e581727be96;hpb=8c321fbcc2a64f0d0627562fdf5651442e525ab1;p=citadel.git diff --git a/webcit/subst.c b/webcit/subst.c index 1de23b6ae..4e08db7ac 100644 --- a/webcit/subst.c +++ b/webcit/subst.c @@ -1,26 +1,22 @@ -/* - * $Id$ - */ -/** - * \defgroup Subst Variable substitution type stuff - * \ingroup CitadelConfig - */ +#include "sysdep.h" -/*@{*/ -#include "sysdep.h" #include #include -#include #include #include + +#include +#include #include +#include + #define SHOW_ME_VAPPEND_PRINTF #include "webcit.h" #include "webserver.h" -extern char *static_dirs[PATH_MAX]; /**< Disk representation */ +extern char *static_dirs[PATH_MAX]; /* Disk representation */ HashList *WirelessTemplateCache; HashList *WirelessLocalTemplateCache; @@ -31,8 +27,15 @@ HashList *GlobalNS; HashList *Iterators; HashList *Conditionals; HashList *SortHash; +HashList *Defines; +int DumpTemplateI18NStrings = 0; int LoadTemplates = 0; +int dbg_backtrace_template_errors = 0; +WCTemplputParams NoCtx; +StrBuf *I18nDump = NULL; + +const char EmptyStr[]=""; #define SV_GETTEXT 1 #define SV_CONDITIONAL 2 @@ -41,403 +44,355 @@ int LoadTemplates = 0; #define SV_SUBTEMPL 5 #define SV_PREEVALUATED 6 + +/* + * Dynamic content for variable substitution in templates + */ +typedef struct _wcsubst { + ContextFilter Filter; + int wcs_type; /* which type of Substitution are we */ + char wcs_key[32]; /* copy of our hashkey for debugging */ + StrBuf *wcs_value; /* if we're a string, keep it here */ + long lvalue; /* type long? keep data here */ + WCHandlerFunc wcs_function; /* funcion hook ???*/ +} wcsubst; + + typedef struct _WCTemplate { StrBuf *Data; StrBuf *FileName; int nTokensUsed; int TokenSpace; + StrBuf *MimeType; WCTemplateToken **Tokens; } WCTemplate; typedef struct _HashHandler { - int nMinArgs; - int nMaxArgs; - int ContextRequired; + ContextFilter Filter; + WCPreevalFunc PreEvalFunc; WCHandlerFunc HandlerFunc; }HashHandler; -void *load_template(StrBuf *filename, StrBuf *Key, HashList *PutThere); -int EvaluateConditional(StrBuf *Target, WCTemplateToken *Tokens, WCTemplate *pTmpl, void *Context, int Neg, int state, int ContextType); +void *load_template(WCTemplate *NewTemplate); +int EvaluateConditional(StrBuf *Target, int Neg, int state, WCTemplputParams *TP); -void RegisterNS(const char *NSName, - long len, - int nMinArgs, - int nMaxArgs, - WCHandlerFunc HandlerFunc, - int ContextRequired) -{ - HashHandler *NewHandler; - - NewHandler = (HashHandler*) malloc(sizeof(HashHandler)); - NewHandler->nMinArgs = nMinArgs; - NewHandler->nMaxArgs = nMaxArgs; - NewHandler->HandlerFunc = HandlerFunc; - NewHandler->ContextRequired = ContextRequired; - Put(GlobalNS, NSName, len, NewHandler, NULL); -} -void FreeToken(WCTemplateToken **Token) -{ - int i; - FreeStrBuf(&(*Token)->FlatToken); - if ((*Token)->HaveParameters) - for (i = 0; i < (*Token)->nParameters; i++) - free((*Token)->Params[i]); - free(*Token); - *Token = NULL; -} +typedef struct _SortStruct { + StrBuf *Name; + StrBuf *PrefPrepend; + CompareFunc Forward; + CompareFunc Reverse; + CompareFunc GroupChange; + long ContextType; +}SortStruct; -void FreeWCTemplate(void *vFreeMe) -{ - int i; - WCTemplate *FreeMe = (WCTemplate*)vFreeMe; +const char *CtxNames[] = { + "Context NONE", + "Context SITECFG", + "Context SESSION", + "Context INETCFG", + "Context VNOTE", + "Context WHO", + "Context PREF", + "Context NODECONF", + "Context USERLIST", + "Context MAILSUM", + "Context MIME_ATACH", + "Context FILELIST", + "Context STRBUF", + "Context STRBUFARR", + "Context LONGVECTOR", + "Context ROOMS", + "Context FLOORS", + "Context ITERATE", + "Context ICAL", + "Context DavNamespace", + "Context TAB", + "Context UNKNOWN" +}; - if (FreeMe->TokenSpace > 0) { - for (i = 0; i < FreeMe->nTokensUsed; i ++) { - FreeToken(&FreeMe->Tokens[i]); - } - free(FreeMe->Tokens); - } - FreeStrBuf(&FreeMe->FileName); - FreeStrBuf(&FreeMe->Data); - free(FreeMe); -} -/** - * \brief debugging function to print array to log - */ -void VarPrintTransition(void *vVar1, void *vVar2, int odd){} -/** - * \brief debugging function to print array to log - */ -void VarPrintEntry(const char *Key, void *vSubst, int odd) +void DestroySortStruct(void *vSort) { - 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); - } -} - - - -/** - * \brief Clear out the list of substitution variables local to this session - */ -void clear_substs(wcsession *wc) { - - if (wc->vars != NULL) { - DeleteHash(&wc->vars); - } -} - -/** - * \brief Clear out the list of substitution variables local to this session - */ -void clear_local_substs(void) { - clear_substs (WC); + SortStruct *Sort = (SortStruct*) vSort; + FreeStrBuf(&Sort->Name); + FreeStrBuf(&Sort->PrefPrepend); + free (Sort); } -int NeedNewBuf(type) +const char *ContextName(int ContextType) { - switch(type) { - case WCS_STRING: - case WCS_SERVCMD: - case WCS_STRBUF: - return 1; - case WCS_FUNCTION: - case WCS_STRBUF_REF: - case WCS_LONG: - default: - return 0; - } + if (ContextType < CTX_UNKNOWN) + return CtxNames[ContextType]; + else + return CtxNames[CTX_UNKNOWN]; } -void FlushPayload(wcsubst *ptr, int reusestrbuf, int type) +void LogTemplateError (StrBuf *Target, const char *Type, int ErrorPos, WCTemplputParams *TP, const char *Format, ...) { - 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(); + wcsession *WCC; + StrBuf *Error; + StrBuf *Info; + va_list arg_ptr; + const char *Err = NULL; + + Info = NewStrBuf(); + Error = NewStrBuf(); + + va_start(arg_ptr, Format); + StrBufVAppendPrintf(Error, Format, arg_ptr); + va_end(arg_ptr); + + switch (ErrorPos) { + case ERR_NAME: /* the main token name... */ + Err = (TP->Tokens!= NULL)? TP->Tokens->pName:""; break; default: - if (reusestrbuf && NeedNew) - ptr->wcs_value = NewStrBuf(); + Err = ((TP->Tokens!= NULL) && + (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)); + } + else + { + lprintf(1, "%s: %s;\n", + Type, + ChrPtr(Error)); + } +/* + if (Target == NULL) + return; +*/ + WCC = WC; + if (WCC == NULL) { + FreeStrBuf(&Info); + FreeStrBuf(&Error); + return; + } + + if (WCC->WFBuf == NULL) WCC->WFBuf = NewStrBuf(); + if (TP->Tokens != NULL) + { + /* deprecated: + StrBufAppendPrintf( + Target, + "
\n%s [%s] (in '%s' line %ld); %s\n[%s]\n
\n", + Type, + Err, + ChrPtr(TP->Tokens->FileName), + TP->Tokens->Line, + ChrPtr(Error), + ChrPtr(TP->Tokens->FlatToken)); + */ + StrBufPrintf(Info, "%s [%s] %s; [%s]", + Type, + Err, + ChrPtr(Error), + ChrPtr(TP->Tokens->FlatToken)); + + + SerializeJson(WCC->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); +*/ + + } + else + { + /* deprecated. + StrBufAppendPrintf( + Target, + "
\n%s: %s\n
\n", + Type, + ChrPtr(Error)); + */ + StrBufPrintf(Info, "%s [%s] %s; [%s]", + Type, + Err, + ChrPtr(Error), + ChrPtr(TP->Tokens->FlatToken)); + SerializeJson(WCC->WFBuf, WildFireException(HKEY(__FILE__), __LINE__, Info, 1), 1); + } + FreeStrBuf(&Info); + FreeStrBuf(&Error); +/* + if (dbg_backtrace_template_errors) + wc_backtrace(); +*/ } -/** - * \brief 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) +void LogError (StrBuf *Target, const char *Type, const char *Format, ...) { - wcsubst* ptr; - wcsession *WCC = WC; + wcsession *WCC; + StrBuf *Error; + StrBuf *Info; + va_list arg_ptr; - ptr = (wcsubst *) malloc(sizeof(wcsubst)); - memset(ptr, 0, sizeof(wcsubst)); + Info = NewStrBuf(); + Error = NewStrBuf(); - ptr->wcs_type = type; - safestrncpy(ptr->wcs_key, keyname, sizeof ptr->wcs_key); - Put(WCC->vars, keyname, keylen, ptr, deletevar); + va_start(arg_ptr, Format); + StrBufVAppendPrintf(Error, Format, arg_ptr); + va_end(arg_ptr); - 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; -} + lprintf(1, ChrPtr(Error)); + WCC = WC; + if (WCC->WFBuf == NULL) WCC->WFBuf = NewStrBuf(); -/** - * \brief Add a substitution variable (local to this session) (strlen version...) - * \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 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); - } + SerializeJson(WCC->WFBuf, WildFireException(Type, strlen(Type), + 0, + Info, + 1), 1); - /** Format the string */ - va_start(arg_ptr, format); - StrBufVAppendPrintf(ptr->wcs_value, format, arg_ptr); - va_end(arg_ptr); + FreeStrBuf(&Info); + FreeStrBuf(&Error); +/* + if (dbg_backtrace_template_errors) + wc_backtrace(); +*/ } -/** - * \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 svprintf(char *keyname, size_t keylen, int keytype, const char *format,...) + +void RegisterNS(const char *NSName, + long len, + int nMinArgs, + int nMaxArgs, + WCHandlerFunc HandlerFunc, + WCPreevalFunc PreevalFunc, + int ContextRequired) { - 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); - } + HashHandler *NewHandler; + + NewHandler = (HashHandler*) malloc(sizeof(HashHandler)); + memset(NewHandler, 0, sizeof(HashHandler)); + NewHandler->Filter.nMinArgs = nMinArgs; + NewHandler->Filter.nMaxArgs = nMaxArgs; + NewHandler->Filter.ContextType = ContextRequired; + NewHandler->Filter.ControlContextType = CTX_NONE; - /** Format the string and save it */ - va_start(arg_ptr, format); - StrBufVAppendPrintf(ptr->wcs_value, format, arg_ptr); - va_end(arg_ptr); + NewHandler->PreEvalFunc = PreevalFunc; + NewHandler->HandlerFunc = HandlerFunc; + Put(GlobalNS, NSName, len, NewHandler, NULL); } -/** - * \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 SVPut(char *keyname, size_t keylen, int keytype, char *Data) +void RegisterControlNS(const char *NSName, + long len, + int nMinArgs, + int nMaxArgs, + WCHandlerFunc HandlerFunc, + int ControlContextRequired) { - void *vPtr; - wcsubst *ptr = NULL; - wcsession *WCC = WC; - + HashHandler *NewHandler; - /** - * 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); + 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); } -/** - * \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) + + +int CheckContext(StrBuf *Target, ContextFilter *Need, WCTemplputParams *TP, const char *ErrType) { - void *vPtr; - wcsubst *ptr = NULL; - wcsession *WCC = WC; + if ((Need->ContextType != CTX_NONE) && + (Need->ContextType != TP->Filter.ContextType)) { + LogTemplateError( + Target, ErrType, ERR_PARM1, TP, + " WARNING: requires Context: [%s], have [%s]!", + ContextName(Need->ContextType), + ContextName(TP->Filter.ContextType)); + return 0; + } - - /** - * 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); + 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; } - ptr->lvalue = Data; -} +/* + 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; -/** - * \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); } + 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; - ptr->wcs_function = fcn_ptr; + } +*/ + return 1; } -inline void SVCALLBACK(char *keyname, WCHandlerFunc fcn_ptr) + +void FreeToken(WCTemplateToken **Token) { - SVCallback(keyname, strlen(keyname), fcn_ptr); + int i; + FreeStrBuf(&(*Token)->FlatToken); + if ((*Token)->HaveParameters) + for (i = 0; i < (*Token)->nParameters; i++) + free((*Token)->Params[i]); + free(*Token); + *Token = NULL; } -void SVPUTBuf(const char *keyname, int keylen, const StrBuf *Buf, int ref) +void FreeWCTemplate(void *vFreeMe) { - wcsubst *ptr; - void *vPtr; - wcsession *WCC = WC; + int i; + WCTemplate *FreeMe = (WCTemplate*)vFreeMe; - /** - * 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); + if (FreeMe->TokenSpace > 0) { + for (i = 0; i < FreeMe->nTokensUsed; i ++) { + FreeToken(&FreeMe->Tokens[i]); + } + free(FreeMe->Tokens); } - ptr->wcs_value = (StrBuf*)Buf; + FreeStrBuf(&FreeMe->FileName); + FreeStrBuf(&FreeMe->Data); + FreeStrBuf(&FreeMe->MimeType); + free(FreeMe); } + + /** * \brief back end for print_value_of() ... does a server command * \param servcmd server command to execute on the citadel server @@ -465,213 +420,231 @@ void pvo_do_cmd(StrBuf *Target, StrBuf *servcmd) { } } -void GetTemplateTokenString(WCTemplateToken *Tokens, - int N, +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, const char **Value, long *len) { StrBuf *Buf; + WCTemplputParams SubTP; - if (Tokens->nParameters < N) { + if (N >= TP->Tokens->nParameters) { + LogTemplateError(Target, + "TokenParameter", N, TP, + "invalid token %d. this shouldn't have come till here.\n", N); *Value = ""; *len = 0; return; } - switch (Tokens->Params[N]->Type) { + switch (TP->Tokens->Params[N]->Type) { + case TYPE_INTDEFINE: case TYPE_STR: - *Value = Tokens->Params[N]->Start; - *len = Tokens->Params[N]->len; + *Value = TP->Tokens->Params[N]->Start; + *len = TP->Tokens->Params[N]->len; break; case TYPE_BSTR: - Buf = (StrBuf*) SBstr(Tokens->Params[N]->Start, - Tokens->Params[N]->len); + if (TP->Tokens->Params[N]->len == 0) { + LogTemplateError(Target, + "TokenParameter", N, TP, + "Requesting parameter %d; of type BSTR, empty lookup string not admitted.", N); + *len = 0; + *Value = EmptyStr; + break; + } + Buf = (StrBuf*) SBstr(TKEY(N)); *Value = ChrPtr(Buf); *len = StrLength(Buf); break; case TYPE_PREFSTR: - get_PREFERENCE( - Tokens->Params[N]->Start, - Tokens->Params[N]->len, - &Buf); + 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; + } + get_PREFERENCE(TKEY(N), &Buf); *Value = ChrPtr(Buf); *len = StrLength(Buf); break; case TYPE_LONG: + LogTemplateError(Target, + "TokenParameter", N, TP, + "Requesting parameter %d; of type LONG, want string.", N); + break; case TYPE_PREFINT: - break; ///todo: string to text? + LogTemplateError(Target, + "TokenParameter", N, TP, + "Requesting parameter %d; of type PREFINT, want string.", N); + break; case TYPE_GETTEXT: - *Value = _(Tokens->Params[N]->Start); + *Value = _(TP->Tokens->Params[N]->Start); *len = strlen(*Value); break; - default: - break; -//todo log error - } -} - - - -/** - * \brief Print the value of a variable - * \param keyname get a key to print - */ -void print_value_of(StrBuf *Target, WCTemplateToken *Tokens, void *Context, int ContextType) { - wcsession *WCC = WC; - wcsubst *ptr; - void *vVar; - - /*if (WCC->vars != NULL) PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/ - /// TODO: debricated! - if (Tokens->pName[0] == '=') { - DoTemplate(Tokens->pName+1, Tokens->NameEnd - 1, NULL, NULL, 0); - } - -//////TODO: if param[1] == "U" -> urlescape -/// X -> escputs - /** Page-local variables */ - if ((WCC->vars!= NULL) && GetHash(WCC->vars, Tokens->pName, 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, Tokens->nParameters, Tokens, Context, ContextType); - break; - case WCS_STRBUF: - case WCS_STRBUF_REF: - StrBufAppendBuf(Target, ptr->wcs_value, 0); + case TYPE_SUBTEMPLATE: + if (TP->Tokens->Params[N]->len == 0) { + LogTemplateError(Target, + "TokenParameter", N, TP, + "Requesting parameter %d; of type SUBTEMPLATE, empty lookup string not admitted.", N); + *len = 0; + *Value = EmptyStr; break; - case WCS_LONG: - StrBufAppendPrintf(Target, "%ld", ptr->lvalue); - break; - default: - lprintf(1,"WARNING: invalid value in SV-Hash at %s!\n", Tokens->pName); - StrBufAppendPrintf(Target, "
WARNING: \ninvalid value in SV-Hash at %s!\n
", Tokens->pName); } - } - else { - lprintf(1, "didn't find Handler [%s] (in '%s' line %ld); " - " [%s]\n", - Tokens->pName, - ChrPtr(Tokens->FileName), - Tokens->Line, - ChrPtr(Tokens->FlatToken)); - wc_backtrace(); - } -} -int CompareSubstToToken(TemplateParam *ParamToCompare, TemplateParam *ParamToLookup) -{ - wcsession *WCC = WC; - wcsubst *ptr; - void *vVar; + memset(&SubTP, 0, sizeof(WCTemplputParams *)); + SubTP.Context = TP->Context; + SubTP.Filter.ContextType = TP->Filter.ContextType; + Buf = NewStrBuf(); + DoTemplate(TKEY(N), Buf, &SubTP); + *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); + break; - 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); - } + default: + LogTemplateError(Target, + "TokenParameter", N, TP, + "unknown param type %d; [%d]", N, TP->Tokens->Params[N]->Type); + break; } - return 0; } -int CompareSubstToStrBuf(StrBuf *Compare, TemplateParam *ParamToLookup) +long GetTemplateTokenNumber(StrBuf *Target, WCTemplputParams *TP, int N, long dflt) { - wcsession *WCC = WC; - wcsubst *ptr; - void *vVar; + 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(); + return 0; + } - 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 (TP->Tokens->Params[N]->Type) { + + case TYPE_STR: + return atol(TP->Tokens->Params[N]->Start); + break; + case TYPE_BSTR: + if (TP->Tokens->Params[N]->len == 0) { + LogTemplateError(Target, + "TokenParameter", N, TP, + "Requesting parameter %d; of type BSTR, empty lookup string not admitted.", N); + return 0; } + return LBstr(TKEY(N)); + break; + case TYPE_PREFSTR: + 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_PREF_LONG(TKEY(N), &Ret, dflt)) + return Ret; + return 0; + case TYPE_INTDEFINE: + case TYPE_LONG: + return TP->Tokens->Params[N]->lvalue; + case TYPE_PREFINT: + if (TP->Tokens->Params[N]->len == 0) { + LogTemplateError(Target, + "TokenParameter", N, TP, + "Requesting parameter %d; of type PREFINT, empty lookup string not admitted.", N); + return 0; + } + if (get_PREF_LONG(TKEY(N), &Ret, dflt)) + return Ret; + return 0; + case TYPE_GETTEXT: + LogTemplateError(Target, + "TokenParameter", N, TP, + "requesting a I18N string in param %d; want a number", N); + return 0; + case TYPE_SUBTEMPLATE: + LogTemplateError(Target, + "TokenParameter", N, TP, + "requesting a subtemplate in param %d; not supported for numbers", N); + return 0; + default: + LogTemplateError(Target, + "TokenParameter", N, TP, + "unknown param type %d; [%d]", N, TP->Tokens->Params[N]->Type); + return 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? */ void StrBufAppendTemplate(StrBuf *Target, - int nArgs, - WCTemplateToken *Tokens, - void *Context, int ContextType, + WCTemplputParams *TP, const StrBuf *Source, int FormatTypeIndex) { wcsession *WCC; - StrBuf *Buf; char EscapeAs = ' '; - if ((FormatTypeIndex < Tokens->nParameters) && - (Tokens->Params[FormatTypeIndex]->Type == TYPE_STR) && - (Tokens->Params[FormatTypeIndex]->len == 1)) { - EscapeAs = *Tokens->Params[FormatTypeIndex]->Start; + if ((FormatTypeIndex < TP->Tokens->nParameters) && + (TP->Tokens->Params[FormatTypeIndex]->Type == TYPE_STR) && + (TP->Tokens->Params[FormatTypeIndex]->len == 1)) { + EscapeAs = *TP->Tokens->Params[FormatTypeIndex]->Start; } switch(EscapeAs) { case 'H': WCC = WC; - Buf = NewStrBufPlain(NULL, StrLength(Source)); - StrBuf_RFC822_to_Utf8(Buf, - Source, - (WCC!=NULL)? WCC->DefaultCharset : NULL, - NULL); - StrEscAppend(Target, Buf, NULL, 0, 0); - FreeStrBuf(&Buf); + StrEscAppend(Target, Source, NULL, 0, 2); break; case 'X': StrEscAppend(Target, Source, NULL, 0, 0); break; + case 'J': + StrECMAEscAppend(Target, Source, NULL); + break; + case 'K': + StrHtmlEcmaEscAppend(Target, Source, NULL, 0, 0); + break; + case 'U': + StrBufUrlescAppend(Target, Source, NULL); + break; default: StrBufAppendBuf(Target, Source, 0); } @@ -684,15 +657,22 @@ void PutNewToken(WCTemplate *Template, WCTemplateToken *NewToken) if (Template->TokenSpace <= 0) { Template->Tokens = (WCTemplateToken**)malloc( sizeof(WCTemplateToken*) * 10); + 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; @@ -701,14 +681,22 @@ 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) +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; - TemplateParam *Parm = (TemplateParam *) malloc(sizeof(TemplateParam)); + TemplateParam *Parm; char quote = '\0'; - + int ParamBrace = 0; + *pParm = Parm = (TemplateParam *) malloc(sizeof(TemplateParam)); + memset(Parm, 0, sizeof(TemplateParam)); Parm->Type = TYPE_STR; /* Skip leading whitespaces */ @@ -720,18 +708,46 @@ TemplateParam *GetNextParameter(StrBuf *Buf, const char **pCh, const char *pe, W if (*pch == ':') { Parm->Type = TYPE_PREFSTR; pch ++; + if (*pch == '(') { + pch ++; + ParamBrace = 1; + } } else if (*pch == ';') { Parm->Type = TYPE_PREFINT; pch ++; + if (*pch == '(') { + pch ++; + ParamBrace = 1; + } + } + else if (*pch == '#') { + Parm->Type = TYPE_INTDEFINE; + pch ++; } else if (*pch == '_') { Parm->Type = TYPE_GETTEXT; pch ++; + if (*pch == '(') { + pch ++; + ParamBrace = 1; + } } else if (*pch == 'B') { Parm->Type = TYPE_BSTR; pch ++; + if (*pch == '(') { + pch ++; + ParamBrace = 1; + } + } + else if (*pch == '=') { + Parm->Type = TYPE_SUBTEMPLATE; + pch ++; + if (*pch == '(') { + pch ++; + ParamBrace = 1; + } } @@ -758,7 +774,8 @@ TemplateParam *GetNextParameter(StrBuf *Buf, const char **pCh, const char *pe, W *pCh); pch ++; free(Parm); - return NULL; + *pParm = NULL; + return 0; } else { StrBufPeek(Buf, pch, -1, '\0'); @@ -769,6 +786,10 @@ TemplateParam *GetNextParameter(StrBuf *Buf, const char **pCh, const char *pe, W Parm->Start = pchs; Parm->len = pche - pchs; pch ++; /* move after trailing quote */ + if (ParamBrace && (*pch == ')')) { + pch ++; + } + } } else { @@ -788,14 +809,17 @@ TemplateParam *GetNextParameter(StrBuf *Buf, const char **pCh, const char *pe, W } else { Parm->lvalue = 0; +/* TODO whUT? lprintf(1, "Error (in '%s' line %ld); " "evaluating long template param [%s] in Token [%s]\n", ChrPtr(pTmpl->FileName), Tokens->Line, ChrPtr(Tokens->FlatToken), *pCh); + */ free(Parm); - return NULL; + *pParm = NULL; + return 0; } } while ((*pch == ' ' )|| @@ -804,68 +828,187 @@ TemplateParam *GetNextParameter(StrBuf *Buf, const char **pCh, const char *pe, W (*pch == ',' )|| (*pch == '\n')) pch ++; + 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)) + { + long *PVal; + PVal = (long*) vPVal; + + Parm->lvalue = *PVal; + } + else if (strchr(Parm->Start, '|') != NULL) + { + const char *Pos; + StrBuf *pToken; + StrBuf *Match; + + Parm->MaskBy = eOR; + pToken = NewStrBufPlain (Parm->Start, Parm->len); + Match = NewStrBufPlain (NULL, Parm->len); + Pos = ChrPtr(pToken); + + while ((Pos != NULL) && (Pos != StrBufNOTNULL)) + { + StrBufExtract_NextToken(Match, pToken, &Pos, '|'); + StrBufTrim(Match); + if (StrLength (Match) > 0) + { + if (GetHash(Defines, SKEY(Match), &vPVal) && + (vPVal != NULL)) + { + long *PVal; + PVal = (long*) vPVal; + + Parm->lvalue |= *PVal; + } + else { + LogTemplateError(NULL, "Define", + Tokens->nParameters, + TP, + "%s isn't known!!", + ChrPtr(Match)); + + } + } + } + } + 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)); + + } + } + } + } + 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 = (WCTemplateToken*)malloc(sizeof(WCTemplateToken)); + WCTemplateToken *NewToken; + WCTemplputParams TP; + NewToken = (WCTemplateToken*)malloc(sizeof(WCTemplateToken)); + memset(NewToken, 0, sizeof(WCTemplateToken)); + TP.Tokens = NewToken; 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); - - StrBufPeek(Buf, pTmplStart, + 1, '\0'); - StrBufPeek(Buf, pTmplEnd, -1, '\0'); - pch = NewToken->pName = pTmplStart + 2; + NewToken->FlatToken = NewStrBufPlain(pTokenStart + 2, pTokenEnd - pTokenStart - 2); + StrBufShrinkToFit(NewToken->FlatToken, 1); + + 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) != ')') { - lprintf(1, "Warning, Non welformed Token; missing right parenthesis (in '%s' line %ld); " - "[%s]\n", - ChrPtr(pTmpl->FileName), - NewToken->Line, - ChrPtr(NewToken->FlatToken)); + 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); - 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) { - lprintf(1, "Error (in '%s' line %ld); " - "only [%ld] Params allowed in Tokens [%s]\n", - ChrPtr(pTmpl->FileName), - NewToken->Line, - MAXPARAM, - ChrPtr(NewToken->FlatToken)); - free(Param); + LogTemplateError( + NULL, "Parseerror", ERR_NAME, &TP, + "only [%d] Params allowed in Tokens", + MAXPARAM); + FreeToken(&NewToken); return NULL; } - NewToken->Params[NewToken->nParameters++] = Param; } else break; } @@ -894,80 +1037,89 @@ WCTemplateToken *NewTemplateSubstitute(StrBuf *Buf, if (GetHash(GlobalNS, NewToken->pName, NewToken->NameEnd, &vVar)) { HashHandler *Handler; Handler = (HashHandler*) vVar; - if ((NewToken->nParameters < Handler->nMinArgs) || - (NewToken->nParameters > Handler->nMaxArgs)) { - lprintf(1, "Handler [%s] (in '%s' line %ld); " - "doesn't work with %ld params [%s]\n", - NewToken->pName, - ChrPtr(pTmpl->FileName), - NewToken->Line, - NewToken->nParameters, - ChrPtr(NewToken->FlatToken)); + if ((NewToken->nParameters < Handler->Filter.nMinArgs) || + (NewToken->nParameters > Handler->Filter.nMaxArgs)) { + LogTemplateError( + NULL, "Token", ERR_NAME, &TP, + "doesn't work with %d params", + NewToken->nParameters); + } else { NewToken->PreEval = Handler; NewToken->Flags = SV_PREEVALUATED; + if (Handler->PreEvalFunc != NULL) + Handler->PreEvalFunc(NewToken); } } break; case SV_GETTEXT: if (NewToken->nParameters !=1) { - lprintf(1, "Gettext (in '%s' line %ld); " - "requires exactly 1 parameter, you gave %ld params [%s]\n", - ChrPtr(pTmpl->FileName), - NewToken->Line, - NewToken->nParameters, - ChrPtr(NewToken->FlatToken)); + LogTemplateError( + NULL, "Gettext", ERR_NAME, &TP, + "requires exactly 1 parameter, you gave %d params", + NewToken->nParameters); NewToken->Flags = 0; break; } + if (DumpTemplateI18NStrings) { + StrBufAppendPrintf(I18nDump, "_(\"%s\");\n", NewToken->Params[0]->Start); + } break; case SV_SUBTEMPL: if (NewToken->nParameters != 1) { - lprintf(1, "Subtemplates (in '%s' line %ld); " - "require exactly 1 parameter, you gave %ld params [%s]\n", - ChrPtr(pTmpl->FileName), - NewToken->Line, - NewToken->nParameters, - ChrPtr(NewToken->FlatToken)); + LogTemplateError( + NULL, "Subtemplates", ERR_NAME, &TP, + "require exactly 1 parameter, you gave %d params", + NewToken->nParameters); break; } + else { + void *vTmpl; + /* well, we don't check the mobile stuff here... */ + if (!GetHash(LocalTemplateCache, + NewToken->Params[0]->Start, + NewToken->Params[0]->len, + &vTmpl) && + !GetHash(TemplateCache, + NewToken->Params[0]->Start, + NewToken->Params[0]->len, + &vTmpl)) { + LogTemplateError( + NULL, "SubTemplate", ERR_PARM1, &TP, + "doesn't exist"); + } + } break; case SV_CUST_STR_CONDITIONAL: case SV_CONDITIONAL: case SV_NEG_CONDITIONAL: if (NewToken->nParameters <2) { - lprintf(1, "Conditional (in '%s' line %ld); " - "require at least 2 parameters, you gave %ld params [%s]\n", - ChrPtr(pTmpl->FileName), - NewToken->Line, - NewToken->nParameters, - ChrPtr(NewToken->FlatToken)); + LogTemplateError( + NULL, "Conditional", ERR_PARM1, &TP, + "require at least 2 parameters, you gave %d params", + NewToken->nParameters); NewToken->Flags = 0; break; } if (NewToken->Params[1]->lvalue == 0) { - lprintf(1, "Conditional (in '%s' line %ld); " - "Conditional ID mustn't be 0! [%s]\n", - ChrPtr(pTmpl->FileName), - NewToken->Line, - ChrPtr(NewToken->FlatToken)); + LogTemplateError( + NULL, "Conditional", ERR_PARM1, &TP, + "Conditional ID (Parameter 1) mustn't be 0!"); NewToken->Flags = 0; break; } if (!GetHash(Conditionals, - NewToken->Params[0]->Start, - NewToken->Params[0]->len, + NewToken->Params[0]->Start, + NewToken->Params[0]->len, &vVar) || (vVar == NULL)) { if ((NewToken->Params[0]->len == 1) && (NewToken->Params[0]->Start[0] == 'X')) break; - lprintf(1, "Conditional [%s] (in '%s' line %ld); Not found![%s]\n", - NewToken->Params[0]->Start, - ChrPtr(pTmpl->FileName), - NewToken->Line, - ChrPtr(NewToken->FlatToken)); + LogTemplateError( + NULL, "Conditional", ERR_PARM1, &TP, + "Not found!"); /* NewToken->Error = NewStrBuf(); StrBufAppendPrintf( @@ -998,12 +1150,23 @@ WCTemplateToken *NewTemplateSubstitute(StrBuf *Buf, void *prepare_template(StrBuf *filename, StrBuf *Key, HashList *PutThere) { WCTemplate *NewTemplate; + NewTemplate = (WCTemplate *) malloc(sizeof(WCTemplate)); + memset(NewTemplate, 0, sizeof(WCTemplate)); NewTemplate->Data = NULL; NewTemplate->FileName = NewStrBufDup(filename); + StrBufShrinkToFit(NewTemplate->FileName, 1); 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); + } + + 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; @@ -1013,44 +1176,60 @@ void *prepare_template(StrBuf *filename, StrBuf *Key, HashList *PutThere) * \brief Display a variable-substituted template * \param templatename template file to load */ -void *load_template(StrBuf *filename, StrBuf *Key, HashList *PutThere) +void *duplicate_template(WCTemplate *OldTemplate) +{ + WCTemplate *NewTemplate; + + NewTemplate = (WCTemplate *) malloc(sizeof(WCTemplate)); + memset(NewTemplate, 0, sizeof(WCTemplate)); + NewTemplate->Data = NULL; + NewTemplate->FileName = NewStrBufDup(OldTemplate->FileName); + StrBufShrinkToFit(NewTemplate->FileName, 1); + NewTemplate->nTokensUsed = 0; + NewTemplate->TokenSpace = 0; + NewTemplate->Tokens = NULL; + NewTemplate->MimeType = NewStrBufDup(OldTemplate->MimeType); + return NewTemplate; +} + +/** + * \brief Display a variable-substituted template + * \param templatename template file to load + */ +void *load_template(WCTemplate *NewTemplate) { int fd; struct stat statbuf; const char *pS, *pE, *pch, *Err; long Line; int pos; - WCTemplate *NewTemplate; - fd = open(ChrPtr(filename), O_RDONLY); + fd = open(ChrPtr(NewTemplate->FileName), O_RDONLY); if (fd <= 0) { lprintf(1, "ERROR: could not open template '%s' - %s\n", - ChrPtr(filename), strerror(errno)); + ChrPtr(NewTemplate->FileName), strerror(errno)); return NULL; } if (fstat(fd, &statbuf) == -1) { lprintf(1, "ERROR: could not stat template '%s' - %s\n", - ChrPtr(filename), strerror(errno)); + ChrPtr(NewTemplate->FileName), strerror(errno)); return NULL; } - NewTemplate = (WCTemplate *) malloc(sizeof(WCTemplate)); - NewTemplate->Data = NewStrBufPlain(NULL, statbuf.st_size); - NewTemplate->FileName = NewStrBufDup(filename); - NewTemplate->nTokensUsed = 0; - NewTemplate->TokenSpace = 0; - NewTemplate->Tokens = NULL; + 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)); + ChrPtr(NewTemplate->FileName), strerror(errno)); + //FreeWCTemplate(NewTemplate);/////tODO return NULL; } close(fd); Line = 0; + StrBufShrinkToFit(NewTemplate->Data, 1); + StrBufShrinkToFit(NewTemplate->MimeType, 1); pS = pch = ChrPtr(NewTemplate->Data); pE = pS + StrLength(NewTemplate->Data); while (pch < pE) { @@ -1061,7 +1240,11 @@ void *load_template(StrBuf *filename, StrBuf *Key, HashList *PutThere) /** Find one */ pos = (-1); for (; pch < pE; pch ++) { - if ((*pch=='<')&&(*(pch + 1)=='?')) + if ((*pch=='<')&&(*(pch + 1)=='?') && + !((pch == pS) && /* we must ommit a Data, pS, pts, pte, Line, NewTemplate)); pch ++; } - if (LoadTemplates == 0) - Put(PutThere, ChrPtr(Key), StrLength(Key), NewTemplate, FreeWCTemplate); return NewTemplate; } -///void PrintTemplate(const char *Key, void *vSubst, int odd) const char* PrintTemplate(void *vSubst) { WCTemplate *Tmpl = vSubst; @@ -1103,74 +1283,212 @@ const char* PrintTemplate(void *vSubst) } -int LoadTemplateDir(const char *DirName, HashList *wireless, HashList *big) +int LoadTemplateDir(const StrBuf *DirName, HashList *wireless, HashList *big, const StrBuf *BaseKey) { + int Toplevel; StrBuf *FileName; - StrBuf *Tag; - StrBuf *Dir; + StrBuf *Key; + StrBuf *SubKey; + StrBuf *SubDirectory; DIR *filedir = NULL; struct dirent *filedir_entry; + struct dirent *d; + int d_type = 0; int d_namelen; int d_without_ext; int IsMobile; - Dir = NewStrBuf(); - StrBufPrintf(Dir, "%s/t", DirName); - filedir = opendir (ChrPtr(Dir)); + d = (struct dirent *)malloc(offsetof(struct dirent, d_name) + PATH_MAX + 1); + if (d == NULL) { + return 0; + } + + filedir = opendir (ChrPtr(DirName)); if (filedir == NULL) { - FreeStrBuf(&Dir); + free(d); return 0; } - FileName = NewStrBuf(); - Tag = NewStrBuf(); - while ((filedir_entry = readdir(filedir))) + Toplevel = StrLength(BaseKey) == 0; + SubDirectory = NewStrBuf(); + SubKey = NewStrBuf(); + FileName = NewStrBufPlain(NULL, PATH_MAX); + Key = NewStrBuf(); + while ((readdir_r(filedir, d, &filedir_entry) == 0) && + (filedir_entry != NULL)) { char *MinorPtr; char *PStart; #ifdef _DIRENT_HAVE_D_NAMELEN d_namelen = filedir_entry->d_namelen; + d_type = filedir_entry->d_type; #else + +#ifndef DT_UNKNOWN +#define DT_UNKNOWN 0 +#define DT_DIR 4 +#define DT_REG 8 +#define DT_LNK 10 + +#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; - while ((d_without_ext > 0) && (filedir_entry->d_name[d_without_ext] != '.')) - d_without_ext --; - if ((d_without_ext == 0) || (d_namelen < 3)) - continue; + if ((d_namelen > 1) && filedir_entry->d_name[d_namelen - 1] == '~') continue; /* Ignore backup files... */ - IsMobile = (strstr(filedir_entry->d_name, ".m.html")!= NULL); - PStart = filedir_entry->d_name; - StrBufPrintf(FileName, "%s/%s", ChrPtr(Dir), filedir_entry->d_name); - MinorPtr = strchr(filedir_entry->d_name, '.'); - if (MinorPtr != NULL) - *MinorPtr = '\0'; - StrBufPlain(Tag, filedir_entry->d_name, MinorPtr - filedir_entry->d_name); + if ((d_namelen == 1) && + (filedir_entry->d_name[0] == '.')) + continue; - if (LoadTemplates > 1) - lprintf(1, "%s %d %s\n",ChrPtr(FileName), IsMobile, ChrPtr(Tag)); - if (LoadTemplates == 0) - load_template(FileName, Tag, (IsMobile)?wireless:big); - else - prepare_template(FileName, Tag, (IsMobile)?wireless:big); + if ((d_namelen == 2) && + (filedir_entry->d_name[0] == '.') && + (filedir_entry->d_name[1] == '.')) + continue; + + if (d_type == DT_UNKNOWN) { + struct stat s; + char path[PATH_MAX]; + snprintf(path, PATH_MAX, "%s/%s", + ChrPtr(DirName), filedir_entry->d_name); + if (stat(path, &s) == 0) { + d_type = IFTODT(s.st_mode); + } + } + switch (d_type) + { + case DT_DIR: + /* Skip directories we are not interested in... */ + if (strcmp(filedir_entry->d_name, ".svn") == 0) + continue; + + FlushStrBuf(SubKey); + if (!Toplevel) { + /* If we're not toplevel, the upper dirs count as foo_bar_*/ + StrBufAppendBuf(SubKey, BaseKey, 0); + StrBufAppendBufPlain(SubKey, HKEY("_"), 0); + } + StrBufAppendBufPlain(SubKey, filedir_entry->d_name, d_namelen, 0); + + FlushStrBuf(SubDirectory); + StrBufAppendBuf(SubDirectory, DirName, 0); + if (ChrPtr(SubDirectory)[StrLength(SubDirectory) - 1] != '/') + StrBufAppendBufPlain(SubDirectory, HKEY("/"), 0); + StrBufAppendBufPlain(SubDirectory, filedir_entry->d_name, d_namelen, 0); + + LoadTemplateDir(SubDirectory, wireless, big, SubKey); + + break; + case DT_LNK: /* TODO: check whether its a file or a directory */ + case DT_REG: + + + while ((d_without_ext > 0) && (filedir_entry->d_name[d_without_ext] != '.')) + d_without_ext --; + if ((d_without_ext == 0) || (d_namelen < 3)) + continue; + if (((d_namelen > 1) && filedir_entry->d_name[d_namelen - 1] == '~') || + (strcmp(&filedir_entry->d_name[d_without_ext], ".orig") == 0) || + (strcmp(&filedir_entry->d_name[d_without_ext], ".swp") == 0)) + continue; /* Ignore backup files... */ + /* .m.xxx is for mobile useragents! */ + IsMobile = 0; + if (d_without_ext > 2) + IsMobile = (filedir_entry->d_name[d_without_ext - 1] == 'm') && + (filedir_entry->d_name[d_without_ext - 2] == '.'); + PStart = filedir_entry->d_name; + StrBufPrintf(FileName, "%s/%s", ChrPtr(DirName), filedir_entry->d_name); + MinorPtr = strchr(filedir_entry->d_name, '.'); + if (MinorPtr != NULL) + *MinorPtr = '\0'; + FlushStrBuf(Key); + if (!Toplevel) { + /* If we're not toplevel, the upper dirs count as foo_bar_*/ + StrBufAppendBuf(Key, BaseKey, 0); + StrBufAppendBufPlain(Key, HKEY("_"), 0); + } + StrBufAppendBufPlain(Key, filedir_entry->d_name, MinorPtr - filedir_entry->d_name, 0); + + if (LoadTemplates >= 1) + lprintf(1, "%s %d %s\n", ChrPtr(FileName), IsMobile, ChrPtr(Key)); + prepare_template(FileName, Key, (IsMobile)?wireless:big); + default: + break; + } } + free(d); closedir(filedir); FreeStrBuf(&FileName); - FreeStrBuf(&Tag); - FreeStrBuf(&Dir); + FreeStrBuf(&Key); + FreeStrBuf(&SubDirectory); + FreeStrBuf(&SubKey); return 1; } void InitTemplateCache(void) { - LoadTemplateDir(static_dirs[0], + int i; + StrBuf *Key; + StrBuf *Dir; + HashList *Templates[4]; + + Dir = NewStrBuf(); + Key = NewStrBuf(); + + /* Primary Template set... */ + StrBufPrintf(Dir, "%s/t", static_dirs[0]); + LoadTemplateDir(Dir, WirelessTemplateCache, - TemplateCache); - LoadTemplateDir(static_dirs[1], + TemplateCache, + Key); + + /* User local Template set */ + StrBufPrintf(Dir, "%s/t", static_dirs[1]); + LoadTemplateDir(Dir, WirelessLocalTemplateCache, - LocalTemplateCache); + LocalTemplateCache, + Key); + + /* Debug Templates, just to be loaded while debugging. */ + + StrBufPrintf(Dir, "%s/dbg", static_dirs[0]); + LoadTemplateDir(Dir, + WirelessTemplateCache, + TemplateCache, + Key); + Templates[0] = WirelessTemplateCache; + Templates[1] = TemplateCache; + Templates[2] = WirelessLocalTemplateCache; + Templates[3] = LocalTemplateCache; + + + if (LoadTemplates == 0) + for (i=0; i < 4; i++) { + const char *Key; + long KLen; + HashPos *At; + void *vTemplate; + + At = GetNewHashPos(Templates[i], 0); + while (GetNextHashPos(Templates[i], + At, + &KLen, + &Key, + &vTemplate) && + (vTemplate != NULL)) + { + load_template((WCTemplate *)vTemplate); + } + DeleteHashPos(&At); + } + + + FreeStrBuf(&Dir); + FreeStrBuf(&Key); } @@ -1187,36 +1505,38 @@ void InitTemplateCache(void) * \param state are we in conditional state? * \param ContextType what type of information does context giv us? */ -int EvaluateToken(StrBuf *Target, WCTemplateToken *Tokens, WCTemplate *pTmpl, void *Context, int state, int ContextType) +int EvaluateToken(StrBuf *Target, int state, WCTemplputParams *TP) { const char *AppendMe; long AppendMeLen; HashHandler *Handler; void *vVar; -// much output, since pName is not terminated... -// lprintf(1,"Doing token: %s\n",Token->pName); + +/* much output, since pName is not terminated... + lprintf(1,"Doing token: %s\n",Token->pName); +*/ - switch (Tokens->Flags) { + switch (TP->Tokens->Flags) { case SV_GETTEXT: - TmplGettext(Target, Tokens->nParameters, Tokens); + TmplGettext(Target, TP); break; case SV_CONDITIONAL: /** Forward conditional evaluation */ - return EvaluateConditional(Target, Tokens, pTmpl, Context, 1, state, ContextType); + return EvaluateConditional(Target, 1, state, TP); break; case SV_NEG_CONDITIONAL: /** Reverse conditional evaluation */ - return EvaluateConditional(Target, Tokens, pTmpl, Context, 0, state, ContextType); + return EvaluateConditional(Target, 0, state, TP); break; case SV_CUST_STR_CONDITIONAL: /** Conditional put custom strings from params */ - if (Tokens->nParameters >= 6) { - if (EvaluateConditional(Target, Tokens, pTmpl, Context, 0, state, ContextType)) { - GetTemplateTokenString(Tokens, 5, &AppendMe, &AppendMeLen); + if (TP->Tokens->nParameters >= 6) { + if (EvaluateConditional(Target, 0, state, TP)) { + GetTemplateTokenString(Target, TP, 5, &AppendMe, &AppendMeLen); StrBufAppendBufPlain(Target, AppendMe, AppendMeLen, 0); } else{ - GetTemplateTokenString(Tokens, 4, &AppendMe, &AppendMeLen); + GetTemplateTokenString(Target, TP, 4, &AppendMe, &AppendMeLen); StrBufAppendBufPlain(Target, AppendMe, AppendMeLen, @@ -1224,110 +1544,36 @@ int EvaluateToken(StrBuf *Target, WCTemplateToken *Tokens, WCTemplate *pTmpl, vo } } else { - lprintf(1, "Conditional [%s] (in '%s' line %ld); needs at least 6 Params![%s]\n", - Tokens->Params[0]->Start, - ChrPtr(pTmpl->FileName), - Tokens->Line, - ChrPtr(Tokens->FlatToken)); - StrBufAppendPrintf( - Target, - "
\nConditional [%s] (in '%s' line %ld); needs 6 Params!\n[%s]\n
\n", - Tokens->Params[0]->Start, - ChrPtr(pTmpl->FileName), - Tokens->Line, - ChrPtr(Tokens->FlatToken)); + LogTemplateError( + Target, "Conditional", ERR_NAME, TP, + "needs at least 6 Params!"); } break; case SV_SUBTEMPL: - if (Tokens->nParameters == 1) - DoTemplate(Tokens->Params[0]->Start, Tokens->Params[0]->len, NULL, NULL, ContextType); + if (TP->Tokens->nParameters == 1) + DoTemplate(TKEY(0), Target, TP); break; case SV_PREEVALUATED: - Handler = (HashHandler*) Tokens->PreEval; - if ((Handler->ContextRequired != CTX_NONE) && - (Handler->ContextRequired != ContextType)) { - lprintf(1, "Handler [%s] (in '%s' line %ld); " - "requires context of type %ld, have %ld [%s]\n", - Tokens->pName, - ChrPtr(pTmpl->FileName), - Tokens->Line, - Handler->ContextRequired, - ContextType, - ChrPtr(Tokens->FlatToken)); - StrBufAppendPrintf( - Target, - "
\nHandler [%s] (in '%s' line %ld);"
-				" requires context of type %ld, have %ld!\n[%s]\n
\n", - Tokens->pName, - ChrPtr(pTmpl->FileName), - Tokens->Line, - Handler->ContextRequired, - ContextType, - ChrPtr(Tokens->FlatToken)); + Handler = (HashHandler*) TP->Tokens->PreEval; + if (!CheckContext(Target, &Handler->Filter, TP, "Token")) { return -1; - } - Handler->HandlerFunc(Target, - Tokens->nParameters, - Tokens, - Context, - ContextType); + Handler->HandlerFunc(Target, TP); break; default: - if (GetHash(GlobalNS, Tokens->pName, Tokens->NameEnd, &vVar)) { + if (GetHash(GlobalNS, TP->Tokens->pName, TP->Tokens->NameEnd, &vVar)) { Handler = (HashHandler*) vVar; - if ((Handler->ContextRequired != CTX_NONE) && - (Handler->ContextRequired != ContextType)) { - lprintf(1, "Handler [%s] (in '%s' line %ld); " - "requires context of type %ld, have %ld [%s]\n", - Tokens->pName, - ChrPtr(pTmpl->FileName), - Tokens->Line, - Handler->ContextRequired, - ContextType, - ChrPtr(Tokens->FlatToken)); - StrBufAppendPrintf( - Target, - "
\nHandler [%s] (in '%s' line %ld);"
-					" requires context of type %ld, have %ld!\n[%s]\n
\n", - Tokens->pName, - ChrPtr(pTmpl->FileName), - Tokens->Line, - Handler->ContextRequired, - ContextType, - ChrPtr(Tokens->FlatToken)); + if (!CheckContext(Target, &Handler->Filter, TP, "Token")) { return -1; } - else if ((Tokens->nParameters < Handler->nMinArgs) || - (Tokens->nParameters > Handler->nMaxArgs)) { - lprintf(1, "Handler [%s] (in '%s' line %ld); " - "doesn't work with %ld params [%s]\n", - Tokens->pName, - ChrPtr(pTmpl->FileName), - Tokens->Line, - Tokens->nParameters, - ChrPtr(Tokens->FlatToken)); - StrBufAppendPrintf( - Target, - "
\nHandler [%s] (in '%s' line %ld);"
-					" doesn't work with %ld params!\n[%s]\n
\n", - Tokens->pName, - ChrPtr(pTmpl->FileName), - Tokens->Line, - Tokens->nParameters, - ChrPtr(Tokens->FlatToken)); - } else { - Handler->HandlerFunc(Target, - Tokens->nParameters, - Tokens, - Context, - ContextType); /*TODO: subset of that */ - + Handler->HandlerFunc(Target, TP); } } else { - print_value_of(Target, Tokens, Context, ContextType); + LogTemplateError( + Target, "Token UNKNOWN", ERR_NAME, TP, + "You've specified a token that isn't known to webcit.!"); } } return 0; @@ -1335,26 +1581,32 @@ int EvaluateToken(StrBuf *Target, WCTemplateToken *Tokens, WCTemplate *pTmpl, vo -void ProcessTemplate(WCTemplate *Tmpl, StrBuf *Target, void *Context, int ContextType) +const StrBuf *ProcessTemplate(WCTemplate *Tmpl, StrBuf *Target, WCTemplputParams *CallingTP) { WCTemplate *pTmpl = Tmpl; int done = 0; int i, state; const char *pData, *pS; long len; + WCTemplputParams TP; + + memcpy(&TP.Filter, &CallingTP->Filter, sizeof(ContextFilter)); + + TP.Context = CallingTP->Context; + TP.ControlContext = CallingTP->ControlContext; if (LoadTemplates != 0) { if (LoadTemplates > 1) lprintf(1, "DBG: ----- loading: [%s] ------ \n", ChrPtr(Tmpl->FileName)); - - pTmpl = load_template(Tmpl->FileName, NULL, NULL); - if(pTmpl == NULL) { + pTmpl = duplicate_template(Tmpl); + if(load_template(pTmpl) == NULL) { StrBufAppendPrintf( Target, "
\nError loading Template [%s]\n See Logfile for details\n
\n", ChrPtr(Tmpl->FileName)); - return; + FreeWCTemplate(pTmpl); + return NULL; } } @@ -1374,20 +1626,22 @@ void ProcessTemplate(WCTemplate *Tmpl, StrBuf *Target, void *Context, int Contex StrBufAppendBufPlain( Target, pData, pTmpl->Tokens[i]->pTokenStart - pData, 0); - state = EvaluateToken(Target, pTmpl->Tokens[i], pTmpl, Context, state, ContextType); + TP.Tokens = pTmpl->Tokens[i]; + TP.nArgs = pTmpl->Tokens[i]->nParameters; + state = EvaluateToken(Target, state, &TP); + while ((state != 0) && (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; if ((pTmpl->Tokens[i]->Flags == SV_CONDITIONAL) || (pTmpl->Tokens[i]->Flags == SV_NEG_CONDITIONAL)) { if (state == EvaluateConditional( - Target, - pTmpl->Tokens[i], - pTmpl, - Context, - pTmpl->Tokens[i]->Flags, + Target, + pTmpl->Tokens[i]->Flags, state, - ContextType)) + &TP)) state = 0; } } @@ -1399,21 +1653,30 @@ void ProcessTemplate(WCTemplate *Tmpl, StrBuf *Target, void *Context, int Contex if (LoadTemplates != 0) { FreeWCTemplate(pTmpl); } + return Tmpl->MimeType; + } /** * \brief Display a variable-substituted template * \param templatename template file to load + * \returns the mimetype of the template its doing */ -void DoTemplate(const char *templatename, long len, StrBuf *Target, void *Context, int ContextType) +const StrBuf *DoTemplate(const char *templatename, long len, StrBuf *Target, WCTemplputParams *TP) { + WCTemplputParams LocalTP; HashList *Static; HashList *StaticLocal; void *vTmpl; if (Target == NULL) Target = WC->WBuf; - if (WC->is_mobile) { + if (TP == NULL) { + memset(&LocalTP, 0, sizeof(WCTemplputParams)); + TP = &LocalTP; + } + + if (WC->is_mobile > 0) { Static = WirelessTemplateCache; StaticLocal = WirelessLocalTemplateCache; } @@ -1426,7 +1689,7 @@ void DoTemplate(const char *templatename, long len, StrBuf *Target, void *Contex { lprintf (1, "Can't to load a template with empty name!\n"); StrBufAppendPrintf(Target, "
\nCan't to load a template with empty name!\n
"); - return; + return NULL; } if (!GetHash(StaticLocal, templatename, len, &vTmpl) && @@ -1435,13 +1698,34 @@ void DoTemplate(const char *templatename, long len, StrBuf *Target, void *Contex StrBufAppendPrintf(Target, "
\ndidn't find Template [%s] %ld %ld\n
", templatename, len, (long)strlen(templatename)); -/// dbg_PrintHash(Static, PrintTemplate, NULL); -// PrintHash(Static, VarPrintTransition, PrintTemplate); - return; +#if 0 + dbg_PrintHash(Static, PrintTemplate, NULL); + PrintHash(Static, VarPrintTransition, PrintTemplate); +#endif + return NULL; } if (vTmpl == NULL) - return; - ProcessTemplate(vTmpl, Target, Context, ContextType); + return NULL; + 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); + } } /*----------------------------------------------------------------------------- @@ -1452,6 +1736,7 @@ typedef struct _HashIterator { int AdditionalParams; int ContextType; int XPectContextType; + int Flags; RetrieveHashlistFunc GetHash; HashDestructorFunc Destructor; SubTemplFunc DoSubTemplate; @@ -1464,9 +1749,13 @@ void RegisterITERATOR(const char *Name, long len, SubTemplFunc DoSubTempl, HashDestructorFunc Destructor, int ContextType, - int XPectContextType) + int XPectContextType, + int Flags) { - HashIterator *It = (HashIterator*)malloc(sizeof(HashIterator)); + HashIterator *It; + + It = (HashIterator*)malloc(sizeof(HashIterator)); + memset(It, 0, sizeof(HashIterator)); It->StaticList = StaticList; It->AdditionalParams = AdditionalParams; It->GetHash = GetHash; @@ -1474,115 +1763,170 @@ void RegisterITERATOR(const char *Name, long len, It->Destructor = Destructor; It->ContextType = ContextType; It->XPectContextType = XPectContextType; + It->Flags = Flags; Put(Iterators, Name, len, It, NULL); } -void tmpl_iterate_subtmpl(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void *Context, int ContextType) +typedef struct _iteratestruct { + int GroupChange; + int oddeven; + const char *Key; + long KeyLen; + int n; + int LastN; + }IterateStruct; + +int preeval_iterate(WCTemplateToken *Token) { + WCTemplputParams TPP; + WCTemplputParams *TP; + void *vTmpl; void *vIt; HashIterator *It; + + memset(&TPP, 0, sizeof(WCTemplputParams)); + TP = &TPP; + TP->Tokens = Token; + if (!GetHash(Iterators, TKEY(0), &vIt)) { + LogTemplateError( + NULL, "Iterator", ERR_PARM1, TP, + "not found"); + return 0; + } + if (TP->Tokens->Params[1]->Type != TYPE_SUBTEMPLATE) { + LogTemplateError(NULL, "Iterator", ERR_PARM1, TP, + "Need token with type Subtemplate as param 1, have %s", + TP->Tokens->Params[1]->Start); + } + + /* well, we don't check the mobile stuff here... */ + if (!GetHash(LocalTemplateCache, TKEY(1), &vTmpl) && + !GetHash(TemplateCache, TKEY(1), &vTmpl)) { + LogTemplateError(NULL, "SubTemplate", ERR_PARM1, TP, + "referenced here doesn't exist"); + } + Token->Preeval2 = vIt; + It = (HashIterator *) vIt; + + if (TP->Tokens->nParameters < It->AdditionalParams + 2) { + LogTemplateError( + NULL, "Iterator", ERR_PARM1, TP, + "doesn't work with %d params", + TP->Tokens->nParameters); + } + + + return 1; +} + +void tmpl_iterate_subtmpl(StrBuf *Target, WCTemplputParams *TP) +{ + HashIterator *It; HashList *List; HashPos *it; + SortStruct *SortBy = NULL; + void *vSortBy; + int DetectGroupChange = 0; int nMembersUsed; - int nMembersCounted = 0; - long len; - const char *Key; void *vContext; + void *vLastContext = NULL; StrBuf *SubBuf; - int oddeven = 0; + WCTemplputParams SubTP; + IterateStruct Status; + + long StartAt = 0; + long StepWidth = 0; + long StopAt = -1; + + memset(&Status, 0, sizeof(IterateStruct)); + memcpy (&SubTP, &TP, sizeof(WCTemplputParams)); - if (!GetHash(Iterators, - Tokens->Params[0]->Start, - Tokens->Params[0]->len, - &vIt)) { - lprintf(1, "unknown Iterator [%s] (in '%s' line %ld); " - " [%s]\n", - Tokens->Params[0]->Start, - ChrPtr(Tokens->FileName), - Tokens->Line, - ChrPtr(Tokens->FlatToken)); - StrBufAppendPrintf( - Target, - "
\nunknown Iterator [%s] (in '%s' line %ld); \n"
-			" [%s]\n
", - Tokens->Params[0]->Start, - ChrPtr(Tokens->FileName), - Tokens->Line, - ChrPtr(Tokens->FlatToken)); + It = (HashIterator*) TP->Tokens->Preeval2; + if (It == NULL) { + LogTemplateError( + Target, "Iterator", ERR_PARM1, TP, "Unknown!"); return; } - It = (HashIterator*) vIt; - - if (Tokens->nParameters < It->AdditionalParams + 2) { - lprintf(1, "Iterator [%s] (in '%s' line %ld); " - "doesn't work with %ld params [%s]\n", - Tokens->Params[0]->Start, - ChrPtr(Tokens->FileName), - Tokens->Line, - Tokens->nParameters, - ChrPtr(Tokens->FlatToken)); - StrBufAppendPrintf( - Target, - "
Iterator [%s] \n(in '%s' line %ld);\n"
-			"doesn't work with %ld params \n[%s]\n
", - Tokens->Params[0]->Start, - ChrPtr(Tokens->FileName), - Tokens->Line, - Tokens->nParameters, - ChrPtr(Tokens->FlatToken)); + if (TP->Tokens->nParameters < It->AdditionalParams + 2) { + LogTemplateError( + Target, "Iterator", ERR_PARM1, TP, + "doesn't work with %d params", + TP->Tokens->nParameters - 1); return; } if ((It->XPectContextType != CTX_NONE) && - (It->XPectContextType != ContextType)) { - lprintf(1, "Iterator [%s] (in '%s' line %ld); " - "requires context of type %ld, have %ld [%s]\n", - Tokens->pName, - ChrPtr(Tokens->FileName), - Tokens->Line, - It->XPectContextType, - ContextType, - ChrPtr(Tokens->FlatToken)); - StrBufAppendPrintf( - Target, - "
\nIterator [%s] (in '%s' line %ld);"
-			" requires context of type %ld, have %ld!\n[%s]\n
\n", - Tokens->pName, - ChrPtr(Tokens->FileName), - Tokens->Line, - It->XPectContextType, - ContextType, - ChrPtr(Tokens->FlatToken)); + (It->XPectContextType != TP->Filter.ContextType)) { + LogTemplateError( + Target, "Iterator", ERR_PARM1, TP, + "requires context of type %s, have %s", + ContextName(It->XPectContextType), + ContextName(TP->Filter.ContextType)); return ; } if (It->StaticList == NULL) - List = It->GetHash(Target, nArgs, Tokens, Context, ContextType); + List = It->GetHash(Target, TP); else List = It->StaticList; + DetectGroupChange = (It->Flags & IT_FLAG_DETECT_GROUPCHANGE) != 0; + if (DetectGroupChange) { + const StrBuf *BSort; + DetectGroupChange = 0; + if (havebstr("SortBy")) { + BSort = sbstr("SortBy"); + if (GetHash(SortHash, SKEY(BSort), &vSortBy) && + (vSortBy != NULL)) { + SortBy = (SortStruct*)vSortBy; + /** Ok, its us, lets see in which direction we should sort... */ + if (havebstr("SortOrder")) { + int SortOrder; + SortOrder = LBSTR("SortOrder"); + if (SortOrder != 0) + DetectGroupChange = 1; + } + } + } + } nMembersUsed = GetCount(List); SubBuf = NewStrBuf(); - it = GetNewHashPos(List, 0); - while (GetNextHashPos(List, it, &len, &Key, &vContext)) { - svprintf(HKEY("ITERATE:ODDEVEN"), WCS_STRING, "%s", - (oddeven) ? "odd" : "even"); - svprintf(HKEY("ITERATE:KEY"), WCS_STRING, "%s", Key); - svputlong("ITERATE:N", nMembersCounted); - svputlong("ITERATE:LASTN", ++nMembersCounted == nMembersUsed); - - if (It->DoSubTemplate != NULL) - It->DoSubTemplate(SubBuf, vContext, Tokens); - DoTemplate(Tokens->Params[1]->Start, - Tokens->Params[1]->len, - SubBuf, vContext, - It->ContextType); + SubTP.Filter.ContextType = It->ContextType; + SubTP.Filter.ControlContextType = CTX_ITERATE; + SubTP.ControlContext = &Status; + + 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); + } + 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); - oddeven = ~ oddeven; + StrBufAppendBuf(Target, SubBuf, 0); + FlushStrBuf(SubBuf); + Status.oddeven = ! Status.oddeven; + vLastContext = vContext; + } + Status.n++; } FreeStrBuf(&SubBuf); DeleteHashPos(&it); @@ -1591,155 +1935,241 @@ void tmpl_iterate_subtmpl(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, vo } +int conditional_ITERATE_ISGROUPCHANGE(StrBuf *Target, WCTemplputParams *TP) +{ + IterateStruct *Ctx = CCTX; + if (TP->Tokens->nParameters < 3) + return Ctx->GroupChange; + + return TP->Tokens->Params[2]->lvalue == Ctx->GroupChange; +} + +void tmplput_ITERATE_ODDEVEN(StrBuf *Target, WCTemplputParams *TP) +{ + IterateStruct *Ctx = CCTX; + if (Ctx->oddeven) + StrBufAppendBufPlain(Target, HKEY("odd"), 0); + else + StrBufAppendBufPlain(Target, HKEY("even"), 0); +} + + +void tmplput_ITERATE_KEY(StrBuf *Target, WCTemplputParams *TP) +{ + IterateStruct *Ctx = CCTX; + + StrBufAppendBufPlain(Target, Ctx->Key, Ctx->KeyLen, 0); +} + + +void tmplput_ITERATE_LASTN(StrBuf *Target, WCTemplputParams *TP) +{ + IterateStruct *Ctx = CCTX; + StrBufAppendPrintf(Target, "%d", Ctx->n); +} + +int conditional_ITERATE_FIRSTN(StrBuf *Target, WCTemplputParams *TP) +{ + IterateStruct *Ctx = CCTX; + return Ctx->n == 0; +} + +int conditional_ITERATE_LASTN(StrBuf *Target, WCTemplputParams *TP) +{ + IterateStruct *Ctx = CCTX; + return Ctx->LastN; +} + + /*----------------------------------------------------------------------------- * Conditionals */ -int EvaluateConditional(StrBuf *Target, WCTemplateToken *Tokens, WCTemplate *pTmpl, void *Context, int Neg, int state, int ContextType) +int EvaluateConditional(StrBuf *Target, int Neg, int state, WCTemplputParams *TP) { ConditionalStruct *Cond; - if ((Tokens->Params[0]->len == 1) && - (Tokens->Params[0]->Start[0] == 'X')) - return (state != 0)?Tokens->Params[1]->lvalue:0; + if ((TP->Tokens->Params[0]->len == 1) && + (TP->Tokens->Params[0]->Start[0] == 'X')) + return (state != 0)?TP->Tokens->Params[1]->lvalue:0; - Cond = (ConditionalStruct *) Tokens->PreEval; + Cond = (ConditionalStruct *) TP->Tokens->PreEval; if (Cond == NULL) { - lprintf(1, "Conditional [%s] (in '%s' line %ld); unknown![%s]\n", - Tokens->Params[0]->Start, - ChrPtr(pTmpl->FileName), - Tokens->Line, - ChrPtr(Tokens->FlatToken)); + LogTemplateError( + Target, "Conditional", ERR_PARM1, TP, + "unknown!"); return 1; } - if (Tokens->nParameters < Cond->nParams) { - lprintf(1, "Conditional [%s] (in '%s' line %ld); needs %ld Params![%s]\n", - Tokens->Params[0]->Start, - ChrPtr(pTmpl->FileName), - Tokens->Line, - Cond->nParams, - ChrPtr(Tokens->FlatToken)); - StrBufAppendPrintf( - Target, - "
\nConditional [%s] (in '%s' line %ld); needs %ld Params!\n[%s]\n
\n", - Tokens->Params[0]->Start, - ChrPtr(pTmpl->FileName), - Tokens->Line, - Cond->nParams, - ChrPtr(Tokens->FlatToken)); + if (!CheckContext(Target, &Cond->Filter, TP, "Conditional")) { return 0; } - if (Cond->CondF(Tokens, Context, ContextType) == Neg) - return Tokens->Params[1]->lvalue; - return 0; -} -int ConditionalVar(WCTemplateToken *Tokens, void *Context, int ContextType) -{ - void *vsubst; - wcsubst *subst; - - if (!GetHash(WC->vars, - Tokens->Params[2]->Start, - Tokens->Params[2]->len, - &vsubst)) - return 0; - subst = (wcsubst*) vsubst; - if ((subst->ContextRequired != CTX_NONE) && - (subst->ContextRequired != ContextType)) { - lprintf(1," WARNING: Conditional requires Context: [%ld]!\n", Tokens->Params[2]->Start); - return -1; - } - - 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 (Tokens->nParameters < 4) - return 1; - return (strcmp(Tokens->Params[3]->Start, ChrPtr(subst->wcs_value)) == 0); - case WCS_LONG: - if (Tokens->nParameters < 4) - return (subst->lvalue != 0); - return (subst->lvalue == Tokens->Params[3]->lvalue); - default: - lprintf(1," WARNING: invalid type: [%ld]!\n", subst->wcs_type); - return -1; - } + if (Cond->CondF(Target, TP) == Neg) + return TP->Tokens->Params[1]->lvalue; return 0; } - void RegisterConditional(const char *Name, long len, int nParams, WCConditionalFunc CondF, int ContextRequired) { - ConditionalStruct *Cond = (ConditionalStruct*)malloc(sizeof(ConditionalStruct)); + ConditionalStruct *Cond; + + 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); +} + +void RegisterControlConditional(const char *Name, long len, + int nParams, + WCConditionalFunc CondF, + int ControlContextRequired) +{ + ConditionalStruct *Cond; + + Cond = (ConditionalStruct*)malloc(sizeof(ConditionalStruct)); + memset(Cond, 0, sizeof(ConditionalStruct)); Cond->PlainName = Name; - Cond->nParams = nParams; + Cond->Filter.nMaxArgs = nParams; + Cond->Filter.nMinArgs = nParams; Cond->CondF = CondF; - Cond->ContextRequired = ContextRequired; + Cond->Filter.ContextType = CTX_NONE; + Cond->Filter.ControlContextType = ControlContextRequired; Put(Conditionals, Name, len, Cond, NULL); } +void RegisterTokenParamDefine(const char *Name, long len, + long Value) +{ + long *PVal; + + PVal = (long*)malloc(sizeof(long)); + *PVal = Value; + 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; + /*----------------------------------------------------------------------------- * Context Strings */ -void tmplput_ContextString(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void *Context, int ContextType) +void tmplput_ContextString(StrBuf *Target, WCTemplputParams *TP) { - StrBufAppendTemplate(Target, nArgs, Tokens, Context, ContextType, (StrBuf*)Context, 0); + StrBufAppendTemplate(Target, TP, (StrBuf*)CTX, 0); } -int ConditionalContextStr(WCTemplateToken *Tokens, void *Context, int ContextType) +int ConditionalContextStr(StrBuf *Target, WCTemplputParams *TP) { - StrBuf *TokenText = (StrBuf*) Context; + StrBuf *TokenText = (StrBuf*) CTX; const char *CompareToken; long len; - GetTemplateTokenString(Tokens, 2, &CompareToken, &len); + GetTemplateTokenString(Target, TP, 2, &CompareToken, &len); 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 */ -void tmpl_do_boxed(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void *Context, int ContextType) +void tmpl_do_boxed(StrBuf *Target, WCTemplputParams *TP) { - StrBuf *Headline; - if (nArgs == 2) { - if (Tokens->Params[1]->Type == TYPE_STR) { + WCTemplputParams SubTP; + + StrBuf *Headline = NULL; + if (TP->Tokens->nParameters == 2) { + if (TP->Tokens->Params[1]->Type == TYPE_STR) { Headline = NewStrBuf(); - DoTemplate(Tokens->Params[1]->Start, - Tokens->Params[1]->len, - Headline, - Context, - ContextType); + DoTemplate(TKEY(1), Headline, TP); } else { const char *Ch; long len; - GetTemplateTokenString(Tokens, + GetTemplateTokenString(Target, + TP, 1, &Ch, &len); Headline = NewStrBufPlain(Ch, len); } } - - DoTemplate(HKEY("beginbox"), Target, Headline, CTX_STRBUF); - DoTemplate(Tokens->Params[0]->Start, - Tokens->Params[0]->len, - Target, - Context, - ContextType); - DoTemplate(HKEY("endbox"), Target, Context, ContextType); + /* else TODO error? logging? */ + memcpy (&SubTP, TP, sizeof(WCTemplputParams)); + SubTP.Context = Headline; + SubTP.Filter.ContextType = CTX_STRBUF; + DoTemplate(HKEY("beginbox"), Target, &SubTP); + DoTemplate(TKEY(0), Target, TP); + DoTemplate(HKEY("endbox"), Target, TP); FreeStrBuf(&Headline); } @@ -1747,71 +2177,155 @@ void tmpl_do_boxed(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void *Con * Tabbed-API */ -void tmpl_do_tabbed(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void *Context, int ContextType) +typedef struct _tab_struct { + long CurrentTab; + StrBuf *TabTitle; +} tab_struct; + +int preeval_do_tabbed(WCTemplateToken *Token) +{ + WCTemplputParams TPP; + WCTemplputParams *TP; + const char *Ch; + long len; + int i, nTabs; + + + memset(&TPP, 0, sizeof(WCTemplputParams)); + TP = &TPP; + TP->Tokens = Token; + nTabs = TP->Tokens->nParameters / 2 - 1; + if (TP->Tokens->nParameters % 2 != 0) + { + LogTemplateError(NULL, "TabbedApi", ERR_PARM1, TP, + "need even number of arguments"); + return 0; + + } + else for (i = 0; i < nTabs; i++) { + if (!HaveTemplateTokenString(NULL, + TP, + i * 2, + &Ch, + &len) || + (TP->Tokens->Params[i * 2]->len == 0)) + { + LogTemplateError(NULL, "TabbedApi", ERR_PARM1, TP, + "Tab-Subject %d needs to be able to produce a string, have %s", + i, TP->Tokens->Params[i * 2]->Start); + return 0; + } + if (!HaveTemplateTokenString(NULL, + TP, + i * 2 + 1, + &Ch, + &len) || + (TP->Tokens->Params[i * 2 + 1]->len == 0)) + { + LogTemplateError(NULL, "TabbedApi", ERR_PARM1, TP, + "Tab-Content %d needs to be able to produce a string, have %s", + i, TP->Tokens->Params[i * 2 + 1]->Start); + return 0; + } + } + + if (!HaveTemplateTokenString(NULL, + TP, + i * 2 + 1, + &Ch, + &len) || + (TP->Tokens->Params[i * 2 + 1]->len == 0)) + { + LogTemplateError(NULL, "TabbedApi", ERR_PARM1, TP, + "Tab-Content %d needs to be able to produce a string, have %s", + i, TP->Tokens->Params[i * 2 + 1]->Start); + return 0; + } + return 1; +} + + +void tmpl_do_tabbed(StrBuf *Target, WCTemplputParams *TP) { StrBuf **TabNames; int i, ntabs, nTabs; + tab_struct TS; + WCTemplputParams SubTP; + + memset(&TS, 0, sizeof(tab_struct)); + memcpy (&SubTP, &TP, sizeof(WCTemplputParams)); - nTabs = ntabs = Tokens->nParameters / 2; + nTabs = ntabs = TP->Tokens->nParameters / 2; TabNames = (StrBuf **) malloc(ntabs * sizeof(StrBuf*)); + memset(TabNames, 0, ntabs * sizeof(StrBuf*)); for (i = 0; i < ntabs; i++) { - TabNames[i] = NewStrBuf(); - if (Tokens->Params[i * 2]->len > 0) { - DoTemplate(Tokens->Params[i * 2]->Start, - Tokens->Params[i * 2]->len, - TabNames[i], - Context, - ContextType); + if ((TP->Tokens->Params[i * 2]->Type == TYPE_STR) && + (TP->Tokens->Params[i * 2]->len > 0)) { + TabNames[i] = NewStrBuf(); + DoTemplate(TKEY(i * 2), TabNames[i], TP); + } + else if (TP->Tokens->Params[i * 2]->Type == TYPE_GETTEXT) { + const char *Ch; + long len; + GetTemplateTokenString(Target, + TP, + i * 2, + &Ch, + &len); + TabNames[i] = NewStrBufPlain(Ch, -1); } else { /** A Tab without subject? we can't count that, add it as silent */ nTabs --; } } + memcpy (&SubTP, TP, sizeof(WCTemplputParams)); + SubTP.Filter.ControlContextType = CTX_TAB; + SubTP.ControlContext = &TS; StrTabbedDialog(Target, nTabs, TabNames); for (i = 0; i < ntabs; i++) { - StrBeginTab(Target, i, nTabs); - - DoTemplate(Tokens->Params[i * 2 + 1]->Start, - Tokens->Params[i * 2 + 1]->len, - Target, - Context, - ContextType); + memset(&TS, 0, sizeof(tab_struct)); + TS.CurrentTab = i; + TS.TabTitle = TabNames[i]; + StrBeginTab(Target, i, nTabs, TabNames); + DoTemplate(TKEY(i * 2 + 1), Target, &SubTP); StrEndTab(Target, i, nTabs); } + for (i = 0; i < ntabs; i++) + FreeStrBuf(&TabNames[i]); } +void tmplput_TAB_N(StrBuf *Target, WCTemplputParams *TP) +{ + tab_struct *Ctx = CCTX; + + StrBufAppendPrintf(Target, "%d", Ctx->CurrentTab); +} + +void tmplput_TAB_TITLE(StrBuf *Target, WCTemplputParams *TP) +{ + tab_struct *Ctx = CCTX; + StrBufAppendTemplate(Target, TP, Ctx->TabTitle, 0); +} /*----------------------------------------------------------------------------- * Sorting-API */ -typedef struct _SortStruct { - StrBuf *Name; - StrBuf *PrefPrepend; - CompareFunc Forward; - CompareFunc Reverse; - - long ContextType; -}SortStruct; - -void DestroySortStruct(void *vSort) -{ - SortStruct *Sort = (SortStruct*) vSort; - FreeStrBuf(&Sort->Name); - FreeStrBuf(&Sort->PrefPrepend); - free (Sort); -} void RegisterSortFunc(const char *name, long len, const char *prepend, long preplen, CompareFunc Forward, CompareFunc Reverse, + CompareFunc GroupChange, long ContextType) { - SortStruct *NewSort = (SortStruct*) malloc(sizeof(SortStruct)); + SortStruct *NewSort; + + NewSort = (SortStruct*) malloc(sizeof(SortStruct)); + memset(NewSort, 0, sizeof(SortStruct)); NewSort->Name = NewStrBufPlain(name, len); if (prepend != NULL) NewSort->PrefPrepend = NewStrBufPlain(prepend, preplen); @@ -1819,28 +2333,49 @@ void RegisterSortFunc(const char *name, long len, NewSort->PrefPrepend = NULL; NewSort->Forward = Forward; NewSort->Reverse = Reverse; + NewSort->GroupChange = GroupChange; NewSort->ContextType = ContextType; + if (ContextType == CTX_NONE) { + lprintf(1, "sorting requires a context. CTX_NONE won't make it.\n"); + exit(1); + } + Put(SortHash, name, len, NewSort, DestroySortStruct); } -CompareFunc RetrieveSort(long ContextType, const char *OtherPrefix, +CompareFunc RetrieveSort(WCTemplputParams *TP, + const char *OtherPrefix, long OtherPrefixLen, const char *Default, long ldefault, long DefaultDirection) { int isdefault = 0; - const StrBuf *BSort; + const StrBuf *BSort = NULL; SortStruct *SortBy; void *vSortBy; - long SortOrder; + long SortOrder = -1; if (havebstr("SortBy")) { BSort = sbstr("SortBy"); + if (OtherPrefix == NULL) { + set_room_pref("sort", NewStrBufDup(BSort), 0); + } + else { + set_X_PREFS(HKEY("sort"), OtherPrefix, OtherPrefixLen, NewStrBufDup(BSort), 0); + } } else { /** Try to fallback to our remembered values... */ if (OtherPrefix == NULL) { BSort = get_room_pref("sort"); } else { - ////todo: nail prefprepend to sort, and lookup this! + BSort = get_X_PREFS(HKEY("sort"), OtherPrefix, OtherPrefixLen); + } + if (BSort != NULL) + putbstr("SortBy", NewStrBufDup(BSort)); + else { + StrBuf *Buf; + + BSort = Buf = NewStrBufPlain(Default, ldefault); + putbstr("SortBy", Buf); } } @@ -1849,23 +2384,37 @@ CompareFunc RetrieveSort(long ContextType, const char *OtherPrefix, isdefault = 1; if (!GetHash(SortHash, Default, ldefault, &vSortBy) || (vSortBy == NULL)) { - lprintf(1, "Illegal default sort: [%s]\n", Default); + LogTemplateError( + NULL, "Sorting", ERR_PARM1, TP, + "Illegal default sort: [%s]", Default); wc_backtrace(); } } SortBy = (SortStruct*)vSortBy; + if (SortBy->ContextType != TP->Filter.ContextType) + return NULL; + /** Ok, its us, lets see in which direction we should sort... */ if (havebstr("SortOrder")) { SortOrder = LBSTR("SortOrder"); } else { /** Try to fallback to our remembered values... */ + StrBuf *Buf = NULL; if (SortBy->PrefPrepend == NULL) { - SortOrder = StrTol(get_room_pref("SortOrder")); + Buf = get_room_pref("SortOrder"); + SortOrder = StrTol(Buf); } else { - ////todo: nail prefprepend to sort, and lookup this! + BSort = get_X_PREFS(HKEY("SortOrder"), OtherPrefix, OtherPrefixLen); } + + if (Buf == NULL) + SortOrder = DefaultDirection; + + Buf = NewStrBufPlain(NULL, 64); + StrBufPrintf(Buf, "%ld", SortOrder); + putbstr("SortOrder", Buf); } switch (SortOrder) { default: @@ -1899,7 +2448,7 @@ ConstStr SortNextOrder[] = { }; -int GetSortMetric(WCTemplateToken *Tokens, SortStruct **Next, SortStruct **Param, long *SortOrder) +int GetSortMetric(WCTemplputParams *TP, SortStruct **Next, SortStruct **Param, long *SortOrder, int N) { int bSortError = eNOT_SPECIFIED; const StrBuf *BSort; @@ -1907,7 +2456,7 @@ int GetSortMetric(WCTemplateToken *Tokens, SortStruct **Next, SortStruct **Param *SortOrder = 0; *Next = NULL; - if (!GetHash(SortHash, Tokens->Params[0]->Start, Tokens->Params[0]->len, &vSort) || + if (!GetHash(SortHash, TKEY(0), &vSort) || (vSort == NULL)) return eNO_SUCH_SORT; *Param = (SortStruct*) vSort; @@ -1916,13 +2465,19 @@ int GetSortMetric(WCTemplateToken *Tokens, SortStruct **Next, SortStruct **Param if (havebstr("SortBy")) { BSort = sbstr("SortBy"); bSortError = eINVALID_PARAM; + if ((*Param)->PrefPrepend == NULL) { + set_room_pref("sort", NewStrBufDup(BSort), 0); + } + else { + set_X_PREFS(HKEY("sort"), TKEY(N), NewStrBufDup(BSort), 0); + } } else { /** Try to fallback to our remembered values... */ if ((*Param)->PrefPrepend == NULL) { BSort = get_room_pref("sort"); } else { - ////todo: nail prefprepend to sort, and lookup this! + BSort = get_X_PREFS(HKEY("sort"), TKEY(N)); } } @@ -1941,7 +2496,7 @@ int GetSortMetric(WCTemplateToken *Tokens, SortStruct **Next, SortStruct **Param *SortOrder = StrTol(get_room_pref("SortOrder")); } else { - ////todo: nail prefprepend to sort, and lookup this! + *SortOrder = StrTol(get_X_PREFS(HKEY("SortOrder"), TKEY(N))); } } if (*SortOrder > 2) @@ -1951,40 +2506,24 @@ int GetSortMetric(WCTemplateToken *Tokens, SortStruct **Next, SortStruct **Param } -void tmplput_SORT_ICON(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void *Context, int ContextType) +void tmplput_SORT_ICON(StrBuf *Target, WCTemplputParams *TP) { long SortOrder; SortStruct *Next; SortStruct *Param; const ConstStr *SortIcon; - switch (GetSortMetric(Tokens, &Next, &Param, &SortOrder)){ + switch (GetSortMetric(TP, &Next, &Param, &SortOrder, 2)){ case eNO_SUCH_SORT: - lprintf(1, "[%s] (in '%s' line %ld); " - " Sorter [%s] unknown! [%s]\n", - Tokens->pName, - ChrPtr(Tokens->FileName), - Tokens->Line, - Tokens->Params[0]->Start, - ChrPtr(Tokens->FlatToken)); - StrBufAppendPrintf( - Target, - "
\n [%s] (in '%s' line %ld);"
-			" Sorter [%s] unknown!\n[%s]\n
\n", - Tokens->pName, - ChrPtr(Tokens->FileName), - Tokens->Line, - Tokens->Params[0]->Start, - ChrPtr(Tokens->FlatToken)); + LogTemplateError( + Target, "Sorter", ERR_PARM1, TP, + " Sorter [%s] unknown!", + TP->Tokens->Params[0]->Start); break; case eINVALID_PARAM: - lprintf(1, "[%s] (in '%s' line %ld); " - " Sorter specified by BSTR 'SortBy' [%s] unknown! [%s]\n", - Tokens->pName, - ChrPtr(Tokens->FileName), - Tokens->Line, - bstr("SortBy"), - ChrPtr(Tokens->FlatToken)); + LogTemplateError(NULL, "Sorter", ERR_PARM1, TP, + " Sorter specified by BSTR 'SortBy' [%s] unknown!", + bstr("SortBy")); case eNOT_SPECIFIED: case eFOUND: if (Next == Param) { @@ -1997,40 +2536,24 @@ void tmplput_SORT_ICON(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void } } -void tmplput_SORT_NEXT(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void *Context, int ContextType) +void tmplput_SORT_NEXT(StrBuf *Target, WCTemplputParams *TP) { long SortOrder; SortStruct *Next; SortStruct *Param; - switch (GetSortMetric(Tokens, &Next, &Param, &SortOrder)){ + switch (GetSortMetric(TP, &Next, &Param, &SortOrder, 2)){ case eNO_SUCH_SORT: - lprintf(1, "[%s] (in '%s' line %ld); " - " Sorter [%s] unknown! [%s]\n", - Tokens->pName, - ChrPtr(Tokens->FileName), - Tokens->Line, - Tokens->Params[0]->Start, - ChrPtr(Tokens->FlatToken)); - StrBufAppendPrintf( - Target, - "
\n [%s] (in '%s' line %ld);"
-			" Sorter [%s] unknown!\n[%s]\n
\n", - Tokens->pName, - ChrPtr(Tokens->FileName), - Tokens->Line, - Tokens->Params[0]->Start, - ChrPtr(Tokens->FlatToken)); + LogTemplateError( + Target, "Sorter", ERR_PARM1, TP, + " Sorter [%s] unknown!", + TP->Tokens->Params[0]->Start); break; case eINVALID_PARAM: - lprintf(1, "[%s] (in '%s' line %ld); " - " Sorter specified by BSTR 'SortBy' [%s] unknown! [%s]\n", - Tokens->pName, - ChrPtr(Tokens->FileName), - Tokens->Line, - bstr("SortBy"), - ChrPtr(Tokens->FlatToken)); - + LogTemplateError( + NULL, "Sorter", ERR_PARM1, TP, + " Sorter specified by BSTR 'SortBy' [%s] unknown!", + bstr("SortBy")); case eNOT_SPECIFIED: case eFOUND: StrBufAppendBuf(Target, Param->Name, 0); @@ -2038,41 +2561,25 @@ void tmplput_SORT_NEXT(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void } } -void tmplput_SORT_ORDER(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void *Context, int ContextType) +void tmplput_SORT_ORDER(StrBuf *Target, WCTemplputParams *TP) { long SortOrder; const ConstStr *SortOrderStr; SortStruct *Next; SortStruct *Param; - switch (GetSortMetric(Tokens, &Next, &Param, &SortOrder)){ + switch (GetSortMetric(TP, &Next, &Param, &SortOrder, 2)){ case eNO_SUCH_SORT: - lprintf(1, "[%s] (in '%s' line %ld); " - " Sorter [%s] unknown! [%s]\n", - Tokens->pName, - ChrPtr(Tokens->FileName), - Tokens->Line, - Tokens->Params[0]->Start, - ChrPtr(Tokens->FlatToken)); - StrBufAppendPrintf( - Target, - "
\n [%s] (in '%s' line %ld);"
-			" Sorter [%s] unknown!\n[%s]\n
\n", - Tokens->pName, - ChrPtr(Tokens->FileName), - Tokens->Line, - Tokens->Params[0]->Start, - ChrPtr(Tokens->FlatToken)); + LogTemplateError( + Target, "Sorter", ERR_PARM1, TP, + " Sorter [%s] unknown!", + TP->Tokens->Params[0]->Start); break; case eINVALID_PARAM: - lprintf(1, "[%s] (in '%s' line %ld); " - " Sorter specified by BSTR 'SortBy' [%s] unknown! [%s]\n", - Tokens->pName, - ChrPtr(Tokens->FileName), - Tokens->Line, - bstr("SortBy"), - ChrPtr(Tokens->FlatToken)); - + LogTemplateError( + NULL, "Sorter", ERR_PARM1, TP, + " Sorter specified by BSTR 'SortBy' [%s] unknown!", + bstr("SortBy")); case eNOT_SPECIFIED: case eFOUND: if (Next == Param) { @@ -2086,107 +2593,198 @@ void tmplput_SORT_ORDER(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void } -void tmplput_long_vector(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void *Context, int ContextType) +void tmplput_long_vector(StrBuf *Target, WCTemplputParams *TP) { - long *LongVector = (long*) Context; + long *LongVector = (long*) CTX; - if ((Tokens->Params[0]->Type == TYPE_LONG) && - (Tokens->Params[0]->lvalue <= LongVector[0])) + if ((TP->Tokens->Params[0]->Type == TYPE_LONG) && + (TP->Tokens->Params[0]->lvalue <= LongVector[0])) { - StrBufAppendPrintf(Target, "%ld", LongVector[Tokens->Params[0]->lvalue]); + StrBufAppendPrintf(Target, "%ld", LongVector[TP->Tokens->Params[0]->lvalue]); } else { - if (Tokens->Params[0]->Type == TYPE_LONG) { - lprintf(1, "longvector [%s] (in '%s' line %ld); needs a long Parameter![%s]\n", - Tokens->Params[0]->Start, - ChrPtr(Tokens->FileName), - Tokens->Line, - ChrPtr(Tokens->FlatToken)); - StrBufAppendPrintf( - Target, - "
\nlongvector [%s] (in '%s' line %ld); needs a numerical Parameter!\n[%s]\n
\n", - Tokens->Params[0]->Start, - ChrPtr(Tokens->FileName), - Tokens->Line, - ChrPtr(Tokens->FlatToken)); + if (TP->Tokens->Params[0]->Type != TYPE_LONG) { + LogTemplateError( + Target, "Longvector", ERR_NAME, TP, + "needs a numerical Parameter!"); } else { - lprintf(1, "longvector [%s] (in '%s' line %ld); doesn't have %ld Parameters," - " its just the size of %ld![%s]\n", - Tokens->Params[0]->Start, - ChrPtr(Tokens->FileName), - Tokens->Line, - Tokens->Params[0]->lvalue, - LongVector[0], - ChrPtr(Tokens->FlatToken)); - StrBufAppendPrintf( - Target, - "
\nlongvector [%s] (in '%s' line %ld); doesn't have %ld Parameters,"
-				" its just the size of %ld!\n[%s]\n
\n", - Tokens->Params[0]->Start, - ChrPtr(Tokens->FileName), - Tokens->Line, - Tokens->Params[0]->lvalue, - LongVector[0], - ChrPtr(Tokens->FlatToken)); + LogTemplateError( + Target, "LongVector", ERR_PARM1, TP, + "doesn't have %ld Parameters, its just the size of %ld!", + TP->Tokens->Params[0]->lvalue, + LongVector[0]); } } } +void dbg_print_longvector(long *LongVector) +{ + StrBuf *Buf = NewStrBufPlain(HKEY("Longvector: [")); + int nItems = LongVector[0]; + int i; + + for (i = 0; i < nItems; i++) { + if (i + 1 < nItems) + StrBufAppendPrintf(Buf, "%d: %ld | ", i, LongVector[i]); + else + StrBufAppendPrintf(Buf, "%d: %ld]\n", i, LongVector[i]); + } + lprintf(1, ChrPtr(Buf)); + FreeStrBuf(&Buf); +} -int ConditionalLongVector(WCTemplateToken *Tokens, void *Context, int ContextType) +int ConditionalLongVector(StrBuf *Target, WCTemplputParams *TP) { - long *LongVector = (long*) Context; + long *LongVector = (long*) CTX; - if ((Tokens->Params[2]->Type == TYPE_LONG) && - (Tokens->Params[2]->lvalue <= LongVector[0])&& - (Tokens->Params[3]->Type == TYPE_LONG) && - (Tokens->Params[3]->lvalue <= LongVector[0])) + if ((TP->Tokens->Params[2]->Type == TYPE_LONG) && + (TP->Tokens->Params[2]->lvalue <= LongVector[0])&& + (TP->Tokens->Params[3]->Type == TYPE_LONG) && + (TP->Tokens->Params[3]->lvalue <= LongVector[0])) { - return LongVector[Tokens->Params[2]->lvalue] == LongVector[Tokens->Params[3]->lvalue]; + return LongVector[TP->Tokens->Params[2]->lvalue] == + LongVector[TP->Tokens->Params[3]->lvalue]; } else { - if ((Tokens->Params[2]->Type == TYPE_LONG) || - (Tokens->Params[2]->Type == TYPE_LONG)) { - lprintf(1, "ConditionalLongVector [%s] (in '%s' line %ld); needs two long Parameter![%s]\n", - Tokens->Params[0]->Start, - ChrPtr(Tokens->FileName), - Tokens->Line, - ChrPtr(Tokens->FlatToken)); + if ((TP->Tokens->Params[2]->Type == TYPE_LONG) || + (TP->Tokens->Params[2]->Type == TYPE_LONG)) { + LogTemplateError( + Target, "ConditionalLongvector", ERR_PARM1, TP, + "needs two long Parameter!"); } else { - lprintf(1, "longvector [%s] (in '%s' line %ld); doesn't have %ld / %ld Parameters," - " its just the size of %ld![%s]\n", - Tokens->Params[0]->Start, - ChrPtr(Tokens->FileName), - Tokens->Line, - Tokens->Params[2]->lvalue, - Tokens->Params[3]->lvalue, - LongVector[0], - ChrPtr(Tokens->FlatToken)); + LogTemplateError( + Target, "Longvector", ERR_PARM1, TP, + "doesn't have %ld / %ld Parameters, its just the size of %ld!", + TP->Tokens->Params[2]->lvalue, + TP->Tokens->Params[3]->lvalue, + LongVector[0]); } } return 0; } + +void tmplput_CURRENT_FILE(StrBuf *Target, WCTemplputParams *TP) +{ + StrBufAppendTemplate(Target, TP, TP->Tokens->FileName, 0); +} + void InitModule_SUBST (void) { - RegisterNamespace("SORT:ICON", 1, 1, tmplput_SORT_ICON, CTX_NONE); - RegisterNamespace("SORT:ORDER", 1, 1, tmplput_SORT_ORDER, CTX_NONE); - RegisterNamespace("SORT:NEXT", 1, 1, tmplput_SORT_NEXT, CTX_NONE); - RegisterNamespace("CONTEXTSTR", 0, 1, tmplput_ContextString, CTX_STRBUF); - RegisterNamespace("ITERATE", 2, 100, tmpl_iterate_subtmpl, CTX_NONE); - RegisterNamespace("DOBOXED", 1, 2, tmpl_do_boxed, CTX_NONE); - RegisterNamespace("DOTABBED", 2, 100, tmpl_do_tabbed, CTX_NONE); - RegisterNamespace("LONGVECTOR", 1, 1, tmplput_long_vector, CTX_LONGVECTOR); - RegisterConditional(HKEY("COND:SUBST"), 3, ConditionalVar, CTX_NONE); + 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, preeval_do_tabbed, CTX_NONE); + RegisterControlNS(HKEY("TAB:N"), 0, 0, tmplput_TAB_N, CTX_TAB); + RegisterControlNS(HKEY("TAB:SUBJECT"), 0, 1, tmplput_TAB_TITLE, CTX_TAB); + + + RegisterNamespace("LONGVECTOR", 1, 1, tmplput_long_vector, NULL, CTX_LONGVECTOR); + + RegisterConditional(HKEY("COND:CONTEXTSTR"), 3, ConditionalContextStr, CTX_STRBUF); + RegisterConditional(HKEY("COND:CONTEXTSTRARR"), 4, ConditionalContextStrinArray, CTX_STRBUFARR); RegisterConditional(HKEY("COND:LONGVECTOR"), 4, ConditionalLongVector, CTX_LONGVECTOR); + + + RegisterControlConditional(HKEY("COND:ITERATE:ISGROUPCHANGE"), 2, + conditional_ITERATE_ISGROUPCHANGE, + CTX_ITERATE); + 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); + 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); + + + + +} + +void +ServerStartModule_SUBST +(void) +{ + WirelessTemplateCache = NewHash(1, NULL); + WirelessLocalTemplateCache = NewHash(1, NULL); + 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); +} + +void +FinalizeModule_SUBST +(void) +{ + +} + +void +ServerShutdownModule_SUBST +(void) +{ + DeleteHash(&WirelessTemplateCache); + DeleteHash(&WirelessLocalTemplateCache); + DeleteHash(&TemplateCache); + DeleteHash(&LocalTemplateCache); + + DeleteHash(&GlobalNS); + DeleteHash(&Iterators); + DeleteHash(&Conditionals); + DeleteHash(&SortHash); + DeleteHash(&Defines); +} + + +void +SessionNewModule_SUBST +(wcsession *sess) +{ + +} + +void +SessionAttachModule_SUBST +(wcsession *sess) +{ +} + +void +SessionDetachModule_SUBST +(wcsession *sess) +{ + FreeStrBuf(&sess->WFBuf); } -/*@}*/ +void +SessionDestroyModule_SUBST +(wcsession *sess) +{ + +}