X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=webcit%2Fsubst.c;h=28afdebc850c96d350fd8684f0c31f9914794f66;hb=808f3be91dd6b6677e380695e2f16e6473141a7e;hp=4fea084856abc38041e5f0dcde5365099e1e1633;hpb=b26952cb66e9f6b4971aa97cdde0425b39f3f944;p=citadel.git diff --git a/webcit/subst.c b/webcit/subst.c index 4fea08485..28afdebc8 100644 --- a/webcit/subst.c +++ b/webcit/subst.c @@ -14,6 +14,8 @@ #include #include #include +#include +#define SHOW_ME_VAPPEND_PRINTF #include "webcit.h" #include "webserver.h" @@ -26,37 +28,109 @@ HashList *TemplateCache; HashList *LocalTemplateCache; HashList *GlobalNS; +HashList *Iterators; +HashList *Conditionals; +HashList *SortHash; -typedef struct _TemplateToken { - const char *pTokenStart; - size_t TokenStart; - size_t TokenEnd; - const char *pTokenEnd; +int LoadTemplates = 0; +WCTemplputParams NoCtx; - const char *pName; - size_t NameEnd; - - int HaveParameters; - int nParameters; - size_t ParamStart [10]; - size_t ParamEnd [10]; -} WCTemplateToken; +#define SV_GETTEXT 1 +#define SV_CONDITIONAL 2 +#define SV_NEG_CONDITIONAL 3 +#define SV_CUST_STR_CONDITIONAL 4 +#define SV_SUBTEMPL 5 +#define SV_PREEVALUATED 6 typedef struct _WCTemplate { StrBuf *Data; + StrBuf *FileName; int nTokensUsed; int TokenSpace; WCTemplateToken **Tokens; } WCTemplate; -typedef void (*WCHandlerFunc)(int nArgs, WCTemplateToken **Tokens); /*TODO: subset of that */ typedef struct _HashHandler { int nMinArgs; int nMaxArgs; + int ContextRequired; WCHandlerFunc HandlerFunc; }HashHandler; -void RegisterNS(const char *NSName, long len, int nMinArgs, int nMaxArgs, WCHandlerFunc HandlerFunc) +void *load_template(StrBuf *filename, StrBuf *Key, HashList *PutThere); +int EvaluateConditional(StrBuf *Target, int Neg, int state, WCTemplputParams *TP); + +typedef struct _SortStruct { + StrBuf *Name; + StrBuf *PrefPrepend; + CompareFunc Forward; + CompareFunc Reverse; + CompareFunc GroupChange; + + long ContextType; +}SortStruct; + +void DestroySortStruct(void *vSort) +{ + SortStruct *Sort = (SortStruct*) vSort; + FreeStrBuf(&Sort->Name); + FreeStrBuf(&Sort->PrefPrepend); + free (Sort); +} + +void LogTemplateError (StrBuf *Target, const char *Type, int ErrorPos, WCTemplputParams *TP, const char *Format, ...) +{ + 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) { + default: + case ERR_NAME: /* the main token name... */ + Err = TP->Tokens->pName; + break; + case ERR_PARM1: + Err = TP->Tokens->Params[0]->Start; + break; + case ERR_PARM2: + Err = TP->Tokens->Params[1]->Start; + break; + } + 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)); + if (Target != NULL) { + 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)); + } +} + + +void RegisterNS(const char *NSName, + long len, + int nMinArgs, + int nMaxArgs, + WCHandlerFunc HandlerFunc, + int ContextRequired) { HashHandler *NewHandler; @@ -64,9 +138,39 @@ void RegisterNS(const char *NSName, long len, int nMinArgs, int nMaxArgs, WCHand 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; +} + + + +void FreeWCTemplate(void *vFreeMe) +{ + int i; + WCTemplate *FreeMe = (WCTemplate*)vFreeMe; + + 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 @@ -83,10 +187,10 @@ void VarPrintEntry(const char *Key, void *vSubst, int odd) switch(ptr->wcs_type) { case WCS_STRING: - lprintf(1, " -> %s\n", ptr->wcs_value); + lprintf(1, " -> %s\n", ChrPtr(ptr->wcs_value)); break; case WCS_SERVCMD: - lprintf(1, " -> Server [%s]\n", ptr->wcs_value); + lprintf(1, " -> Server [%s]\n", ChrPtr(ptr->wcs_value)); break; case WCS_FUNCTION: lprintf(1, " -> function at [%0xd]\n", ptr->wcs_function); @@ -101,10 +205,9 @@ void VarPrintEntry(const char *Key, void *vSubst, int odd) /** * \brief Clear out the list of substitution variables local to this session */ -void clear_substs(struct wcsession *wc) { +void clear_substs(wcsession *wc) { if (wc->vars != NULL) { - DeleteHash(&wc->vars); } } @@ -116,19 +219,99 @@ void clear_local_substs(void) { clear_substs (WC); } +int NeedNewBuf(type) +{ + switch(type) { + case WCS_STRING: + case WCS_SERVCMD: + case WCS_STRBUF: + return 1; + case WCS_FUNCTION: + case WCS_STRBUF_REF: + case WCS_LONG: + default: + return 0; + } +} + +void FlushPayload(wcsubst *ptr, int reusestrbuf, int type) +{ + int NeedNew = NeedNewBuf(type); + switch(ptr->wcs_type) { + case WCS_STRING: + case WCS_SERVCMD: + case WCS_STRBUF: + if (reusestrbuf && NeedNew) { + FlushStrBuf(ptr->wcs_value); + } + else { + + FreeStrBuf(&ptr->wcs_value); + ptr->wcs_value = NULL; + } + break; + case WCS_FUNCTION: + ptr->wcs_function = NULL; + if (reusestrbuf && NeedNew) + ptr->wcs_value = NewStrBuf(); + break; + case WCS_STRBUF_REF: + ptr->wcs_value = NULL; + if (reusestrbuf && NeedNew) + ptr->wcs_value = NewStrBuf(); + break; + case WCS_LONG: + ptr->lvalue = 0; + if (reusestrbuf && NeedNew) + ptr->wcs_value = NewStrBuf(); + break; + default: + if (reusestrbuf && NeedNew) + ptr->wcs_value = NewStrBuf(); + break; + } +} + + /** * \brief destructor; kill one entry. */ void deletevar(void *data) { wcsubst *ptr = (wcsubst*)data; -// if ((wc->vars->wcs_type == WCS_STRING) -// || (wc->vars->wcs_type == WCS_SERVCMD)) { - if (ptr->wcs_type != WCS_FUNCTION) - free(ptr->wcs_value); + FlushPayload(ptr, 0, ptr->wcs_type); free(ptr); } + +wcsubst *NewSubstVar(const char *keyname, int keylen, int type) +{ + wcsubst* ptr; + wcsession *WCC = WC; + + ptr = (wcsubst *) malloc(sizeof(wcsubst)); + memset(ptr, 0, sizeof(wcsubst)); + + ptr->wcs_type = type; + safestrncpy(ptr->wcs_key, keyname, sizeof ptr->wcs_key); + Put(WCC->vars, keyname, keylen, ptr, deletevar); + + switch(ptr->wcs_type) { + case WCS_STRING: + case WCS_SERVCMD: + ptr->wcs_value = NewStrBuf(); + break; + case WCS_STRBUF: + case WCS_FUNCTION: + case WCS_STRBUF_REF: + case WCS_LONG: + default: + break; + } + return ptr; +} + + /** * \brief Add a substitution variable (local to this session) (strlen version...) * \param keyname the replacementstring to substitute @@ -139,11 +322,10 @@ void deletevar(void *data) void SVPRINTF(char *keyname, int keytype, const char *format,...) { va_list arg_ptr; - char wbuf[SIZ]; void *vPtr; wcsubst *ptr = NULL; size_t keylen; - struct wcsession *WCC = WC; + wcsession *WCC = WC; keylen = strlen(keyname); /** @@ -153,25 +335,18 @@ void SVPRINTF(char *keyname, int keytype, const char *format,...) /*PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/ if (GetHash(WCC->vars, keyname, keylen, &vPtr)) { ptr = (wcsubst*)vPtr; - if (ptr->wcs_value != NULL) - free(ptr->wcs_value); + FlushPayload(ptr, keytype, keytype); + ptr->wcs_type = keytype; } else /** Otherwise allocate a new one */ { - ptr = (wcsubst *) malloc(sizeof(wcsubst)); - safestrncpy(ptr->wcs_key, keyname, sizeof ptr->wcs_key); - Put(WCC->vars, keyname, keylen, ptr, deletevar); + ptr = NewSubstVar(keyname, keylen, keytype); } - /** Format the string and save it */ - + /** Format the string */ va_start(arg_ptr, format); - vsnprintf(wbuf, sizeof wbuf, format, arg_ptr); + StrBufVAppendPrintf(ptr->wcs_value, format, arg_ptr); va_end(arg_ptr); - - ptr->wcs_function = NULL; - ptr->wcs_type = keytype; - ptr->wcs_value = strdup(wbuf); } /** @@ -184,12 +359,10 @@ void SVPRINTF(char *keyname, int keytype, const char *format,...) void svprintf(char *keyname, size_t keylen, int keytype, const char *format,...) { va_list arg_ptr; - char wbuf[SIZ]; void *vPtr; wcsubst *ptr = NULL; - struct wcsession *WCC = WC; - size_t len; - + wcsession *WCC = WC; + /** * First look if we're doing a replacement of * an existing key @@ -197,26 +370,18 @@ void svprintf(char *keyname, size_t keylen, int keytype, const char *format,...) /*PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/ if (GetHash(WCC->vars, keyname, keylen, &vPtr)) { ptr = (wcsubst*)vPtr; - if (ptr->wcs_value != NULL) - free(ptr->wcs_value); + FlushPayload(ptr, 1, keytype); + ptr->wcs_type = keytype; } else /** Otherwise allocate a new one */ { - ptr = (wcsubst *) malloc(sizeof(wcsubst)); - safestrncpy(ptr->wcs_key, keyname, sizeof ptr->wcs_key); - Put(WCC->vars, keyname, keylen, ptr, deletevar); + ptr = NewSubstVar(keyname, keylen, keytype); } /** Format the string and save it */ - va_start(arg_ptr, format); - len = vsnprintf(wbuf, sizeof wbuf, format, arg_ptr); + StrBufVAppendPrintf(ptr->wcs_value, format, arg_ptr); va_end(arg_ptr); - - ptr->wcs_value = (char*) malloc(len + 1); - memcpy(ptr->wcs_value, wbuf, len + 1); - ptr->wcs_function = NULL; - ptr->wcs_type = keytype; } /** @@ -230,7 +395,7 @@ void SVPut(char *keyname, size_t keylen, int keytype, char *Data) { void *vPtr; wcsubst *ptr = NULL; - struct wcsession *WCC = WC; + wcsession *WCC = WC; /** @@ -240,19 +405,45 @@ void SVPut(char *keyname, size_t keylen, int keytype, char *Data) /*PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/ if (GetHash(WCC->vars, keyname, keylen, &vPtr)) { ptr = (wcsubst*)vPtr; - if (ptr->wcs_value != NULL) - free(ptr->wcs_value); + FlushPayload(ptr, 1, keytype); + ptr->wcs_type = keytype; } else /** Otherwise allocate a new one */ { - ptr = (wcsubst *) malloc(sizeof(wcsubst)); - safestrncpy(ptr->wcs_key, keyname, sizeof ptr->wcs_key); - Put(WCC->vars, keyname, keylen, ptr, deletevar); + ptr = NewSubstVar(keyname, keylen, keytype); } + StrBufAppendBufPlain(ptr->wcs_value, Data, -1, 0); +} + +/** + * \brief Add a substitution variable (local to this session) + * \param keyname the replacementstring to substitute + * \param keytype the kind of the key + * \param format the format string ala printf + * \param ... the arguments to substitute in the formatstring + */ +void SVPutLong(char *keyname, size_t keylen, long Data) +{ + void *vPtr; + wcsubst *ptr = NULL; + wcsession *WCC = WC; - ptr->wcs_function = NULL; - ptr->wcs_type = keytype; - ptr->wcs_value = strdup(Data); + + /** + * First look if we're doing a replacement of + * an existing key + */ + /*PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/ + if (GetHash(WCC->vars, keyname, keylen, &vPtr)) { + ptr = (wcsubst*)vPtr; + FlushPayload(ptr, 1, WCS_LONG); + ptr->wcs_type = WCS_LONG; + } + else /** Otherwise allocate a new one */ + { + ptr = NewSubstVar(keyname, keylen, WCS_LONG); + } + ptr->lvalue = Data; } /** @@ -260,11 +451,11 @@ void SVPut(char *keyname, size_t keylen, int keytype, char *Data) * \param keyname the keystring to substitute * \param fcn_ptr the function callback to give the substitution string */ -void SVCallback(char *keyname, size_t keylen, var_callback_fptr fcn_ptr) +void SVCallback(char *keyname, size_t keylen, WCHandlerFunc fcn_ptr) { wcsubst *ptr; void *vPtr; - struct wcsession *WCC = WC; + wcsession *WCC = WC; /** * First look if we're doing a replacement of @@ -273,84 +464,278 @@ void SVCallback(char *keyname, size_t keylen, var_callback_fptr fcn_ptr) /*PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/ if (GetHash(WCC->vars, keyname, keylen, &vPtr)) { ptr = (wcsubst*)vPtr; - if (ptr->wcs_value != NULL) - free(ptr->wcs_value); + FlushPayload(ptr, 1, WCS_FUNCTION); + ptr->wcs_type = WCS_FUNCTION; } else /** Otherwise allocate a new one */ { - ptr = (wcsubst *) malloc(sizeof(wcsubst)); - safestrncpy(ptr->wcs_key, keyname, sizeof ptr->wcs_key); - Put(WCC->vars, keyname, keylen, ptr, deletevar); + ptr = NewSubstVar(keyname, keylen, WCS_FUNCTION); } - ptr->wcs_value = NULL; - ptr->wcs_type = WCS_FUNCTION; ptr->wcs_function = fcn_ptr; } -inline void SVCALLBACK(char *keyname, var_callback_fptr fcn_ptr) +inline void SVCALLBACK(char *keyname, WCHandlerFunc fcn_ptr) { SVCallback(keyname, strlen(keyname), fcn_ptr); } +void SVPUTBuf(const char *keyname, int keylen, const StrBuf *Buf, int ref) +{ + wcsubst *ptr; + void *vPtr; + wcsession *WCC = WC; + + /** + * First look if we're doing a replacement of + * an existing key + */ + /*PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/ + if (GetHash(WCC->vars, keyname, keylen, &vPtr)) { + ptr = (wcsubst*)vPtr; + FlushPayload(ptr, 0, (ref)?WCS_STRBUF_REF:WCS_STRBUF); + ptr->wcs_type = (ref)?WCS_STRBUF_REF:WCS_STRBUF; + } + else /** Otherwise allocate a new one */ + { + ptr = NewSubstVar(keyname, keylen, (ref)?WCS_STRBUF_REF:WCS_STRBUF); + } + ptr->wcs_value = (StrBuf*)Buf; +} + /** * \brief back end for print_value_of() ... does a server command * \param servcmd server command to execute on the citadel server */ -void pvo_do_cmd(char *servcmd) { +void pvo_do_cmd(StrBuf *Target, StrBuf *servcmd) { char buf[SIZ]; + int len; - serv_puts(servcmd); - serv_getln(buf, sizeof buf); + serv_puts(ChrPtr(servcmd)); + len = serv_getln(buf, sizeof buf); switch(buf[0]) { case '2': case '3': case '5': - wprintf("%s\n", &buf[4]); + StrBufAppendPrintf(Target, "%s\n", &buf[4]); break; case '1': - fmout("CENTER"); + _fmout(Target, "CENTER"); break; case '4': - wprintf("%s\n", &buf[4]); + StrBufAppendPrintf(Target, "%s\n", &buf[4]); serv_puts("000"); break; } } +void GetTemplateTokenString(WCTemplputParams *TP, + int N, + const char **Value, + long *len) +{ + StrBuf *Buf; + + if (TP->Tokens->nParameters < N) { + lprintf(1, "invalid token. this shouldn't have come till here.\n"); + wc_backtrace(); + *Value = ""; + *len = 0; + return; + } + + switch (TP->Tokens->Params[N]->Type) { + + case TYPE_STR: + *Value = TP->Tokens->Params[N]->Start; + *len = TP->Tokens->Params[N]->len; + break; + case TYPE_BSTR: + Buf = (StrBuf*) SBstr(TKEY(N)); + *Value = ChrPtr(Buf); + *len = StrLength(Buf); + break; + case TYPE_PREFSTR: + get_PREFERENCE(TKEY(N), &Buf); + *Value = ChrPtr(Buf); + *len = StrLength(Buf); + break; + case TYPE_LONG: + case TYPE_PREFINT: + break; /* todo: string to text? */ + case TYPE_GETTEXT: + *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(const char *keyname, size_t keylen) { - struct wcsession *WCC = WC; +void print_value_of(StrBuf *Target, WCTemplputParams *TP) + +{ + wcsession *WCC = WC; wcsubst *ptr; - void *fcn(); void *vVar; /*if (WCC->vars != NULL) PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/ - if (keyname[0] == '=') { - DoTemplate(keyname+1, keylen - 1); + /* TODO: depricated! */ + if (TP->Tokens->pName[0] == '=') { + DoTemplate(TP->Tokens->pName+1, TP->Tokens->NameEnd - 1, NULL, &NoCtx); } +/*/////TODO: if param[1] == "U" -> urlescape +/// X -> escputs */ /** Page-local variables */ - if ((WCC->vars!= NULL) && GetHash(WCC->vars, keyname, keylen, &vVar)) { + if ((WCC->vars!= NULL) && GetHash(WCC->vars, TP->Tokens->pName, TP->Tokens->NameEnd, &vVar)) { + ptr = (wcsubst*) vVar; + switch(ptr->wcs_type) { + case WCS_STRING: + StrBufAppendBuf(Target, ptr->wcs_value, 0); + break; + case WCS_SERVCMD: + pvo_do_cmd(Target, ptr->wcs_value); + break; + case WCS_FUNCTION: + (*ptr->wcs_function) (Target, TP); + break; + case WCS_STRBUF: + case WCS_STRBUF_REF: + StrBufAppendBuf(Target, ptr->wcs_value, 0); + break; + case WCS_LONG: + StrBufAppendPrintf(Target, "%ld", ptr->lvalue); + break; + default: + LogTemplateError( + Target, "Subst", ERR_NAME, TP, + "WARNING: invalid value in SV-Hash at %s!", TP->Tokens->pName); + } + } + else { + LogTemplateError( + Target, "Token", ERR_NAME, TP, + "didn't find Handler"); + wc_backtrace(); + } +} + +int CompareSubstToToken(TemplateParam *ParamToCompare, TemplateParam *ParamToLookup) +{ + wcsession *WCC = WC; + wcsubst *ptr; + void *vVar; + + if ((WCC->vars!= NULL) && GetHash(WCC->vars, ParamToLookup->Start, + ParamToLookup->len, &vVar)) { ptr = (wcsubst*) vVar; switch(ptr->wcs_type) { case WCS_STRING: - wprintf("%s", (const char*)ptr->wcs_value); + 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: - pvo_do_cmd(ptr->wcs_value); + return 1; break; case WCS_FUNCTION: - (*ptr->wcs_function) (); + return 1; + case WCS_LONG: + if (ParamToCompare->Type == TYPE_STR) + return 0; + else + return ParamToCompare->lvalue == ptr->lvalue; + break; + default: + lprintf(1,"WARNING: invalid value in SV-Hash at %s!\n", + ParamToLookup->Start); + } + } + return 0; +} + +int CompareSubstToStrBuf(StrBuf *Compare, TemplateParam *ParamToLookup) +{ + wcsession *WCC = WC; + wcsubst *ptr; + void *vVar; + + if ((WCC->vars!= NULL) && GetHash(WCC->vars, ParamToLookup->Start, + ParamToLookup->len, &vVar)) { + ptr = (wcsubst*) vVar; + switch(ptr->wcs_type) { + case WCS_STRING: + case WCS_STRBUF: + case WCS_STRBUF_REF: + return ((StrLength(Compare) == StrLength(ptr->wcs_value)) && + (strcmp(ChrPtr(Compare), ChrPtr(ptr->wcs_value)) == 0)); + case WCS_SERVCMD: + return 1; break; + case WCS_FUNCTION: + return 1; + case WCS_LONG: + return StrTol(Compare) == ptr->lvalue; default: - lprintf(1,"WARNING: invalid value in SV-Hash at %s!", keyname); + lprintf(1,"WARNING: invalid value in SV-Hash at %s!\n", + ParamToLookup->Start); } } + return 0; +} + + + +/** + * \brief puts string into the template and computes which escape methon we should use + * \param Source the string we should put into the template + * \param FormatTypeIndex where should we look for escape types if? + */ +void StrBufAppendTemplate(StrBuf *Target, + WCTemplputParams *TP, + const StrBuf *Source, int FormatTypeIndex) +{ + wcsession *WCC; + StrBuf *Buf; + char EscapeAs = ' '; + + if ((FormatTypeIndex < TP->Tokens->nParameters) && + (TP->Tokens->Params[FormatTypeIndex]->Type == TYPE_STR) && + (TP->Tokens->Params[FormatTypeIndex]->len == 1)) { + EscapeAs = *TP->Tokens->Params[FormatTypeIndex]->Start; + } + + 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); + break; + case 'X': + StrEscAppend(Target, Source, NULL, 0, 0); + break; + default: + StrBufAppendBuf(Target, Source, 0); + } } @@ -368,7 +753,7 @@ void PutNewToken(WCTemplate *Template, WCTemplateToken *NewToken) sizeof(WCTemplateToken*) * Template->TokenSpace * 2); memcpy(NewTokens, Template->Tokens, - sizeof(WCTemplateToken) * Template->nTokensUsed); + sizeof(WCTemplateToken*) * Template->nTokensUsed); free(Template->Tokens); Template->TokenSpace *= 2; Template->Tokens = NewTokens; @@ -377,91 +762,309 @@ void PutNewToken(WCTemplate *Template, WCTemplateToken *NewToken) Template->Tokens[(Template->nTokensUsed)++] = NewToken; } -WCTemplateToken *NewTemlpateSubstitute(const char *pStart, const char *pTmplStart, const char *pTmplEnd) +TemplateParam *GetNextParameter(StrBuf *Buf, const char **pCh, const char *pe, WCTemplateToken *Tokens, WCTemplate *pTmpl) { - WCTemplateToken *NewToken = (WCTemplateToken*)malloc(sizeof(WCTemplateToken)); - - NewToken->pTokenStart = pTmplStart; - NewToken->TokenStart = pTmplStart - pStart; - NewToken->TokenEnd = (pTmplEnd - pStart) - NewToken->TokenStart; - NewToken->pTokenEnd = pTmplEnd; + const char *pch = *pCh; + const char *pchs, *pche; + TemplateParam *Parm = (TemplateParam *) malloc(sizeof(TemplateParam)); + char quote = '\0'; - NewToken->pName = pTmplStart + 2; - NewToken->NameEnd = NewToken->TokenEnd - 2; - NewToken->HaveParameters = 0;; - NewToken->nParameters = 0; - NewToken->ParamStart[0] = 0; - NewToken->ParamEnd[0] = 0; - return NewToken; -} -void FreeWCTemplate(void *vFreeMe) -{ - int i; - WCTemplate *FreeMe = (WCTemplate*)vFreeMe; + Parm->Type = TYPE_STR; - if (FreeMe->TokenSpace > 0) { - for (i = 0; i < FreeMe->nTokensUsed; i ++) { - free(FreeMe->Tokens[i]); - } - free(FreeMe->Tokens); + /* Skip leading whitespaces */ + while ((*pch == ' ' )|| + (*pch == '\t')|| + (*pch == '\r')|| + (*pch == '\n')) pch ++; + + if (*pch == ':') { + Parm->Type = TYPE_PREFSTR; + pch ++; + } + else if (*pch == ';') { + Parm->Type = TYPE_PREFINT; + pch ++; + } + else if (*pch == '_') { + Parm->Type = TYPE_GETTEXT; + pch ++; + if (*pch == '(') + pch ++; + } + else if (*pch == 'B') { + Parm->Type = TYPE_BSTR; + pch ++; } - free(FreeMe); -} -void EvaluateToken(StrBuf *Target, WCTemplateToken *Token) -{ - void *vVar; -// much output, since pName is not terminated... -// lprintf(1,"Doing token: %s\n",Token->pName); - if (GetHash(GlobalNS, Token->pName, Token->NameEnd, &vVar)) { - HashHandler *Handler; - Handler = (HashHandler*) vVar; - if ((Token->nParameters < Handler->nMinArgs) || - (Token->nParameters < Handler->nMaxArgs)) { - lprintf(1, "Handler [%s] doesn't work with %ld params", - Token->pName, - Token->nParameters); + + if (*pch == '"') + quote = '"'; + else if (*pch == '\'') + quote = '\''; + if (quote != '\0') { + pch ++; + pchs = pch; + while (pch <= pe && + ((*pch != quote) || + ( (pch > pchs) && (*(pch - 1) == '\\')) + )) { + pch ++; + } + pche = pch; + if (*pch != quote) { + lprintf(1, "Error (in '%s' line %ld); " + "evaluating template param [%s] in Token [%s]\n", + ChrPtr(pTmpl->FileName), + Tokens->Line, + ChrPtr(Tokens->FlatToken), + *pCh); + pch ++; + free(Parm); + return NULL; } else { - Handler->HandlerFunc(Token->nParameters, - &Token); /*TODO: subset of that */ - - + StrBufPeek(Buf, pch, -1, '\0'); + if (LoadTemplates > 1) { + lprintf(1, "DBG: got param [%s] %ld %ld\n", + pchs, pche - pchs, strlen(pchs)); + } + Parm->Start = pchs; + Parm->len = pche - pchs; + pch ++; /* move after trailing quote */ + if ((Parm->Type = TYPE_GETTEXT) && (*pch == ')')) { + pch ++; + } + } } else { - print_value_of(Token->pName, Token->NameEnd); - } -} - -void ProcessTemplate(WCTemplate *Tmpl, StrBuf *Target) -{ - int done = 0; - int i; - const char *pData, *pS; - long len; - - pS = pData = ChrPtr(Tmpl->Data); - len = StrLength(Tmpl->Data); - i = 0; - while (!done) { - if (i >= Tmpl->nTokensUsed) { - StrBufAppendBufPlain(Target, pData, len, 0); - done = 1; + Parm->Type = TYPE_LONG; + pchs = pch; + while ((pch <= pe) && + (isdigit(*pch) || + (*pch == '+') || + (*pch == '-'))) + pch ++; + pch ++; + if (pch - pchs > 1){ + StrBufPeek(Buf, pch, -1, '\0'); + Parm->lvalue = atol(pchs); + Parm->Start = pchs; + pch++; } else { - StrBufAppendBufPlain( - Target, pData, - Tmpl->Tokens[i]->pTokenStart - pData, 0); - EvaluateToken(Target, Tmpl->Tokens[i]); - pData = Tmpl->Tokens[i++]->pTokenEnd + 1; + 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; } } + while ((*pch == ' ' )|| + (*pch == '\t')|| + (*pch == '\r')|| + (*pch == ',' )|| + (*pch == '\n')) pch ++; + + *pCh = pch; + return Parm; } +WCTemplateToken *NewTemplateSubstitute(StrBuf *Buf, + const char *pStart, + const char *pTmplStart, + const char *pTmplEnd, + long Line, + WCTemplate *pTmpl) +{ + void *vVar; + const char *pch; + TemplateParam *Param; + WCTemplateToken *NewToken = (WCTemplateToken*)malloc(sizeof(WCTemplateToken)); + WCTemplputParams TP; + + 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->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->HaveParameters = 0;; + NewToken->nParameters = 0; + + while (pch < pTmplEnd - 1) { + if (*pch == '(') { + StrBufPeek(Buf, pch, -1, '\0'); + NewToken->NameEnd = pch - NewToken->pName; + pch ++; + if (*(pTmplEnd - 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) { + NewToken->HaveParameters = 1; + if (NewToken->nParameters > MAXPARAM) { + LogTemplateError( + NULL, "Parseerror", ERR_NAME, &TP, + "only [%ld] Params allowed in Tokens", + MAXPARAM); + + free(Param); + FreeToken(&NewToken); + return NULL; + } + NewToken->Params[NewToken->nParameters++] = Param; + } + else break; + } + if((NewToken->NameEnd == 1) && + (NewToken->HaveParameters == 1)) + + { + if (*(NewToken->pName) == '_') + NewToken->Flags = SV_GETTEXT; + else if (*(NewToken->pName) == '=') + NewToken->Flags = SV_SUBTEMPL; + else if (*(NewToken->pName) == '%') + NewToken->Flags = SV_CUST_STR_CONDITIONAL; + else if (*(NewToken->pName) == '?') + NewToken->Flags = SV_CONDITIONAL; + else if (*(NewToken->pName) == '!') + NewToken->Flags = SV_NEG_CONDITIONAL; + } + } + else pch ++; + } + + switch (NewToken->Flags) { + case 0: + /* If we're able to find out more about the token, do it now while its fresh. */ + if (GetHash(GlobalNS, NewToken->pName, NewToken->NameEnd, &vVar)) { + HashHandler *Handler; + Handler = (HashHandler*) vVar; + if ((NewToken->nParameters < Handler->nMinArgs) || + (NewToken->nParameters > Handler->nMaxArgs)) { + LogTemplateError( + NULL, "Token", ERR_NAME, &TP, + "doesn't work with %ld params", + NewToken->nParameters); + + } + else { + NewToken->PreEval = Handler; + NewToken->Flags = SV_PREEVALUATED; + } + } + break; + case SV_GETTEXT: + if (NewToken->nParameters !=1) { + LogTemplateError( + NULL, "Gettext", ERR_NAME, &TP, + "requires exactly 1 parameter, you gave %ld params", + NewToken->nParameters); + NewToken->Flags = 0; + break; + } + break; + case SV_SUBTEMPL: + if (NewToken->nParameters != 1) { + LogTemplateError( + NULL, "Subtemplates", ERR_NAME, &TP, + "require exactly 1 parameter, you gave %ld params", + NewToken->nParameters); + break; + } + break; + case SV_CUST_STR_CONDITIONAL: + case SV_CONDITIONAL: + case SV_NEG_CONDITIONAL: + if (NewToken->nParameters <2) { + LogTemplateError( + NULL, "Conditional", ERR_NAME, &TP, + "require at least 2 parameters, you gave %ld params", + NewToken->nParameters); + NewToken->Flags = 0; + break; + } + if (NewToken->Params[1]->lvalue == 0) { + LogTemplateError( + NULL, "Conditional", ERR_NAME, &TP, + "Conditional ID (Parameter 1) mustn't be 0!"); + NewToken->Flags = 0; + break; + } + if (!GetHash(Conditionals, + NewToken->Params[0]->Start, + NewToken->Params[0]->len, + &vVar) || + (vVar == NULL)) { + if ((NewToken->Params[0]->len == 1) && + (NewToken->Params[0]->Start[0] == 'X')) + break; + LogTemplateError( + NULL, "Conditional", ERR_NAME, &TP, + "Not found!"); +/* + NewToken->Error = NewStrBuf(); + StrBufAppendPrintf( + NewToken->Error, + "
\nConditional [%s] (in '%s' line %ld); Not found!\n[%s]\n
\n", + NewToken->Params[0]->Start, + ChrPtr(pTmpl->FileName), + NewToken->Line, + ChrPtr(NewToken->FlatToken)); +*/ + } + else { + NewToken->PreEval = vVar; + } + break; + } + return NewToken; +} + + + +/** + * \brief Display a variable-substituted template + * \param templatename template file to load + */ +void *prepare_template(StrBuf *filename, StrBuf *Key, HashList *PutThere) +{ + WCTemplate *NewTemplate; + NewTemplate = (WCTemplate *) malloc(sizeof(WCTemplate)); + NewTemplate->Data = NULL; + NewTemplate->FileName = NewStrBufDup(filename); + NewTemplate->nTokensUsed = 0; + NewTemplate->TokenSpace = 0; + NewTemplate->Tokens = NULL; + + Put(PutThere, ChrPtr(Key), StrLength(Key), NewTemplate, FreeWCTemplate); + return NewTemplate; +} + /** * \brief Display a variable-substituted template * \param templatename template file to load @@ -471,6 +1074,7 @@ void *load_template(StrBuf *filename, StrBuf *Key, HashList *PutThere) int fd; struct stat statbuf; const char *pS, *pE, *pch, *Err; + long Line; int pos; WCTemplate *NewTemplate; @@ -489,6 +1093,7 @@ void *load_template(StrBuf *filename, StrBuf *Key, HashList *PutThere) 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; @@ -501,21 +1106,27 @@ void *load_template(StrBuf *filename, StrBuf *Key, HashList *PutThere) } close(fd); + Line = 0; pS = pch = ChrPtr(NewTemplate->Data); pE = pS + StrLength(NewTemplate->Data); while (pch < pE) { const char *pts, *pte; int InQuotes = 0; int InDoubleQuotes = 0; + + /** Find one */ pos = (-1); for (; pch < pE; pch ++) { if ((*pch=='<')&&(*(pch + 1)=='?')) break; + if (*pch=='\n') Line ++; } if (pch >= pE) continue; pts = pch; - for (; pch < pE - 1; pch ++) { + + /** Found one? parse it. */ + for (; pch <= pE - 1; pch ++) { if (*pch == '"') InDoubleQuotes = ! InDoubleQuotes; else if (*pch == '\'') @@ -526,43 +1137,25 @@ void *load_template(StrBuf *filename, StrBuf *Key, HashList *PutThere) break; } } - if (pch + 1 >= pE) + if (pch + 1 > pE) continue; pte = pch; - PutNewToken(NewTemplate, NewTemlpateSubstitute(pS, pts, pte)); + PutNewToken(NewTemplate, + NewTemplateSubstitute(NewTemplate->Data, pS, pts, pte, Line, NewTemplate)); pch ++; } - Put(PutThere, ChrPtr(Key), StrLength(Key), NewTemplate, FreeWCTemplate); + if (LoadTemplates == 0) + Put(PutThere, ChrPtr(Key), StrLength(Key), NewTemplate, FreeWCTemplate); return NewTemplate; } -/** - * \brief Display a variable-substituted template - * \param templatename template file to load - */ -void DoTemplate(const char *templatename, long len) + +const char* PrintTemplate(void *vSubst) { - HashList *Static; - HashList *StaticLocal; - void *vTmpl; + WCTemplate *Tmpl = vSubst; - if (WC->is_mobile) { - Static = WirelessTemplateCache; - StaticLocal = WirelessLocalTemplateCache; - } - else { - Static = TemplateCache; - StaticLocal = LocalTemplateCache; - } + return ChrPtr(Tmpl->FileName); - if (!GetHash(StaticLocal, templatename, len, &vTmpl) && - !GetHash(Static, templatename, len, &vTmpl)) { - printf ("didn't find %s\n", templatename); - return; - } - if (vTmpl == NULL) - return; - ProcessTemplate(vTmpl, WC->WBuf); } int LoadTemplateDir(const char *DirName, HashList *wireless, HashList *big) @@ -580,6 +1173,7 @@ int LoadTemplateDir(const char *DirName, HashList *wireless, HashList *big) StrBufPrintf(Dir, "%s/t", DirName); filedir = opendir (ChrPtr(Dir)); if (filedir == NULL) { + FreeStrBuf(&Dir); return 0; } @@ -599,6 +1193,8 @@ int LoadTemplateDir(const char *DirName, HashList *wireless, HashList *big) 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; @@ -608,9 +1204,12 @@ int LoadTemplateDir(const char *DirName, HashList *wireless, HashList *big) *MinorPtr = '\0'; StrBufPlain(Tag, filedir_entry->d_name, MinorPtr - filedir_entry->d_name); - - printf("%s %d %s\n",ChrPtr(FileName), IsMobile, ChrPtr(Tag)); - load_template(FileName, Tag, (IsMobile)?wireless:big); + 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); } closedir(filedir); FreeStrBuf(&FileName); @@ -629,66 +1228,902 @@ void InitTemplateCache(void) LocalTemplateCache); } -void tmplput_serv_ip(int nArgs, WCTemplateToken **Tokens) + + +/*----------------------------------------------------------------------------- + * Filling & processing Templates + */ +/** + * \brief executes one token + * \param Target buffer to append to + * \param Token da to process. + * \param Template we're iterating + * \param Context Contextpoointer to pass in + * \param state are we in conditional state? + * \param ContextType what type of information does context giv us? + */ +int EvaluateToken(StrBuf *Target, int state, WCTemplputParams *TP) { - wprintf("%d", WC->ctdl_pid); + const char *AppendMe; + long AppendMeLen; + HashHandler *Handler; + void *vVar; +/* much output, since pName is not terminated... + lprintf(1,"Doing token: %s\n",Token->pName); +*/ + + switch (TP->Tokens->Flags) { + case SV_GETTEXT: + TmplGettext(Target, TP); + break; + case SV_CONDITIONAL: /** Forward conditional evaluation */ + return EvaluateConditional(Target, 1, state, TP); + break; + case SV_NEG_CONDITIONAL: /** Reverse conditional evaluation */ + return EvaluateConditional(Target, 0, state, TP); + break; + case SV_CUST_STR_CONDITIONAL: /** Conditional put custom strings from params */ + if (TP->Tokens->nParameters >= 6) { + if (EvaluateConditional(Target, 0, state, TP)) { + GetTemplateTokenString(TP, 5, &AppendMe, &AppendMeLen); + StrBufAppendBufPlain(Target, + AppendMe, + AppendMeLen, + 0); + } + else{ + GetTemplateTokenString(TP, 4, &AppendMe, &AppendMeLen); + StrBufAppendBufPlain(Target, + AppendMe, + AppendMeLen, + 0); + } + } + else { + LogTemplateError( + Target, "Conditional", ERR_NAME, TP, + "needs at least 6 Params!"); + } + break; + case SV_SUBTEMPL: + if (TP->Tokens->nParameters == 1) + DoTemplate(TKEY(0), NULL, TP); + break; + case SV_PREEVALUATED: + Handler = (HashHandler*) TP->Tokens->PreEval; + if ((Handler->ContextRequired != CTX_NONE) && + (Handler->ContextRequired != TP->ContextType)) { + LogTemplateError( + Target, "Token", ERR_NAME, TP, + "requires context of type %ld, have %ld", + Handler->ContextRequired, + TP->ContextType); + return -1; + + } + Handler->HandlerFunc(Target, TP); + break; + default: + if (GetHash(GlobalNS, TP->Tokens->pName, TP->Tokens->NameEnd, &vVar)) { + Handler = (HashHandler*) vVar; + if ((Handler->ContextRequired != CTX_NONE) && + (Handler->ContextRequired != TP->ContextType)) { + LogTemplateError( + Target, "Token", ERR_NAME, TP, + "requires context of type %ld, have %ld", + Handler->ContextRequired, + TP->ContextType); + return -1; + } + else if ((TP->Tokens->nParameters < Handler->nMinArgs) || + (TP->Tokens->nParameters > Handler->nMaxArgs)) { + LogTemplateError( + Target, "Token", ERR_NAME, TP, + "doesn't work with %ld params need > %ld < %ld", + TP->Tokens->nParameters, + Handler->nMaxArgs, + Handler->nMinArgs); + } + else { + Handler->HandlerFunc(Target, TP); + } + } + else { + print_value_of(Target, TP); + } + } + return 0; } -void tmplput_serv_nodename(int nArgs, WCTemplateToken **Tokens) + + +void ProcessTemplate(WCTemplate *Tmpl, StrBuf *Target, void *Context, int ContextType) { - escputs(serv_info.serv_nodename); + WCTemplate *pTmpl = Tmpl; + int done = 0; + int i, state; + const char *pData, *pS; + long len; + WCTemplputParams TP; + + TP.Context = Context; + TP.ContextType = ContextType; + + 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) { + StrBufAppendPrintf( + Target, + "
\nError loading Template [%s]\n See Logfile for details\n
\n", + ChrPtr(Tmpl->FileName)); + return; + } + + } + + pS = pData = ChrPtr(pTmpl->Data); + len = StrLength(pTmpl->Data); + i = 0; + state = 0; + while (!done) { + if (i >= pTmpl->nTokensUsed) { + StrBufAppendBufPlain(Target, + pData, + len - (pData - pS), 0); + done = 1; + } + else { + StrBufAppendBufPlain( + Target, pData, + pTmpl->Tokens[i]->pTokenStart - pData, 0); + TP.Tokens = pTmpl->Tokens[i]; + TP.nArgs = pTmpl->Tokens[i]->nParameters; + state = EvaluateToken(Target, state, &TP); + + while ((state != 0) && (i+1 < pTmpl->nTokensUsed)) { + /* 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]->Flags, + state, + &TP)) + state = 0; + } + } + pData = pTmpl->Tokens[i++]->pTokenEnd + 1; + if (i > pTmpl->nTokensUsed) + done = 1; + } + } + if (LoadTemplates != 0) { + FreeWCTemplate(pTmpl); + } } -void tmplput_serv_humannode(int nArgs, WCTemplateToken **Tokens) +/** + * \brief Display a variable-substituted template + * \param templatename template file to load + */ +void DoTemplate(const char *templatename, long len, StrBuf *Target, WCTemplputParams *TP) { - escputs(serv_info.serv_humannode); + HashList *Static; + HashList *StaticLocal; + void *vTmpl; + + if (Target == NULL) + Target = WC->WBuf; + if (WC->is_mobile) { + Static = WirelessTemplateCache; + StaticLocal = WirelessLocalTemplateCache; + } + else { + Static = TemplateCache; + StaticLocal = LocalTemplateCache; + } + + if (len == 0) + { + 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; + } + + if (!GetHash(StaticLocal, templatename, len, &vTmpl) && + !GetHash(Static, templatename, len, &vTmpl)) { + lprintf (1, "didn't find Template [%s] %ld %ld\n", templatename, len , (long)strlen(templatename)); + StrBufAppendPrintf(Target, "
\ndidn't find Template [%s] %ld %ld\n
", + templatename, len, + (long)strlen(templatename)); +#if 0 + dbg_PrintHash(Static, PrintTemplate, NULL); + PrintHash(Static, VarPrintTransition, PrintTemplate); +#endif + return; + } + if (vTmpl == NULL) + return; + ProcessTemplate(vTmpl, Target, TP->Context, TP->ContextType); } -void tmplput_serv_fqdn(int nArgs, WCTemplateToken **Tokens) +/*----------------------------------------------------------------------------- + * Iterators + */ +typedef struct _HashIterator { + HashList *StaticList; + int AdditionalParams; + int ContextType; + int XPectContextType; + int Flags; + RetrieveHashlistFunc GetHash; + HashDestructorFunc Destructor; + SubTemplFunc DoSubTemplate; +} HashIterator; + +void RegisterITERATOR(const char *Name, long len, + int AdditionalParams, + HashList *StaticList, + RetrieveHashlistFunc GetHash, + SubTemplFunc DoSubTempl, + HashDestructorFunc Destructor, + int ContextType, + int XPectContextType, + int Flags) { - escputs(serv_info.serv_fqdn); + HashIterator *It = (HashIterator*)malloc(sizeof(HashIterator)); + It->StaticList = StaticList; + It->AdditionalParams = AdditionalParams; + It->GetHash = GetHash; + It->DoSubTemplate = DoSubTempl; + It->Destructor = Destructor; + It->ContextType = ContextType; + It->XPectContextType = XPectContextType; + It->Flags = Flags; + Put(Iterators, Name, len, It, NULL); } -void tmmplput_serv_software(int nArgs, WCTemplateToken **Tokens) +void tmpl_iterate_subtmpl(StrBuf *Target, WCTemplputParams *TP) { - escputs(serv_info.serv_software); + void *vIt; + 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; + + memcpy (&SubTP, &TP, sizeof(WCTemplputParams)); + + if (!GetHash(Iterators, TKEY(0), &vIt)) { + LogTemplateError( + Target, "Iterator", ERR_PARM1, TP, "Unknown!"); + return; + } + + It = (HashIterator*) vIt; + + if (TP->Tokens->nParameters < It->AdditionalParams + 2) { + LogTemplateError( + Target, "Iterator", ERR_PARM1, TP, + "doesn't work with %ld params", + TP->Tokens->nParameters); + return; + } + + if ((It->XPectContextType != CTX_NONE) && + (It->XPectContextType != TP->ContextType)) { + LogTemplateError( + Target, "Iterator", ERR_PARM1, TP, + "requires context of type %ld, have %ld", + It->XPectContextType, + TP->ContextType); + return ; + + } + + if (It->StaticList == NULL) + 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(); + SubTP.ContextType = It->ContextType; + it = GetNewHashPos(List, 0); + while (GetNextHashPos(List, it, &len, &Key, &vContext)) { + if (DetectGroupChange && nMembersCounted > 0) { + if (SortBy->GroupChange(vContext, vLastContext)) + svputlong("ITERATE:ISGROUPCHANGE", 1); + else + svputlong("ITERATE:ISGROUPCHANGE", 0); + } + 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); + SubTP.Context = vContext; + if (It->DoSubTemplate != NULL) + It->DoSubTemplate(SubBuf, &SubTP); + DoTemplate(TKEY(1), SubBuf, &SubTP); + + StrBufAppendBuf(Target, SubBuf, 0); + FlushStrBuf(SubBuf); + oddeven = ~ oddeven; + vLastContext = vContext; + } + FreeStrBuf(&SubBuf); + DeleteHashPos(&it); + if (It->Destructor != NULL) + It->Destructor(&List); +} + + + +/*----------------------------------------------------------------------------- + * Conditionals + */ +int EvaluateConditional(StrBuf *Target, int Neg, int state, WCTemplputParams *TP) +{ + ConditionalStruct *Cond; + + 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 *) TP->Tokens->PreEval; + if (Cond == NULL) { + LogTemplateError( + Target, "Conditional", ERR_PARM1, TP, + "unknown!"); + return 1; + } + + if (TP->Tokens->nParameters < Cond->nParams) { + LogTemplateError( + Target, "Conditional", ERR_PARM1, TP, + "needs %ld Params, have %ld!", + Cond->nParams, + TP->Tokens->nParameters); + return 0; + } + if (Cond->CondF(Target, TP) == Neg) + return TP->Tokens->Params[1]->lvalue; + return 0; } -void tmplput_serv_rev_level(int nArgs, WCTemplateToken **Tokens) +int ConditionalVar(StrBuf *Target, WCTemplputParams *TP) { - wprintf("%d.%02d", - serv_info.serv_rev_level / 100, - serv_info.serv_rev_level % 100); + void *vsubst; + wcsubst *subst; + + if (!GetHash(WC->vars, TKEY(2), &vsubst)) + return 0; + subst = (wcsubst*) vsubst; + if ((subst->ContextRequired != CTX_NONE) && + (subst->ContextRequired != TP->ContextType)) { + LogTemplateError( + Target, "ConditionalVar", ERR_PARM1, TP, + " WARNING: Conditional requires Context: [%ld], have [%ld]!", + subst->ContextRequired, CTX); + 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 (TP->Tokens->nParameters < 4) + return 1; + return (strcmp(TP->Tokens->Params[3]->Start, ChrPtr(subst->wcs_value)) == 0); + case WCS_LONG: + if (TP->Tokens->nParameters < 4) + return (subst->lvalue != 0); + return (subst->lvalue == TP->Tokens->Params[3]->lvalue); + default: + lprintf(1," WARNING: invalid type: [%ld]!\n", subst->wcs_type); + return -1; + } + return 0; } -void tmmplput_serv_bbs_city(int nArgs, WCTemplateToken **Tokens) + +void RegisterConditional(const char *Name, long len, + int nParams, + WCConditionalFunc CondF, + int ContextRequired) { - escputs(serv_info.serv_bbs_city); + ConditionalStruct *Cond = (ConditionalStruct*)malloc(sizeof(ConditionalStruct)); + Cond->PlainName = Name; + Cond->nParams = nParams; + Cond->CondF = CondF; + Cond->ContextRequired = ContextRequired; + Put(Conditionals, Name, len, Cond, NULL); } -void tmplput_current_user(int nArgs, WCTemplateToken **Tokens) +/*----------------------------------------------------------------------------- + * Context Strings + */ +void tmplput_ContextString(StrBuf *Target, WCTemplputParams *TP) +{ + StrBufAppendTemplate(Target, TP, (StrBuf*)CTX, 0); +} +int ConditionalContextStr(StrBuf *Target, WCTemplputParams *TP) { - escputs(WC->wc_fullname); + StrBuf *TokenText = (StrBuf*) CTX; + const char *CompareToken; + long len; + + GetTemplateTokenString(TP, 2, &CompareToken, &len); + return strcmp(ChrPtr(TokenText), CompareToken) == 0; } -void tmplput_current_room(int nArgs, WCTemplateToken **Tokens) +/*----------------------------------------------------------------------------- + * Boxed-API + */ + +void tmpl_do_boxed(StrBuf *Target, WCTemplputParams *TP) { - escputs(WC->wc_roomname); + WCTemplputParams SubTP; + + StrBuf *Headline; + if (TP->Tokens->nParameters == 2) { + if (TP->Tokens->Params[1]->Type == TYPE_STR) { + Headline = NewStrBuf(); + DoTemplate(TKEY(1), Headline, TP); + } + else { + const char *Ch; + long len; + GetTemplateTokenString(TP, + 1, + &Ch, + &len); + Headline = NewStrBufPlain(Ch, len); + } + } + memcpy (&SubTP, TP, sizeof(WCTemplputParams)); + SubTP.Context = Headline; + SubTP.ContextType = CTX_STRBUF; + DoTemplate(HKEY("beginbox"), Target, &SubTP); + DoTemplate(TKEY(0), Target, TP); + DoTemplate(HKEY("endbox"), Target, TP); + FreeStrBuf(&Headline); +} + +/*----------------------------------------------------------------------------- + * Tabbed-API + */ + +void tmpl_do_tabbed(StrBuf *Target, WCTemplputParams *TP) +{ + StrBuf **TabNames; + int i, ntabs, nTabs; + + nTabs = ntabs = TP->Tokens->nParameters / 2; + TabNames = (StrBuf **) malloc(ntabs * sizeof(StrBuf*)); + + for (i = 0; i < ntabs; i++) { + 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(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 --; + } + } + + StrTabbedDialog(Target, nTabs, TabNames); + for (i = 0; i < ntabs; i++) { + StrBeginTab(Target, i, nTabs); + DoTemplate(TKEY(i * 2 + 1), Target, TP); + StrEndTab(Target, i, nTabs); + } +} + + +/*----------------------------------------------------------------------------- + * Sorting-API + */ + + +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)); + NewSort->Name = NewStrBufPlain(name, len); + if (prepend != NULL) + NewSort->PrefPrepend = NewStrBufPlain(prepend, preplen); + else + NewSort->PrefPrepend = NULL; + NewSort->Forward = Forward; + NewSort->Reverse = Reverse; + NewSort->GroupChange = GroupChange; + NewSort->ContextType = ContextType; + Put(SortHash, name, len, NewSort, DestroySortStruct); +} + +CompareFunc RetrieveSort(WCTemplputParams *TP, const char *OtherPrefix, + const char *Default, long ldefault, long DefaultDirection) +{ + int isdefault = 0; + const StrBuf *BSort = NULL; + SortStruct *SortBy; + void *vSortBy; + long SortOrder = -1; + + if (havebstr("SortBy")) { + BSort = sbstr("SortBy"); + } + 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! */ + } + if (BSort != NULL) + putbstr("SortBy", NewStrBufDup(BSort)); + else { + StrBuf *Buf; + + BSort = Buf = NewStrBufPlain(Default, ldefault); + putbstr("SortBy", Buf); + } + } + + if (!GetHash(SortHash, SKEY(BSort), &vSortBy) || + (vSortBy == NULL)) { + isdefault = 1; + if (!GetHash(SortHash, Default, ldefault, &vSortBy) || + (vSortBy == NULL)) { + LogTemplateError( + NULL, "Sorting", ERR_PARM1, TP, + "Illegal default sort: [%s]", Default); + wc_backtrace(); + } + } + SortBy = (SortStruct*)vSortBy; + + /** 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) { + Buf = get_room_pref("SortOrder"); + SortOrder = StrTol(Buf); + } + else { + /* TODO: nail prefprepend to sort, and lookup this! */ + } + + if (Buf == NULL) + SortOrder = DefaultDirection; + + Buf = NewStrBufPlain(NULL, 64); + StrBufPrintf(Buf, "%ld", SortOrder); + putbstr("SortOrder", Buf); + } + switch (SortOrder) { + default: + case 0: + return NULL; + case 1: + return SortBy->Forward; + case 2: + return SortBy->Reverse; + } +} + + +enum { + eNO_SUCH_SORT, + eNOT_SPECIFIED, + eINVALID_PARAM, + eFOUND +}; + +ConstStr SortIcons[] = { + {HKEY("static/sort_none.gif")}, + {HKEY("static/up_pointer.gif")}, + {HKEY("static/down_pointer.gif")}, +}; + +ConstStr SortNextOrder[] = { + {HKEY("1")}, + {HKEY("2")}, + {HKEY("0")}, +}; + + +int GetSortMetric(WCTemplputParams *TP, SortStruct **Next, SortStruct **Param, long *SortOrder) +{ + int bSortError = eNOT_SPECIFIED; + const StrBuf *BSort; + void *vSort; + + *SortOrder = 0; + *Next = NULL; + if (!GetHash(SortHash, TKEY(0), &vSort) || + (vSort == NULL)) + return eNO_SUCH_SORT; + *Param = (SortStruct*) vSort; + + + if (havebstr("SortBy")) { + BSort = sbstr("SortBy"); + bSortError = eINVALID_PARAM; + } + else { /** Try to fallback to our remembered values... */ + if ((*Param)->PrefPrepend == NULL) { + BSort = get_room_pref("sort"); + } + else { + BSort = NULL;/* TODO: nail prefprepend to sort, and lookup this! */ + } + } + + if (!GetHash(SortHash, SKEY(BSort), &vSort) || + (vSort == NULL)) + return bSortError; + + *Next = (SortStruct*) vSort; + + /** 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... */ + if ((*Param)->PrefPrepend == NULL) { + *SortOrder = StrTol(get_room_pref("SortOrder")); + } + else { + *SortOrder = 0;/* TODO: nail prefprepend to sort, and lookup this! */ + } + } + if (*SortOrder > 2) + *SortOrder = 0; + + return eFOUND; +} + + +void tmplput_SORT_ICON(StrBuf *Target, WCTemplputParams *TP) +{ + long SortOrder; + SortStruct *Next; + SortStruct *Param; + const ConstStr *SortIcon; + + switch (GetSortMetric(TP, &Next, &Param, &SortOrder)){ + case eNO_SUCH_SORT: + LogTemplateError( + Target, "Sorter", ERR_PARM1, TP, + " Sorter [%s] unknown!", + TP->Tokens->Params[0]->Start); + break; + case eINVALID_PARAM: + LogTemplateError(NULL, "Sorter", ERR_PARM1, TP, + " Sorter specified by BSTR 'SortBy' [%s] unknown!", + bstr("SortBy")); + case eNOT_SPECIFIED: + case eFOUND: + if (Next == Param) { + SortIcon = &SortIcons[SortOrder]; + } + else { /** Not Us... */ + SortIcon = &SortIcons[0]; + } + StrBufAppendBufPlain(Target, SortIcon->Key, SortIcon->len, 0); + } +} + +void tmplput_SORT_NEXT(StrBuf *Target, WCTemplputParams *TP) +{ + long SortOrder; + SortStruct *Next; + SortStruct *Param; + + switch (GetSortMetric(TP, &Next, &Param, &SortOrder)){ + case eNO_SUCH_SORT: + LogTemplateError( + Target, "Sorter", ERR_PARM1, TP, + " Sorter [%s] unknown!", + TP->Tokens->Params[0]->Start); + break; + case eINVALID_PARAM: + 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); + + } +} + +void tmplput_SORT_ORDER(StrBuf *Target, WCTemplputParams *TP) +{ + long SortOrder; + const ConstStr *SortOrderStr; + SortStruct *Next; + SortStruct *Param; + + switch (GetSortMetric(TP, &Next, &Param, &SortOrder)){ + case eNO_SUCH_SORT: + LogTemplateError( + Target, "Sorter", ERR_PARM1, TP, + " Sorter [%s] unknown!", + TP->Tokens->Params[0]->Start); + break; + case eINVALID_PARAM: + LogTemplateError( + NULL, "Sorter", ERR_PARM1, TP, + " Sorter specified by BSTR 'SortBy' [%s] unknown!", + bstr("SortBy")); + case eNOT_SPECIFIED: + case eFOUND: + if (Next == Param) { + SortOrderStr = &SortNextOrder[SortOrder]; + } + else { /** Not Us... */ + SortOrderStr = &SortNextOrder[0]; + } + StrBufAppendBufPlain(Target, SortOrderStr->Key, SortOrderStr->len, 0); + } +} + + +void tmplput_long_vector(StrBuf *Target, WCTemplputParams *TP) +{ + long *LongVector = (long*) CTX; + + if ((TP->Tokens->Params[0]->Type == TYPE_LONG) && + (TP->Tokens->Params[0]->lvalue <= LongVector[0])) + { + StrBufAppendPrintf(Target, "%ld", LongVector[TP->Tokens->Params[0]->lvalue]); + } + else + { + if (TP->Tokens->Params[0]->Type != TYPE_LONG) { + LogTemplateError( + Target, "Longvector", ERR_NAME, TP, + "needs a numerical Parameter!"); + } + else { + 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(StrBuf *Target, WCTemplputParams *TP) +{ + long *LongVector = (long*) CTX; + + 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[TP->Tokens->Params[2]->lvalue] == + LongVector[TP->Tokens->Params[3]->lvalue]; + } + else + { + 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 { + 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 InitModule_SUBST (void) { - RegisterNS(HKEY("SERV_PID"), 0, 0, tmplput_serv_ip); - RegisterNS(HKEY("SERV_NODENAME"), 0, 0, tmplput_serv_nodename); - RegisterNS(HKEY("SERV_HUMANNODE"), 0, 0, tmplput_serv_humannode); - RegisterNS(HKEY("SERV_FQDN"), 0, 0, tmplput_serv_fqdn); - RegisterNS(HKEY("SERV_SOFTWARE"), 0, 0, tmmplput_serv_software); - RegisterNS(HKEY("SERV_REV_LEVEL"), 0, 0, tmplput_serv_rev_level); - RegisterNS(HKEY("SERV_BBS_CITY"), 0, 0, tmmplput_serv_bbs_city); - RegisterNS(HKEY("CURRENT_USER"), 0, 0, tmplput_current_user); - RegisterNS(HKEY("CURRENT_ROOM"), 0, 0, tmplput_current_room); + memset(&NoCtx, 0, sizeof(WCTemplputParams)); + 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); + RegisterConditional(HKEY("COND:CONTEXTSTR"), 3, ConditionalContextStr, CTX_STRBUF); + RegisterConditional(HKEY("COND:LONGVECTOR"), 4, ConditionalLongVector, CTX_LONGVECTOR); } /*@}*/