X-Git-Url: https://code.citadel.org/?p=citadel.git;a=blobdiff_plain;f=webcit%2Fsubst.c;h=0cd7615f26b1b5746b8c4871be568aa9b2090e56;hp=0798d3b71b29cccfb3fdb152a4001e7e1a47266b;hb=5d2d3f4eea91c74af93c735bff7ad9955b466181;hpb=9f8e0bd23ce7dde31156b634f3a66bf234b11927 diff --git a/webcit/subst.c b/webcit/subst.c index 0798d3b71..0cd7615f2 100644 --- a/webcit/subst.c +++ b/webcit/subst.c @@ -17,7 +17,7 @@ #include "webcit.h" #include "webserver.h" -extern char *static_dirs[PATH_MAX]; /* Disk representation */ +extern char *static_dirs[PATH_MAX]; /* Disk representation */ HashList *TemplateCache; HashList *LocalTemplateCache; @@ -34,7 +34,7 @@ int dbg_backtrace_template_errors = 0; WCTemplputParams NoCtx; StrBuf *I18nDump = NULL; -const char EmptyStr[] = ""; +const char EmptyStr[]=""; #define SV_GETTEXT 1 #define SV_CONDITIONAL 2 @@ -50,11 +50,11 @@ const char EmptyStr[] = ""; */ 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 ??? */ + 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; @@ -71,15 +71,15 @@ typedef struct _HashHandler { ContextFilter Filter; WCPreevalFunc PreEvalFunc; WCHandlerFunc HandlerFunc; -} HashHandler; +}HashHandler; typedef enum _estate { eNext, eSkipTilEnd } TemplState; -void *load_template(StrBuf * Target, WCTemplate * NewTemplate); -int EvaluateConditional(StrBuf * Target, int Neg, int state, WCTemplputParams ** TPP); +void *load_template(StrBuf *Target, WCTemplate *NewTemplate); +int EvaluateConditional(StrBuf *Target, int Neg, int state, WCTemplputParams **TPP); @@ -91,7 +91,7 @@ typedef struct _SortStruct { CompareFunc GroupChange; CtxType ContextType; -} SortStruct; +}SortStruct; HashList *CtxList = NULL; @@ -104,21 +104,24 @@ CtxType CTX_LONGVECTOR = CTX_NONE; CtxType CTX_ITERATE = CTX_NONE; CtxType CTX_TAB = CTX_NONE; -void HFreeContextType(void *pCtx) { +void HFreeContextType(void *pCtx) +{ CtxTypeStruct *FreeStruct = (CtxTypeStruct *) pCtx; FreeStrBuf(&FreeStruct->Name); free(FreeStruct); } -void PutContextType(const char *name, long len, CtxType TheCtx) { +void PutContextType(const char *name, long len, CtxType TheCtx) +{ CtxTypeStruct *NewStruct; - NewStruct = (CtxTypeStruct *) malloc(sizeof(CtxTypeStruct)); + NewStruct = (CtxTypeStruct*) malloc(sizeof(CtxTypeStruct)); NewStruct->Name = NewStrBufPlain(name, len); NewStruct->Type = TheCtx; Put(CtxList, IKEY(NewStruct->Type), NewStruct, HFreeContextType); } -void RegisterContextType(const char *name, long len, CtxType * TheCtx) { +void RegisterContextType(const char *name, long len, CtxType *TheCtx) +{ if (*TheCtx != CTX_NONE) return; @@ -126,7 +129,8 @@ void RegisterContextType(const char *name, long len, CtxType * TheCtx) { PutContextType(name, len, *TheCtx); } -CtxTypeStruct *GetContextType(CtxType Type) { +CtxTypeStruct *GetContextType(CtxType Type) +{ void *pv = NULL; GetHash(CtxList, IKEY(Type), &pv); return pv; @@ -134,21 +138,27 @@ CtxTypeStruct *GetContextType(CtxType Type) { const char *UnknownContext = "CTX_UNKNOWN"; -const char *ContextName(CtxType ContextType) { +const char *ContextName(CtxType ContextType) +{ CtxTypeStruct *pCtx; pCtx = GetContextType(ContextType); - if (pCtx != NULL) + if (pCtx != NULL) return ChrPtr(pCtx->Name); else return UnknownContext; } -void StackDynamicContext(WCTemplputParams * Super, - WCTemplputParams * Sub, +void StackDynamicContext(WCTemplputParams *Super, + WCTemplputParams *Sub, void *Context, - CtxType ContextType, int nArgs, WCTemplateToken * Tokens, WCConditionalFunc ExitCtx, long ExitCTXID) { + CtxType ContextType, + int nArgs, + WCTemplateToken *Tokens, + WCConditionalFunc ExitCtx, + long ExitCTXID) +{ memset(Sub, 0, sizeof(WCTemplputParams)); if (Super != NULL) { @@ -158,7 +168,7 @@ void StackDynamicContext(WCTemplputParams * Super, if (Sub->Sub != NULL) Sub->Sub->Super = Sub; Sub->Super = Super; - + Sub->Context = Context; Sub->Filter.ContextType = ContextType; Sub->nArgs = nArgs; @@ -167,22 +177,27 @@ void StackDynamicContext(WCTemplputParams * Super, Sub->ExitCTXID = ExitCTXID; } -void UnStackContext(WCTemplputParams * Sub) { - if (Sub->Super != NULL) { +void UnStackContext(WCTemplputParams *Sub) +{ + if (Sub->Super != NULL) + { Sub->Super->Sub = Sub->Sub; } - if (Sub->Sub != NULL) { + if (Sub->Sub != NULL) + { Sub->Sub->Super = Sub->Super; } } -void UnStackDynamicContext(StrBuf * Target, WCTemplputParams ** TPP) { +void UnStackDynamicContext(StrBuf *Target, WCTemplputParams **TPP) +{ WCTemplputParams *TP = *TPP; WCTemplputParams *Super = TP->Super; TP->ExitCtx(Target, TP); *TPP = Super; } -void *GetContextPayload(WCTemplputParams * TP, CtxType ContextType) { +void *GetContextPayload(WCTemplputParams *TP, CtxType ContextType) +{ WCTemplputParams *whichTP = TP; if (ContextType == CTX_NONE) @@ -191,73 +206,96 @@ void *GetContextPayload(WCTemplputParams * TP, CtxType ContextType) { while ((whichTP != NULL) && (whichTP->Filter.ContextType != ContextType)) whichTP = whichTP->Super; - return whichTP->Context; + return whichTP->Context; } -void DestroySortStruct(void *vSort) { - SortStruct *Sort = (SortStruct *) vSort; +void DestroySortStruct(void *vSort) +{ + SortStruct *Sort = (SortStruct*) vSort; FreeStrBuf(&Sort->Name); FreeStrBuf(&Sort->PrefPrepend); - free(Sort); + free (Sort); } -void LogTemplateError(StrBuf * Target, const char *Type, int ErrorPos, WCTemplputParams * TP, const char *Format, ...) { +void LogTemplateError (StrBuf *Target, const char *Type, int ErrorPos, WCTemplputParams *TP, const char *Format, ...) +{ StrBuf *Error; StrBuf *Info; - va_list arg_ptr; + va_list arg_ptr; const char *Err = NULL; Info = NewStrBuf(); Error = NewStrBuf(); - va_start(arg_ptr, Format); + 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 : ""; + case ERR_NAME: /* the main token name... */ + Err = (TP->Tokens!= NULL)? TP->Tokens->pName:""; break; default: - Err = ((TP->Tokens != NULL) && - (TP->Tokens->nParameters > ErrorPos - 1)) ? TP->Tokens->Params[ErrorPos - 1]->Start : ""; + Err = ((TP->Tokens!= NULL) && + (TP->Tokens->nParameters > ErrorPos - 1))? + TP->Tokens->Params[ErrorPos - 1]->Start : ""; break; } - if (TP->Tokens != NULL) { - syslog(LOG_WARNING, "%s [%s] (in '%s' line %ld); %s; [%s]\n", - Type, Err, ChrPtr(TP->Tokens->FileName), TP->Tokens->Line, ChrPtr(Error), ChrPtr(TP->Tokens->FlatToken)); - } - else { - syslog(LOG_WARNING, "%s: %s;\n", Type, ChrPtr(Error)); + if (TP->Tokens != NULL) + { + syslog(LOG_WARNING, "%s [%s] (in '%s' line %ld); %s; [%s]\n", + Type, + Err, + ChrPtr(TP->Tokens->FileName), + TP->Tokens->Line, + ChrPtr(Error), + ChrPtr(TP->Tokens->FlatToken)); + } + else + { + syslog(LOG_WARNING, "%s: %s;\n", + Type, + ChrPtr(Error)); } if (WC == NULL) { FreeStrBuf(&Info); FreeStrBuf(&Error); - return; + return; } - if (WC->WFBuf == NULL) - WC->WFBuf = NewStrBuf(); - if (TP->Tokens != NULL) { + if (WC->WFBuf == NULL) WC->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(WC->WFBuf, WildFireException(SKEY(TP->Tokens->FileName), TP->Tokens->Line, Info, 1), 1); + 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(WC->WFBuf, WildFireException(SKEY(TP->Tokens->FileName), + TP->Tokens->Line, + Info, + 1), 1); } else { - StrBufPrintf(Info, "%s [%s] %s; [%s]", Type, Err, ChrPtr(Error), ChrPtr(TP->Tokens->FlatToken)); + StrBufPrintf(Info, "%s [%s] %s; [%s]", + Type, + Err, + ChrPtr(Error), + ChrPtr(TP->Tokens->FlatToken)); SerializeJson(WC->WFBuf, WildFireException(HKEY(__FILE__), __LINE__, Info, 1), 1); } FreeStrBuf(&Info); @@ -265,72 +303,86 @@ void LogTemplateError(StrBuf * Target, const char *Type, int ErrorPos, WCTemplpu } -void LogError(StrBuf * Target, const char *Type, const char *Format, ...) { +void LogError (StrBuf *Target, const char *Type, const char *Format, ...) { StrBuf *Error; StrBuf *Info; - va_list arg_ptr; + va_list arg_ptr; Info = NewStrBuf(); Error = NewStrBuf(); - va_start(arg_ptr, Format); + va_start(arg_ptr, Format); StrBufVAppendPrintf(Error, Format, arg_ptr); va_end(arg_ptr); syslog(LOG_WARNING, "%s", ChrPtr(Error)); - if (WC->WFBuf == NULL) - WC->WFBuf = NewStrBuf(); + if (WC->WFBuf == NULL) WC->WFBuf = NewStrBuf(); - SerializeJson(WC->WFBuf, WildFireException(Type, strlen(Type), 0, Info, 1), 1); + SerializeJson(WC->WFBuf, WildFireException(Type, strlen(Type), + 0, + Info, + 1), 1); FreeStrBuf(&Info); FreeStrBuf(&Error); } -void RegisterNS(const char *NSName, - long len, - int nMinArgs, int nMaxArgs, WCHandlerFunc HandlerFunc, WCPreevalFunc PreevalFunc, CtxType ContextRequired) { +void RegisterNS(const char *NSName, + long len, + int nMinArgs, + int nMaxArgs, + WCHandlerFunc HandlerFunc, + WCPreevalFunc PreevalFunc, + CtxType ContextRequired) +{ HashHandler *NewHandler; - - NewHandler = (HashHandler *) malloc(sizeof(HashHandler)); + + NewHandler = (HashHandler*) malloc(sizeof(HashHandler)); memset(NewHandler, 0, sizeof(HashHandler)); NewHandler->Filter.nMinArgs = nMinArgs; NewHandler->Filter.nMaxArgs = nMaxArgs; NewHandler->Filter.ContextType = ContextRequired; NewHandler->PreEvalFunc = PreevalFunc; - NewHandler->HandlerFunc = HandlerFunc; + NewHandler->HandlerFunc = HandlerFunc; Put(GlobalNS, NSName, len, NewHandler, NULL); } -int CheckContext(StrBuf * Target, ContextFilter * Need, WCTemplputParams * TP, const char *ErrType) { +int CheckContext(StrBuf *Target, ContextFilter *Need, WCTemplputParams *TP, const char *ErrType) +{ WCTemplputParams *TPP = TP; - - if ((Need != NULL) && (Need->ContextType != CTX_NONE) && (Need->ContextType != TPP->Filter.ContextType)) { - - while ((TPP != NULL) && (Need->ContextType != TPP->Filter.ContextType)) { + + if ((Need != NULL) && + (Need->ContextType != CTX_NONE) && + (Need->ContextType != TPP->Filter.ContextType)) { + + while ((TPP != NULL) && + (Need->ContextType != TPP->Filter.ContextType)) + { TPP = TPP->Super; } if (TPP != NULL) return 1; - LogTemplateError(Target, ErrType, ERR_NAME, TP, - " WARNING: requires Context: [%s], have [%s]!", - ContextName(Need->ContextType), ContextName(TP->Filter.ContextType)); + LogTemplateError( + Target, ErrType, ERR_NAME, TP, + " WARNING: requires Context: [%s], have [%s]!", + ContextName(Need->ContextType), + ContextName(TP->Filter.ContextType)); return 0; } return 1; } -void FreeToken(WCTemplateToken ** Token) { - int i; +void FreeToken(WCTemplateToken **Token) { + int i; FreeStrBuf(&(*Token)->FlatToken); - if ((*Token)->HaveParameters) + if ((*Token)->HaveParameters) for (i = 0; i < (*Token)->nParameters; i++) free((*Token)->Params[i]); free(*Token); @@ -340,10 +392,10 @@ void FreeToken(WCTemplateToken ** Token) { void FreeWCTemplate(void *vFreeMe) { int i; - WCTemplate *FreeMe = (WCTemplate *) vFreeMe; + WCTemplate *FreeMe = (WCTemplate*)vFreeMe; if (FreeMe->TokenSpace > 0) { - for (i = 0; i < FreeMe->nTokensUsed; i++) { + for (i = 0; i < FreeMe->nTokensUsed; i ++) { FreeToken(&FreeMe->Tokens[i]); } free(FreeMe->Tokens); @@ -354,7 +406,12 @@ void FreeWCTemplate(void *vFreeMe) { free(FreeMe); } -int HaveTemplateTokenString(StrBuf * Target, WCTemplputParams * TP, int N, const char **Value, long *len) { +int HaveTemplateTokenString(StrBuf *Target, + WCTemplputParams *TP, + int N, + const char **Value, + long *len) +{ if (N >= TP->Tokens->nParameters) { return 0; } @@ -375,11 +432,13 @@ int HaveTemplateTokenString(StrBuf * Target, WCTemplputParams * TP, int N, const } } -void GetTemplateTokenString(StrBuf * Target, WCTemplputParams * TP, int N, const char **Value, long *len) { +void GetTemplateTokenString(StrBuf *Target, WCTemplputParams *TP, int N, const char **Value, long *len) { StrBuf *Buf; if (N >= TP->Tokens->nParameters) { - LogTemplateError(Target, "TokenParameter", N, TP, "invalid token %d. this shouldn't have come till here.\n", N); + LogTemplateError(Target, + "TokenParameter", N, TP, + "invalid token %d. this shouldn't have come till here.\n", N); *Value = ""; *len = 0; return; @@ -394,21 +453,21 @@ void GetTemplateTokenString(StrBuf * Target, WCTemplputParams * TP, int N, const break; case TYPE_BSTR: if (TP->Tokens->Params[N]->len == 0) { - LogTemplateError(Target, - "TokenParameter", N, TP, + 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)); + Buf = (StrBuf*) SBstr(TKEY(N)); *Value = ChrPtr(Buf); *len = StrLength(Buf); break; case TYPE_PREFSTR: if (TP->Tokens->Params[N]->len == 0) { - LogTemplateError(Target, - "TokenParameter", N, TP, + LogTemplateError(Target, + "TokenParameter", N, TP, "Requesting parameter %d; of type PREFSTR, empty lookup string not admitted.", N); *len = 0; *Value = EmptyStr; @@ -420,8 +479,8 @@ void GetTemplateTokenString(StrBuf * Target, WCTemplputParams * TP, int N, const break; case TYPE_ROOMPREFSTR: if (TP->Tokens->Params[N]->len == 0) { - LogTemplateError(Target, - "TokenParameter", N, TP, + LogTemplateError(Target, + "TokenParameter", N, TP, "Requesting parameter %d; of type PREFSTR, empty lookup string not admitted.", N); *len = 0; *Value = EmptyStr; @@ -432,10 +491,14 @@ void GetTemplateTokenString(StrBuf * Target, WCTemplputParams * TP, int N, const *len = StrLength(Buf); break; case TYPE_LONG: - LogTemplateError(Target, "TokenParameter", N, TP, "Requesting parameter %d; of type LONG, want string.", N); + LogTemplateError(Target, + "TokenParameter", N, TP, + "Requesting parameter %d; of type LONG, want string.", N); break; case TYPE_PREFINT: - LogTemplateError(Target, "TokenParameter", N, TP, "Requesting parameter %d; of type PREFINT, want string.", N); + LogTemplateError(Target, + "TokenParameter", N, TP, + "Requesting parameter %d; of type PREFINT, want string.", N); break; case TYPE_GETTEXT: *Value = _(TP->Tokens->Params[N]->Start); @@ -443,8 +506,8 @@ void GetTemplateTokenString(StrBuf * Target, WCTemplputParams * TP, int N, const break; case TYPE_SUBTEMPLATE: if (TP->Tokens->Params[N]->len == 0) { - LogTemplateError(Target, - "TokenParameter", N, TP, + LogTemplateError(Target, + "TokenParameter", N, TP, "Requesting parameter %d; of type SUBTEMPLATE, empty lookup string not admitted.", N); *len = 0; *Value = EmptyStr; @@ -461,16 +524,20 @@ void GetTemplateTokenString(StrBuf * Target, WCTemplputParams * TP, int N, const break; default: - LogTemplateError(Target, "TokenParameter", N, TP, "unknown param type %d; [%d]", N, TP->Tokens->Params[N]->Type); + LogTemplateError(Target, + "TokenParameter", N, TP, + "unknown param type %d; [%d]", N, TP->Tokens->Params[N]->Type); break; } } -long GetTemplateTokenNumber(StrBuf * Target, WCTemplputParams * TP, int N, long dflt) { +long GetTemplateTokenNumber(StrBuf *Target, WCTemplputParams *TP, int N, long dflt) { long Ret; if (N >= TP->Tokens->nParameters) { - LogTemplateError(Target, "TokenParameter", N, TP, "invalid token %d. this shouldn't have come till here.\n", N); - wc_backtrace(LOG_DEBUG); + LogTemplateError(Target, + "TokenParameter", N, TP, + "invalid token %d. this shouldn't have come till here.\n", N); + wc_backtrace(LOG_DEBUG); return 0; } @@ -481,18 +548,20 @@ long GetTemplateTokenNumber(StrBuf * Target, WCTemplputParams * TP, int N, long break; case TYPE_BSTR: if (TP->Tokens->Params[N]->len == 0) { - LogTemplateError(Target, - "TokenParameter", N, TP, + LogTemplateError(Target, + "TokenParameter", N, TP, "Requesting parameter %d; of type BSTR, empty lookup string not admitted.", N); return 0; } - return LBstr(TKEY(N)); + return LBstr(TKEY(N)); break; case TYPE_PREFSTR: - LogTemplateError(Target, "TokenParameter", N, TP, "requesting a prefstring in param %d want a number", N); + 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, + LogTemplateError(Target, + "TokenParameter", N, TP, "Requesting parameter %d; of type PREFSTR, empty lookup string not admitted.", N); return 0; } @@ -500,10 +569,12 @@ long GetTemplateTokenNumber(StrBuf * Target, WCTemplputParams * TP, int N, long return Ret; return 0; case TYPE_ROOMPREFSTR: - LogTemplateError(Target, "TokenParameter", N, TP, "requesting a prefstring in param %d want a number", N); + 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, + LogTemplateError(Target, + "TokenParameter", N, TP, "Requesting parameter %d; of type PREFSTR, empty lookup string not admitted.", N); return 0; } @@ -515,23 +586,28 @@ long GetTemplateTokenNumber(StrBuf * Target, WCTemplputParams * TP, int N, long return TP->Tokens->Params[N]->lvalue; case TYPE_PREFINT: if (TP->Tokens->Params[N]->len == 0) { - LogTemplateError(Target, - "TokenParameter", N, TP, + 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; + return 0; case TYPE_GETTEXT: - LogTemplateError(Target, "TokenParameter", N, TP, "requesting a I18N string in param %d; want a number", N); + 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); + 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); + LogTemplateError(Target, + "TokenParameter", N, TP, + "unknown param type %d; [%d]", N, TP->Tokens->Params[N]->Type); return 0; } } @@ -542,18 +618,23 @@ long GetTemplateTokenNumber(StrBuf * Target, WCTemplputParams * TP, int N, long * Source = the string we should put into the template * FormatTypeIndex = where should we look for escape types if? */ -void StrBufAppendTemplate(StrBuf * Target, WCTemplputParams * TP, const StrBuf * Source, int FormatTypeIndex) { +void StrBufAppendTemplate(StrBuf *Target, + WCTemplputParams *TP, + const StrBuf *Source, int FormatTypeIndex) +{ const char *pFmt = NULL; char EscapeAs = ' '; if ((FormatTypeIndex < TP->Tokens->nParameters) && (TP->Tokens->Params[FormatTypeIndex] != NULL) && - (TP->Tokens->Params[FormatTypeIndex]->Type == TYPE_STR) && (TP->Tokens->Params[FormatTypeIndex]->len >= 1)) { + (TP->Tokens->Params[FormatTypeIndex]->Type == TYPE_STR) && + (TP->Tokens->Params[FormatTypeIndex]->len >= 1)) { pFmt = TP->Tokens->Params[FormatTypeIndex]->Start; EscapeAs = *pFmt; } - switch (EscapeAs) { + switch(EscapeAs) + { case 'H': StrEscAppend(Target, Source, NULL, 0, 2); break; @@ -570,12 +651,9 @@ void StrBufAppendTemplate(StrBuf * Target, WCTemplputParams * TP, const StrBuf * StrBufUrlescAppend(Target, Source, NULL); break; case 'F': - if (pFmt != NULL) - pFmt++; - else - pFmt = "JUSTIFY"; - if (*pFmt == '\0') - pFmt = "JUSTIFY"; + if (pFmt != NULL) pFmt++; + else pFmt = "JUSTIFY"; + if (*pFmt == '\0') pFmt = "JUSTIFY"; FmOut(Target, pFmt, Source); break; default: @@ -588,17 +666,22 @@ void StrBufAppendTemplate(StrBuf * Target, WCTemplputParams * TP, const StrBuf * * Source = the string we should put into the template * FormatTypeIndex = where should we look for escape types if? */ -void StrBufAppendTemplateStr(StrBuf * Target, WCTemplputParams * TP, const char *Source, int FormatTypeIndex) { +void StrBufAppendTemplateStr(StrBuf *Target, + WCTemplputParams *TP, + const char *Source, int FormatTypeIndex) +{ const char *pFmt = NULL; char EscapeAs = ' '; if ((FormatTypeIndex < TP->Tokens->nParameters) && - (TP->Tokens->Params[FormatTypeIndex]->Type == TYPE_STR) && (TP->Tokens->Params[FormatTypeIndex]->len >= 1)) { + (TP->Tokens->Params[FormatTypeIndex]->Type == TYPE_STR) && + (TP->Tokens->Params[FormatTypeIndex]->len >= 1)) { pFmt = TP->Tokens->Params[FormatTypeIndex]->Start; EscapeAs = *pFmt; } - switch (EscapeAs) { + switch(EscapeAs) + { case 'H': StrEscAppend(Target, NULL, Source, 0, 2); break; @@ -607,14 +690,13 @@ void StrBufAppendTemplateStr(StrBuf * Target, WCTemplputParams * TP, const char break; case 'J': StrECMAEscAppend(Target, NULL, Source); - break; + break; case 'K': StrHtmlEcmaEscAppend(Target, NULL, Source, 0, 0); - break; + break; case 'U': StrBufUrlescAppend(Target, NULL, Source); break; - /* case 'F': if (pFmt != NULL) pFmt++; @@ -629,21 +711,27 @@ void StrBufAppendTemplateStr(StrBuf * Target, WCTemplputParams * TP, const char } -void PutNewToken(WCTemplate * Template, WCTemplateToken * NewToken) { +void PutNewToken(WCTemplate *Template, WCTemplateToken *NewToken) +{ if (Template->nTokensUsed + 1 >= Template->TokenSpace) { if (Template->TokenSpace <= 0) { - Template->Tokens = (WCTemplateToken **) malloc(sizeof(WCTemplateToken *) * 10); - memset(Template->Tokens, 0, sizeof(WCTemplateToken *) * 10); + 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); + NewTokens= (WCTemplateToken**) malloc( + sizeof(WCTemplateToken*) * Template->TokenSpace * 2); - memset(NewTokens, 0, sizeof(WCTemplateToken *) * Template->TokenSpace * 2); + memset(NewTokens, + 0, sizeof(WCTemplateToken*) * Template->TokenSpace * 2); - memcpy(NewTokens, Template->Tokens, sizeof(WCTemplateToken *) * Template->nTokensUsed); + memcpy(NewTokens, + Template->Tokens, + sizeof(WCTemplateToken*) * Template->nTokensUsed); free(Template->Tokens); Template->TokenSpace *= 2; @@ -653,9 +741,14 @@ void PutNewToken(WCTemplate * Template, WCTemplateToken * NewToken) { Template->Tokens[(Template->nTokensUsed)++] = NewToken; } -int GetNextParameter(StrBuf * Buf, - const char **pCh, - const char *pe, WCTemplateToken * Tokens, WCTemplate * pTmpl, WCTemplputParams * TP, TemplateParam ** pParm) { +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; @@ -667,58 +760,60 @@ int GetNextParameter(StrBuf * Buf, Parm->Type = TYPE_STR; /* Skip leading whitespaces */ - while ((*pch == ' ') || (*pch == '\t') || (*pch == '\r') || (*pch == '\n')) - pch++; + while ((*pch == ' ' )|| + (*pch == '\t')|| + (*pch == '\r')|| + (*pch == '\n')) pch ++; if (*pch == ':') { Parm->Type = TYPE_PREFSTR; - pch++; + pch ++; if (*pch == '(') { - pch++; + pch ++; ParamBrace = 1; } } else if (*pch == '.') { Parm->Type = TYPE_ROOMPREFSTR; - pch++; + pch ++; if (*pch == '(') { - pch++; + pch ++; ParamBrace = 1; } } else if (*pch == ';') { Parm->Type = TYPE_PREFINT; - pch++; + pch ++; if (*pch == '(') { - pch++; + pch ++; ParamBrace = 1; } } else if (*pch == '#') { Parm->Type = TYPE_INTDEFINE; - pch++; + pch ++; } else if (*pch == '_') { Parm->Type = TYPE_GETTEXT; - pch++; + pch ++; if (*pch == '(') { - pch++; + pch ++; ParamBrace = 1; } } else if (*pch == 'B') { Parm->Type = TYPE_BSTR; - pch++; + pch ++; if (*pch == '(') { - pch++; + pch ++; ParamBrace = 1; } } else if (*pch == '=') { Parm->Type = TYPE_SUBTEMPLATE; - pch++; + pch ++; if (*pch == '(') { - pch++; + pch ++; ParamBrace = 1; } } @@ -729,34 +824,40 @@ int GetNextParameter(StrBuf * Buf, else if (*pch == '\'') quote = '\''; if (quote != '\0') { - pch++; + pch ++; pchs = pch; - while (pch <= pe && ((*pch != quote) || ((pch > pchs) && (*(pch - 1) == '\\')) - )) { - pch++; + while (pch <= pe && + ((*pch != quote) || + ( (pch > pchs) && (*(pch - 1) == '\\')) + )) { + pch ++; } pche = pch; if (*pch != quote) { syslog(LOG_WARNING, "Error (in '%s' line %ld); " - "evaluating template param [%s] in Token [%s]\n", - ChrPtr(pTmpl->FileName), Tokens->Line, ChrPtr(Tokens->FlatToken), *pCh); - pch++; + "evaluating template param [%s] in Token [%s]\n", + ChrPtr(pTmpl->FileName), + Tokens->Line, + ChrPtr(Tokens->FlatToken), + *pCh); + pch ++; free(Parm); *pParm = NULL; return 0; } else { - StrBufPeek(Buf, pch, -1, '\0'); - if (LoadTemplates > 1) { + StrBufPeek(Buf, pch, -1, '\0'); + if (LoadTemplates > 1) { syslog(LOG_DEBUG, - "DBG: got param [%s] " SIZE_T_FMT " " SIZE_T_FMT "\n", pchs, pche - pchs, strlen(pchs) - ); + "DBG: got param [%s] "SIZE_T_FMT" "SIZE_T_FMT"\n", + pchs, pche - pchs, strlen(pchs) + ); } Parm->Start = pchs; Parm->len = pche - pchs; - pch++; /* move after trailing quote */ + pch ++; /* move after trailing quote */ if (ParamBrace && (*pch == ')')) { - pch++; + pch ++; } } @@ -764,10 +865,13 @@ int GetNextParameter(StrBuf * Buf, else { Parm->Type = TYPE_LONG; pchs = pch; - while ((pch <= pe) && (isdigit(*pch) || (*pch == '+') || (*pch == '-'))) - pch++; - pch++; - if (pch - pchs > 1) { + 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; @@ -775,7 +879,6 @@ int GetNextParameter(StrBuf * Buf, } else { Parm->lvalue = 0; - /* TODO whUT? syslog(LOG_DEBUG, "Error (in '%s' line %ld); " "evaluating long template param [%s] in Token [%s]\n", @@ -789,131 +892,161 @@ int GetNextParameter(StrBuf * Buf, return 0; } } - while ((*pch == ' ') || (*pch == '\t') || (*pch == '\r') || (*pch == ',') || (*pch == '\n')) - pch++; + while ((*pch == ' ' )|| + (*pch == '\t')|| + (*pch == '\r')|| + (*pch == ',' )|| + (*pch == '\n')) pch ++; - switch (Parm->Type) { + 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)); + 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)); - } } } - FreeStrBuf(&pToken); - FreeStrBuf(&Match); } - else if (strchr(Parm->Start, '&') != NULL) { - const char *Pos; - StrBuf *pToken; - StrBuf *Match; - - Parm->MaskBy = eAND; - pToken = NewStrBufPlain(Parm->Start, Parm->len); - Match = NewStrBufPlain(NULL, Parm->len); - Pos = ChrPtr(pToken); - - while ((Pos != NULL) && (Pos != StrBufNOTNULL)) { - StrBufExtract_NextToken(Match, pToken, &Pos, '&'); - StrBufTrim(Match); - if (StrLength(Match) > 0) { - if (GetHash(Defines, SKEY(Match), &vPVal) && (vPVal != NULL)) { - long *PVal; - PVal = (long *) vPVal; - - Parm->lvalue |= *PVal; - } - else { - LogTemplateError(NULL, "Define", - Tokens->nParameters, - TP, "%s isn't known!!", ChrPtr(Match)); + FreeStrBuf(&pToken); + FreeStrBuf(&Match); + } + else if (strchr(Parm->Start, '&') != NULL) + { + const char *Pos; + StrBuf *pToken; + StrBuf *Match; + + Parm->MaskBy = eAND; + pToken = NewStrBufPlain (Parm->Start, Parm->len); + Match = NewStrBufPlain (NULL, Parm->len); + Pos = ChrPtr(pToken); + + while ((Pos != NULL) && (Pos != StrBufNOTNULL)) + { + StrBufExtract_NextToken(Match, pToken, &Pos, '&'); + StrBufTrim(Match); + if (StrLength (Match) > 0) + { + if (GetHash(Defines, SKEY(Match), &vPVal) && + (vPVal != NULL)) + { + long *PVal; + PVal = (long*) vPVal; + + Parm->lvalue |= *PVal; + } + else { + LogTemplateError(NULL, "Define", + Tokens->nParameters, + TP, + "%s isn't known!!", + ChrPtr(Match)); - } } } - FreeStrBuf(&Match); - FreeStrBuf(&pToken); } - else { + FreeStrBuf(&Match); + FreeStrBuf(&pToken); + } + else { - LogTemplateError(NULL, "Define", Tokens->nParameters, TP, "%s isn't known!!", Parm->Start); - } - } + 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"); - } - } + 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 1; } -WCTemplateToken *NewTemplateSubstitute(StrBuf * Buf, - const char *pStart, - const char *pTokenStart, const char *pTokenEnd, long Line, WCTemplate * pTmpl) { +WCTemplateToken *NewTemplateSubstitute(StrBuf *Buf, + const char *pStart, + const char *pTokenStart, + const char *pTokenEnd, + long Line, + WCTemplate *pTmpl) +{ void *vVar; const char *pch; WCTemplateToken *NewToken; WCTemplputParams TP; - NewToken = (WCTemplateToken *) malloc(sizeof(WCTemplateToken)); + NewToken = (WCTemplateToken*)malloc(sizeof(WCTemplateToken)); memset(NewToken, 0, sizeof(WCTemplateToken)); TP.Tokens = NewToken; - NewToken->FileName = pTmpl->FileName; /* to print meaningfull log messages... */ + NewToken->FileName = pTmpl->FileName; /* to print meaningfull log messages... */ NewToken->Flags = 0; NewToken->Line = Line + 1; NewToken->pTokenStart = pTokenStart; NewToken->TokenStart = pTokenStart - pStart; - NewToken->TokenEnd = (pTokenEnd - pStart) - NewToken->TokenStart; + NewToken->TokenEnd = (pTokenEnd - pStart) - NewToken->TokenStart; NewToken->pTokenEnd = pTokenEnd; NewToken->NameEnd = NewToken->TokenEnd - 2; NewToken->PreEval = NULL; NewToken->FlatToken = NewStrBufPlain(pTokenStart + 2, pTokenEnd - pTokenStart - 2); StrBufShrinkToFit(NewToken->FlatToken, 1); - StrBufPeek(Buf, pTokenStart, +1, '\0'); + StrBufPeek(Buf, pTokenStart, + 1, '\0'); StrBufPeek(Buf, pTokenEnd, -1, '\0'); pch = NewToken->pName = pTokenStart + 2; @@ -924,30 +1057,39 @@ WCTemplateToken *NewTemplateSubstitute(StrBuf * Buf, if (*pch == '(') { StrBufPeek(Buf, pch, -1, '\0'); NewToken->NameEnd = pch - NewToken->pName; - pch++; + pch ++; if (*(pTokenEnd - 1) != ')') { - LogTemplateError(NULL, "Parseerror", ERR_NAME, &TP, - "Warning, Non welformed Token; missing right parenthesis"); + LogTemplateError( + NULL, "Parseerror", ERR_NAME, &TP, + "Warning, Non welformed Token; missing right parenthesis"); } while (pch < pTokenEnd - 1) { NewToken->nParameters++; - if (GetNextParameter(Buf, - &pch, - pTokenEnd - 1, - NewToken, pTmpl, &TP, &NewToken->Params[NewToken->nParameters - 1])) { + if (GetNextParameter(Buf, + &pch, + pTokenEnd - 1, + NewToken, + pTmpl, + &TP, + &NewToken->Params[NewToken->nParameters - 1])) + { NewToken->HaveParameters = 1; if (NewToken->nParameters >= MAXPARAM) { - LogTemplateError(NULL, "Parseerror", ERR_NAME, &TP, - "only [%d] Params allowed in Tokens", MAXPARAM); + LogTemplateError( + NULL, "Parseerror", ERR_NAME, &TP, + "only [%d] Params allowed in Tokens", + MAXPARAM); FreeToken(&NewToken); return NULL; } } - else - break; + else break; } - if ((NewToken->NameEnd == 1) && (NewToken->HaveParameters == 1)) { + if((NewToken->NameEnd == 1) && + (NewToken->HaveParameters == 1)) + + { if (*(NewToken->pName) == '_') NewToken->Flags = SV_GETTEXT; else if (*(NewToken->pName) == '=') @@ -960,48 +1102,60 @@ WCTemplateToken *NewTemplateSubstitute(StrBuf * Buf, NewToken->Flags = SV_NEG_CONDITIONAL; } } - else - pch++; + else pch ++; } - + switch (NewToken->Flags) { case 0: /* If we're able to find out more about the token, do it now while its fresh. */ pch = NewToken->pName; - while (pch < NewToken->pName + NewToken->NameEnd) { - if (((*pch >= 'A') && (*pch <= 'Z')) || - ((*pch >= '0') && (*pch <= '9')) || (*pch == ':') || (*pch == '-') || (*pch == '_')) - pch++; - else { - LogTemplateError(NULL, "Token Name", ERR_NAME, &TP, "contains illegal char: '%c'", *pch); + while (pch < NewToken->pName + NewToken->NameEnd) + { + if (((*pch >= 'A') && (*pch <= 'Z')) || + ((*pch >= '0') && (*pch <= '9')) || + (*pch == ':') || + (*pch == '-') || + (*pch == '_')) + pch ++; + else + { + LogTemplateError( + NULL, "Token Name", ERR_NAME, &TP, + "contains illegal char: '%c'", + *pch); pch++; } } if (GetHash(GlobalNS, NewToken->pName, NewToken->NameEnd, &vVar)) { HashHandler *Handler; - Handler = (HashHandler *) vVar; - if ((NewToken->nParameters < Handler->Filter.nMinArgs) || + Handler = (HashHandler*) vVar; + 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); + LogTemplateError( + NULL, "Token", ERR_NAME, &TP, + "doesn't work with %d params", + NewToken->nParameters); } else { NewToken->PreEval = Handler; - NewToken->Flags = SV_PREEVALUATED; + NewToken->Flags = SV_PREEVALUATED; if (Handler->PreEvalFunc != NULL) Handler->PreEvalFunc(NewToken); } - } - else { - LogTemplateError(NULL, "Token ", ERR_NAME, &TP, " isn't known to us."); + } else { + LogTemplateError( + NULL, "Token ", ERR_NAME, &TP, + " isn't known to us."); } break; case SV_GETTEXT: if ((NewToken->nParameters < 1) || (NewToken->nParameters > 2)) { - LogTemplateError(NULL, "Gettext", ERR_NAME, &TP, - "requires 1 or 2 parameter, you gave %d params", NewToken->nParameters); + LogTemplateError( + NULL, "Gettext", ERR_NAME, &TP, + "requires 1 or 2 parameter, you gave %d params", + NewToken->nParameters); NewToken->Flags = 0; break; } @@ -1011,41 +1165,58 @@ WCTemplateToken *NewTemplateSubstitute(StrBuf * Buf, break; case SV_SUBTEMPL: if (NewToken->nParameters != 1) { - LogTemplateError(NULL, "Subtemplates", ERR_NAME, &TP, - "require exactly 1 parameter, you gave %d params", NewToken->nParameters); + 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, + 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"); + !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) { - LogTemplateError(NULL, "Conditional", ERR_PARM1, &TP, - "require at least 2 parameters, you gave %d params", NewToken->nParameters); + if (NewToken->nParameters <2) { + 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) { - LogTemplateError(NULL, "Conditional", ERR_PARM1, &TP, "Conditional ID (Parameter 1) mustn't be 0!"); + 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, &vVar) || (vVar == NULL)) { - if ((NewToken->Params[0]->len == 1) && (NewToken->Params[0]->Start[0] == 'X')) + 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_PARM1, &TP, "Not found!"); - + LogTemplateError( + NULL, "Conditional", ERR_PARM1, &TP, + "Not found!"); /* NewToken->Error = NewStrBuf(); StrBufAppendPrintf( @@ -1073,7 +1244,7 @@ WCTemplateToken *NewTemplateSubstitute(StrBuf * Buf, * Display a variable-substituted template * templatename template file to load */ -void *prepare_template(StrBuf * filename, StrBuf * Key, HashList * PutThere) { +void *prepare_template(StrBuf *filename, StrBuf *Key, HashList *PutThere) { WCTemplate *NewTemplate; NewTemplate = (WCTemplate *) malloc(sizeof(WCTemplate)); @@ -1084,7 +1255,7 @@ void *prepare_template(StrBuf * filename, StrBuf * Key, HashList * PutThere) { NewTemplate->nTokensUsed = 0; NewTemplate->TokenSpace = 0; NewTemplate->Tokens = NULL; - NewTemplate->MimeType = NewStrBufPlain(GuessMimeByFilename(SKEY(NewTemplate->FileName)), -1); + NewTemplate->MimeType = NewStrBufPlain(GuessMimeByFilename (SKEY(NewTemplate->FileName)), -1); if (strstr(ChrPtr(NewTemplate->MimeType), "text") != NULL) { StrBufAppendBufPlain(NewTemplate->MimeType, HKEY("; charset=utf-8"), 0); } @@ -1101,7 +1272,7 @@ void *prepare_template(StrBuf * filename, StrBuf * Key, HashList * PutThere) { * Display a variable-substituted template * templatename template file to load */ -void *duplicate_template(WCTemplate * OldTemplate) { +void *duplicate_template(WCTemplate *OldTemplate) { WCTemplate *NewTemplate; NewTemplate = (WCTemplate *) malloc(sizeof(WCTemplate)); @@ -1117,32 +1288,40 @@ void *duplicate_template(WCTemplate * OldTemplate) { } -void SanityCheckTemplate(StrBuf * Target, WCTemplate * CheckMe) { +void SanityCheckTemplate(StrBuf *Target, WCTemplate *CheckMe) { int i = 0; int j; int FoundConditionalEnd; for (i = 0; i < CheckMe->nTokensUsed; i++) { - switch (CheckMe->Tokens[i]->Flags) { + switch(CheckMe->Tokens[i]->Flags) { case SV_CONDITIONAL: case SV_NEG_CONDITIONAL: FoundConditionalEnd = 0; - if ((CheckMe->Tokens[i]->Params[0]->len == 1) && (CheckMe->Tokens[i]->Params[0]->Start[0] == 'X')) + if ((CheckMe->Tokens[i]->Params[0]->len == 1) && + (CheckMe->Tokens[i]->Params[0]->Start[0] == 'X')) break; - for (j = i + 1; j < CheckMe->nTokensUsed; j++) { + for (j = i + 1; j < CheckMe->nTokensUsed; j++) + { if (((CheckMe->Tokens[j]->Flags == SV_CONDITIONAL) || - (CheckMe->Tokens[j]->Flags == SV_NEG_CONDITIONAL)) && - (CheckMe->Tokens[i]->Params[1]->lvalue == CheckMe->Tokens[j]->Params[1]->lvalue)) { + (CheckMe->Tokens[j]->Flags == SV_NEG_CONDITIONAL)) && + (CheckMe->Tokens[i]->Params[1]->lvalue == + CheckMe->Tokens[j]->Params[1]->lvalue)) + { FoundConditionalEnd = 1; break; } } - if (!FoundConditionalEnd) { + if (!FoundConditionalEnd) + { WCTemplputParams TP; memset(&TP, 0, sizeof(WCTemplputParams)); TP.Tokens = CheckMe->Tokens[i]; - LogTemplateError(Target, "Token", ERR_PARM1, &TP, "Conditional without Endconditional"); + LogTemplateError( + Target, "Token", ERR_PARM1, &TP, + "Conditional without Endconditional" + ); } break; default: @@ -1155,7 +1334,8 @@ void SanityCheckTemplate(StrBuf * Target, WCTemplate * CheckMe) { * Display a variable-substituted template * templatename template file to load */ -void *load_template(StrBuf * Target, WCTemplate * NewTemplate) { +void *load_template(StrBuf *Target, WCTemplate *NewTemplate) +{ int fd; struct stat statbuf; const char *pS, *pE, *pch, *Err; @@ -1163,19 +1343,22 @@ void *load_template(StrBuf * Target, WCTemplate * NewTemplate) { fd = open(ChrPtr(NewTemplate->FileName), O_RDONLY); if (fd <= 0) { - syslog(LOG_WARNING, "ERROR: could not open template '%s' - %s\n", ChrPtr(NewTemplate->FileName), strerror(errno)); + syslog(LOG_WARNING, "ERROR: could not open template '%s' - %s\n", + ChrPtr(NewTemplate->FileName), strerror(errno)); return NULL; } if (fstat(fd, &statbuf) == -1) { - syslog(LOG_WARNING, "ERROR: could not stat template '%s' - %s\n", ChrPtr(NewTemplate->FileName), strerror(errno)); + syslog(LOG_WARNING, "ERROR: could not stat template '%s' - %s\n", + ChrPtr(NewTemplate->FileName), strerror(errno)); return NULL; } NewTemplate->Data = NewStrBufPlain(NULL, statbuf.st_size + 1); if (StrBufReadBLOB(NewTemplate->Data, &fd, 1, statbuf.st_size, &Err) < 0) { close(fd); - syslog(LOG_WARNING, "ERROR: reading template '%s' - %s
\n", ChrPtr(NewTemplate->FileName), strerror(errno)); + syslog(LOG_WARNING, "ERROR: reading template '%s' - %s
\n", + ChrPtr(NewTemplate->FileName), strerror(errno)); return NULL; } close(fd); @@ -1191,30 +1374,39 @@ void *load_template(StrBuf * Target, WCTemplate * NewTemplate) { void *pv; /** Find one */ - for (; pch < pE; pch++) { - if ((*pch == '<') && (*(pch + 1) == '?') && !((pch == pS) && /* we must ommit a = pE) continue; pts = pch; /** Found one? parse it. */ - for (; pch <= pE - 1; pch++) { - if ((!InQuotes) && ((*pch == '\'') || (*pch == '"'))) { + for (; pch <= pE - 1; pch ++) { + if ((!InQuotes) && + ((*pch == '\'') || (*pch == '"'))) + { InQuotes = *pch; } - else if (InQuotes && (InQuotes == *pch)) { + else if (InQuotes && (InQuotes == *pch)) + { InQuotes = '\0'; } - else if ((InQuotes) && (*pch == '\\') && (*(pch + 1) == InQuotes)) { + else if ((InQuotes) && + (*pch == '\\') && + (*(pch + 1) == InQuotes)) + { pch++; } - else if ((!InQuotes) && (*pch == '>')) { + else if ((!InQuotes) && + (*pch == '>')) + { break; } } @@ -1224,7 +1416,7 @@ void *load_template(StrBuf * Target, WCTemplate * NewTemplate) { pv = NewTemplateSubstitute(NewTemplate->Data, pS, pts, pte, Line, NewTemplate); if (pv != NULL) { PutNewToken(NewTemplate, pv); - pch++; + pch ++; } } @@ -1233,14 +1425,16 @@ void *load_template(StrBuf * Target, WCTemplate * NewTemplate) { } -const char *PrintTemplate(void *vSubst) { +const char* PrintTemplate(void *vSubst) +{ WCTemplate *Tmpl = vSubst; return ChrPtr(Tmpl->FileName); } -int LoadTemplateDir(const StrBuf * DirName, HashList * big, const StrBuf * BaseKey) { +int LoadTemplateDir(const StrBuf *DirName, HashList *big, const StrBuf *BaseKey) +{ int Toplevel; StrBuf *FileName; StrBuf *Key; @@ -1252,13 +1446,13 @@ int LoadTemplateDir(const StrBuf * DirName, HashList * big, const StrBuf * BaseK int d_type = 0; int d_namelen; int d_without_ext; - - d = (struct dirent *) malloc(offsetof(struct dirent, d_name) + PATH_MAX + 1); + + d = (struct dirent *)malloc(offsetof(struct dirent, d_name) + PATH_MAX + 1); if (d == NULL) { return 0; } - filedir = opendir(ChrPtr(DirName)); + filedir = opendir (ChrPtr(DirName)); if (filedir == NULL) { free(d); return 0; @@ -1269,7 +1463,9 @@ int LoadTemplateDir(const StrBuf * DirName, HashList * big, const StrBuf * BaseK SubKey = NewStrBuf(); FileName = NewStrBufPlain(NULL, PATH_MAX); Key = NewStrBuf(); - while ((readdir_r(filedir, d, &filedir_entry) == 0) && (filedir_entry != NULL)) { + while ((readdir_r(filedir, d, &filedir_entry) == 0) && + (filedir_entry != NULL)) + { char *MinorPtr; #ifdef _DIRENT_HAVE_D_NAMLEN @@ -1296,23 +1492,28 @@ int LoadTemplateDir(const StrBuf * DirName, HashList * big, const StrBuf * BaseK d_without_ext = d_namelen; if ((d_namelen > 1) && filedir_entry->d_name[d_namelen - 1] == '~') - continue; /* Ignore backup files... */ + continue; /* Ignore backup files... */ - if ((d_namelen == 1) && (filedir_entry->d_name[0] == '.')) + if ((d_namelen == 1) && + (filedir_entry->d_name[0] == '.')) continue; - if ((d_namelen == 2) && (filedir_entry->d_name[0] == '.') && (filedir_entry->d_name[1] == '.')) + 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); + snprintf(path, PATH_MAX, "%s/%s", + ChrPtr(DirName), filedir_entry->d_name); if (lstat(path, &s) == 0) { d_type = IFTODT(s.st_mode); } } - switch (d_type) { + switch (d_type) + { case DT_DIR: /* Skip directories we are not interested in... */ if (strcmp(filedir_entry->d_name, ".svn") == 0) @@ -1320,7 +1521,7 @@ int LoadTemplateDir(const StrBuf * DirName, HashList * big, const StrBuf * BaseK FlushStrBuf(SubKey); if (!Toplevel) { - /* If we're not toplevel, the upper dirs count as foo_bar_ */ + /* If we're not toplevel, the upper dirs count as foo_bar_*/ StrBufAppendBuf(SubKey, BaseKey, 0); StrBufAppendBufPlain(SubKey, HKEY("_"), 0); } @@ -1335,25 +1536,25 @@ int LoadTemplateDir(const StrBuf * DirName, HashList * big, const StrBuf * BaseK LoadTemplateDir(SubDirectory, big, SubKey); break; - case DT_LNK: + case DT_LNK: case DT_REG: while ((d_without_ext > 0) && (filedir_entry->d_name[d_without_ext] != '.')) - 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... */ - StrBufPrintf(FileName, "%s/%s", ChrPtr(DirName), filedir_entry->d_name); + continue; /* Ignore backup files... */ + 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_ */ + /* If we're not toplevel, the upper dirs count as foo_bar_*/ StrBufAppendBuf(Key, BaseKey, 0); StrBufAppendBufPlain(Key, HKEY("_"), 0); } @@ -1375,7 +1576,8 @@ int LoadTemplateDir(const StrBuf * DirName, HashList * big, const StrBuf * BaseK return 1; } -void InitTemplateCache(void) { +void InitTemplateCache(void) +{ int i; StrBuf *Key; StrBuf *Dir; @@ -1391,17 +1593,17 @@ void InitTemplateCache(void) { /* User local Template set */ StrBufPrintf(Dir, "%s/t", static_dirs[1]); LoadTemplateDir(Dir, LocalTemplateCache, Key); - + /* Debug Templates, just to be loaded while debugging. */ - + StrBufPrintf(Dir, "%s/dbg", static_dirs[0]); LoadTemplateDir(Dir, TemplateCache, Key); Templates[0] = TemplateCache; Templates[1] = LocalTemplateCache; - if (LoadTemplates == 0) - for (i = 0; i < 2; i++) { + if (LoadTemplates == 0) + for (i=0; i < 2; i++) { const char *Key; long KLen; HashPos *At; @@ -1409,7 +1611,7 @@ void InitTemplateCache(void) { At = GetNewHashPos(Templates[i], 0); while (GetNextHashPos(Templates[i], At, &KLen, &Key, &vTemplate) && (vTemplate != NULL)) { - load_template(NULL, (WCTemplate *) vTemplate); + load_template(NULL, (WCTemplate *)vTemplate); } DeleteHashPos(&At); } @@ -1424,7 +1626,6 @@ void InitTemplateCache(void) { /*----------------------------------------------------------------------------- * Filling & processing Templates */ - /** * \brief executes one token * \param Target buffer to append to @@ -1434,13 +1635,14 @@ void InitTemplateCache(void) { * \param state are we in conditional state? * \param ContextType what type of information does context giv us? */ -int EvaluateToken(StrBuf * Target, int state, WCTemplputParams ** TPP) { +int EvaluateToken(StrBuf *Target, int state, WCTemplputParams **TPP) +{ const char *AppendMe; long AppendMeLen; HashHandler *Handler; void *vVar; WCTemplputParams *TP = *TPP; - + /* much output, since pName is not terminated... syslog(LOG_DEBUG,"Doing token: %s\n",Token->pName); */ @@ -1449,25 +1651,22 @@ int EvaluateToken(StrBuf * Target, int state, WCTemplputParams ** TPP) { case SV_GETTEXT: TmplGettext(Target, TP); break; - - case SV_CONDITIONAL:/** Forward conditional evaluation */ - Handler = (HashHandler *) TP->Tokens->PreEval; + case SV_CONDITIONAL: /** Forward conditional evaluation */ + Handler = (HashHandler*) TP->Tokens->PreEval; if (!CheckContext(Target, &Handler->Filter, TP, "Conditional")) { return 0; } return EvaluateConditional(Target, 1, state, TPP); break; - - case SV_NEG_CONDITIONAL:/** Reverse conditional evaluation */ - Handler = (HashHandler *) TP->Tokens->PreEval; + case SV_NEG_CONDITIONAL: /** Reverse conditional evaluation */ + Handler = (HashHandler*) TP->Tokens->PreEval; if (!CheckContext(Target, &Handler->Filter, TP, "Conditional")) { return 0; } return EvaluateConditional(Target, 0, state, TPP); break; - - case SV_CUST_STR_CONDITIONAL:/** Conditional put custom strings from params */ - Handler = (HashHandler *) TP->Tokens->PreEval; + case SV_CUST_STR_CONDITIONAL: /** Conditional put custom strings from params */ + Handler = (HashHandler*) TP->Tokens->PreEval; if (!CheckContext(Target, &Handler->Filter, TP, "Conditional")) { return 0; } @@ -1476,16 +1675,17 @@ int EvaluateToken(StrBuf * Target, int state, WCTemplputParams ** TPP) { GetTemplateTokenString(Target, TP, 5, &AppendMe, &AppendMeLen); StrBufAppendBufPlain(Target, AppendMe, AppendMeLen, 0); } - else { + else{ GetTemplateTokenString(Target, TP, 4, &AppendMe, &AppendMeLen); StrBufAppendBufPlain(Target, AppendMe, AppendMeLen, 0); } - if (*TPP != TP) { + if (*TPP != TP) + { UnStackDynamicContext(Target, TPP); } } - else { - LogTemplateError(Target, "Conditional", ERR_NAME, TP, "needs at least 6 Params!"); + else { + LogTemplateError( Target, "Conditional", ERR_NAME, TP, "needs at least 6 Params!"); } break; case SV_SUBTEMPL: @@ -1493,15 +1693,15 @@ int EvaluateToken(StrBuf * Target, int state, WCTemplputParams ** TPP) { DoTemplate(TKEY(0), Target, TP); break; case SV_PREEVALUATED: - Handler = (HashHandler *) TP->Tokens->PreEval; + Handler = (HashHandler*) TP->Tokens->PreEval; if (!CheckContext(Target, &Handler->Filter, TP, "Token")) { return 0; } Handler->HandlerFunc(Target, TP); - break; + break; default: if (GetHash(GlobalNS, TP->Tokens->pName, TP->Tokens->NameEnd, &vVar)) { - Handler = (HashHandler *) vVar; + Handler = (HashHandler*) vVar; if (!CheckContext(Target, &Handler->Filter, TP, "Token")) { return 0; } @@ -1510,8 +1710,9 @@ int EvaluateToken(StrBuf * Target, int state, WCTemplputParams ** TPP) { } } else { - LogTemplateError(Target, "Token UNKNOWN", ERR_NAME, TP, - "You've specified a token that isn't known to webcit.!"); + LogTemplateError( + Target, "Token UNKNOWN", ERR_NAME, TP, + "You've specified a token that isn't known to webcit.!"); } } return 0; @@ -1519,7 +1720,8 @@ int EvaluateToken(StrBuf * Target, int state, WCTemplputParams ** TPP) { -const StrBuf *ProcessTemplate(WCTemplate * Tmpl, StrBuf * Target, WCTemplputParams * CallingTP) { +const StrBuf *ProcessTemplate(WCTemplate *Tmpl, StrBuf *Target, WCTemplputParams *CallingTP) +{ WCTemplate *pTmpl = Tmpl; int done = 0; int i; @@ -1537,14 +1739,15 @@ const StrBuf *ProcessTemplate(WCTemplate * Tmpl, StrBuf * Target, WCTemplputPara TP.Sub = CallingTP->Sub; TP.Super = CallingTP->Super; - if (LoadTemplates != 0) { + if (LoadTemplates != 0) { if (LoadTemplates > 1) - syslog(LOG_DEBUG, "DBG: ----- loading: [%s] ------ \n", ChrPtr(Tmpl->FileName)); + syslog(LOG_DEBUG, "DBG: ----- loading: [%s] ------ \n", + ChrPtr(Tmpl->FileName)); pTmpl = duplicate_template(Tmpl); - if (load_template(Target, pTmpl) == NULL) { - StrBufAppendPrintf(Target, - "
\nError loading Template [%s]\n See Logfile for details\n
\n", - ChrPtr(Tmpl->FileName)); + if(load_template(Target, pTmpl) == NULL) { + StrBufAppendPrintf( Target, + "
\nError loading Template [%s]\n See Logfile for details\n
\n", + ChrPtr(Tmpl->FileName)); FreeWCTemplate(pTmpl); return NULL; } @@ -1563,11 +1766,11 @@ const StrBuf *ProcessTemplate(WCTemplate * Tmpl, StrBuf * Target, WCTemplputPara else { int TokenRc = 0; - StrBufAppendBufPlain(Target, pData, pTmpl->Tokens[i]->pTokenStart - pData, 0); + StrBufAppendBufPlain( Target, pData, pTmpl->Tokens[i]->pTokenStart - pData, 0); TPtr->Tokens = pTmpl->Tokens[i]; TPtr->nArgs = pTmpl->Tokens[i]->nParameters; - TokenRc = EvaluateToken(Target, TokenRc, &TPtr); + TokenRc = EvaluateToken(Target, TokenRc, &TPtr); if (TokenRc > 0) { state = eSkipTilEnd; } @@ -1578,18 +1781,24 @@ const StrBuf *ProcessTemplate(WCTemplate * Tmpl, StrBuf * Target, WCTemplputPara TokenRc = 0; } - while ((state != eNext) && (i + 1 < pTmpl->nTokensUsed)) { - /* condition told us to skip till its end condition */ + while ((state != eNext) && (i+1 < pTmpl->nTokensUsed)) { + /* condition told us to skip till its end condition */ i++; TPtr->Tokens = pTmpl->Tokens[i]; TPtr->nArgs = pTmpl->Tokens[i]->nParameters; - if ((pTmpl->Tokens[i]->Flags == SV_CONDITIONAL) || (pTmpl->Tokens[i]->Flags == SV_NEG_CONDITIONAL)) { + if ((pTmpl->Tokens[i]->Flags == SV_CONDITIONAL) || + (pTmpl->Tokens[i]->Flags == SV_NEG_CONDITIONAL)) + { int rc; - rc = EvaluateConditional(Target, pTmpl->Tokens[i]->Flags, TokenRc, &TPtr); + rc = EvaluateConditional( + Target, + pTmpl->Tokens[i]->Flags, + TokenRc, + &TPtr); if (-rc == TokenRc) { TokenRc = 0; state = eNext; - if ((TPtr != &TP) && (TPtr->ExitCTXID == -rc)) { + if ((TPtr != &TP) && (TPtr->ExitCTXID == - rc)) { UnStackDynamicContext(Target, &TPtr); } } @@ -1610,18 +1819,18 @@ const StrBuf *ProcessTemplate(WCTemplate * Tmpl, StrBuf * Target, WCTemplputPara StrBuf *textPlainType; - /** * \brief Display a variable-substituted template * \param templatename template file to load * \returns the mimetype of the template its doing */ -const StrBuf *DoTemplate(const char *templatename, long len, StrBuf * Target, WCTemplputParams * TP) { +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 (TP == NULL) { @@ -1638,13 +1847,15 @@ const StrBuf *DoTemplate(const char *templatename, long len, StrBuf * Target, WC return textPlainType; } - if (!GetHash(StaticLocal, templatename, len, &vTmpl) && !GetHash(Static, templatename, len, &vTmpl)) { + if (!GetHash(StaticLocal, templatename, len, &vTmpl) && + !GetHash(Static, templatename, len, &vTmpl)) { StrBuf *escapedString = NewStrBufPlain(NULL, len); - + StrHtmlEcmaEscAppend(escapedString, NULL, templatename, 1, 1); - syslog(LOG_WARNING, "didn't find Template [%s] %ld %ld\n", ChrPtr(escapedString), len, (long) strlen(templatename)); - StrBufAppendPrintf(Target, "
\ndidn't find Template [%s] %ld %ld\n
", - ChrPtr(escapedString), len, (long) strlen(templatename)); + syslog(LOG_WARNING, "didn't find Template [%s] %ld %ld\n", ChrPtr(escapedString), len , (long)strlen(templatename)); + StrBufAppendPrintf(Target, "
\ndidn't find Template [%s] %ld %ld\n
", + ChrPtr(escapedString), len, + (long)strlen(templatename)); WC->isFailure = 1; #if 0 dbg_PrintHash(Static, PrintTemplate, NULL); @@ -1653,15 +1864,17 @@ const StrBuf *DoTemplate(const char *templatename, long len, StrBuf * Target, WC FreeStrBuf(&escapedString); return textPlainType; } - if (vTmpl == NULL) + if (vTmpl == NULL) return textPlainType; return ProcessTemplate(vTmpl, Target, TP); } -void tmplput_Comment(StrBuf * Target, WCTemplputParams * TP) { - if (LoadTemplates != 0) { +void tmplput_Comment(StrBuf *Target, WCTemplputParams *TP) +{ + if (LoadTemplates != 0) + { StrBuf *Comment; const char *pch; long len; @@ -1690,16 +1903,20 @@ typedef struct _HashIterator { FilterByParamFunc Filter; } HashIterator; -void RegisterITERATOR(const char *Name, long len, - int AdditionalParams, - HashList * StaticList, - RetrieveHashlistFunc GetHash, +void RegisterITERATOR(const char *Name, long len, + int AdditionalParams, + HashList *StaticList, + RetrieveHashlistFunc GetHash, SubTemplFunc DoSubTempl, HashDestructorFunc Destructor, - FilterByParamFunc Filter, CtxType ContextType, CtxType XPectContextType, int Flags) { + FilterByParamFunc Filter, + CtxType ContextType, + CtxType XPectContextType, + int Flags) +{ HashIterator *It; - It = (HashIterator *) malloc(sizeof(HashIterator)); + It = (HashIterator*)malloc(sizeof(HashIterator)); memset(It, 0, sizeof(HashIterator)); It->StaticList = StaticList; It->AdditionalParams = AdditionalParams; @@ -1720,9 +1937,10 @@ typedef struct _iteratestruct { long KeyLen; int n; int LastN; -} IterateStruct; + }IterateStruct; -int preeval_iterate(WCTemplateToken * Token) { +int preeval_iterate(WCTemplateToken *Token) +{ WCTemplputParams TPP; WCTemplputParams *TP; void *vTmpl; @@ -1733,33 +1951,42 @@ int preeval_iterate(WCTemplateToken * Token) { TP = &TPP; TP->Tokens = Token; if (!GetHash(Iterators, TKEY(0), &vIt)) { - LogTemplateError(NULL, "Iterator", ERR_PARM1, TP, "not found"); + 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); + "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"); + 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); + 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) { +void tmpl_iterate_subtmpl(StrBuf *Target, WCTemplputParams *TP) +{ HashIterator *It; HashList *List; - HashPos *it; + HashPos *it; SortStruct *SortBy = NULL; void *vSortBy; int DetectGroupChange = 0; @@ -1776,24 +2003,31 @@ void tmpl_iterate_subtmpl(StrBuf * Target, WCTemplputParams * TP) { long StopAt = -1; memset(&Status, 0, sizeof(IterateStruct)); - - It = (HashIterator *) TP->Tokens->Preeval2; + + It = (HashIterator*) TP->Tokens->Preeval2; if (It == NULL) { - LogTemplateError(Target, "Iterator", ERR_PARM1, TP, "Unknown!"); + LogTemplateError( + Target, "Iterator", ERR_PARM1, TP, "Unknown!"); return; } if (TP->Tokens->nParameters < It->AdditionalParams + 2) { - LogTemplateError(Target, "Iterator", ERR_PARM1, TP, "doesn't work with %d params", TP->Tokens->nParameters - 1); + LogTemplateError( + Target, "Iterator", ERR_PARM1, TP, + "doesn't work with %d params", + TP->Tokens->nParameters - 1); return; } - if ((It->XPectContextType != CTX_NONE) && (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->XPectContextType != CTX_NONE) && + (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) @@ -1807,11 +2041,11 @@ void tmpl_iterate_subtmpl(StrBuf * Target, WCTemplputParams * TP) { DetectGroupChange = 0; if (havebstr("SortBy")) { BSort = sbstr("SortBy"); - if (GetHash(SortHash, SKEY(BSort), &vSortBy) && (vSortBy != NULL)) { - SortBy = (SortStruct *) vSortBy; + if (GetHash(SortHash, SKEY(BSort), &vSortBy) && + (vSortBy != NULL)) { + SortBy = (SortStruct*)vSortBy; /* first check whether its intended for us... */ - if ((SortBy->ContextType == It->ContextType) && - + if ((SortBy->ContextType == It->ContextType)&& /** Ok, its us, lets see in which direction we should sort... */ (havebstr("SortOrder"))) { int SortOrder; @@ -1824,10 +2058,10 @@ void tmpl_iterate_subtmpl(StrBuf * Target, WCTemplputParams * TP) { } nMembersUsed = GetCount(List); - StackContext(TP, &IterateTP, &Status, CTX_ITERATE, 0, TP->Tokens); + StackContext (TP, &IterateTP, &Status, CTX_ITERATE, 0, TP->Tokens); { SubBuf = NewStrBuf(); - + if (HAVE_PARAM(2)) { StartAt = GetTemplateTokenNumber(Target, TP, 2, 0); } @@ -1844,7 +2078,9 @@ void tmpl_iterate_subtmpl(StrBuf * Target, WCTemplputParams * TP) { while (GetNextHashPos(List, it, &Status.KeyLen, &Status.Key, &vContext)) { if ((Status.n >= StartAt) && (Status.n <= StopAt)) { - if ((It->Filter != NULL) && !It->Filter(Status.Key, Status.KeyLen, vContext, Target, TP)) { + if ((It->Filter != NULL) && + !It->Filter(Status.Key, Status.KeyLen, vContext, Target, TP)) + { continue; } @@ -1862,7 +2098,7 @@ void tmpl_iterate_subtmpl(StrBuf * Target, WCTemplputParams * TP) { FlushStrBuf(SubBuf); } UnStackContext(&SubTP); - Status.oddeven = !Status.oddeven; + Status.oddeven = ! Status.oddeven; vLastContext = vContext; } Status.n++; @@ -1876,15 +2112,17 @@ void tmpl_iterate_subtmpl(StrBuf * Target, WCTemplputParams * TP) { } -int conditional_ITERATE_ISGROUPCHANGE(StrBuf * Target, WCTemplputParams * TP) { +int conditional_ITERATE_ISGROUPCHANGE(StrBuf *Target, WCTemplputParams *TP) +{ IterateStruct *Ctx = CTX(CTX_ITERATE); if (TP->Tokens->nParameters < 3) - return Ctx->GroupChange; + return Ctx->GroupChange; return TP->Tokens->Params[2]->lvalue == Ctx->GroupChange; } -void tmplput_ITERATE_ODDEVEN(StrBuf * Target, WCTemplputParams * TP) { +void tmplput_ITERATE_ODDEVEN(StrBuf *Target, WCTemplputParams *TP) +{ IterateStruct *Ctx = CTX(CTX_ITERATE); if (Ctx->oddeven) StrBufAppendBufPlain(Target, HKEY("odd"), 0); @@ -1893,13 +2131,15 @@ void tmplput_ITERATE_ODDEVEN(StrBuf * Target, WCTemplputParams * TP) { } -void tmplput_ITERATE_KEY(StrBuf * Target, WCTemplputParams * TP) { +void tmplput_ITERATE_KEY(StrBuf *Target, WCTemplputParams *TP) +{ IterateStruct *Ctx = CTX(CTX_ITERATE); StrBufAppendBufPlain(Target, Ctx->Key, Ctx->KeyLen, 0); } -void tmplput_ITERATE_N_DIV(StrBuf * Target, WCTemplputParams * TP) { +void tmplput_ITERATE_N_DIV(StrBuf *Target, WCTemplputParams *TP) +{ IterateStruct *Ctx = CTX(CTX_ITERATE); long div; long divisor = GetTemplateTokenNumber(Target, TP, 0, 1); @@ -1908,27 +2148,31 @@ void tmplput_ITERATE_N_DIV(StrBuf * Target, WCTemplputParams * TP) { StrBufAppendPrintf(Target, "%ld", div); } -void tmplput_ITERATE_N(StrBuf * Target, WCTemplputParams * TP) { +void tmplput_ITERATE_N(StrBuf *Target, WCTemplputParams *TP) +{ IterateStruct *Ctx = CTX(CTX_ITERATE); StrBufAppendPrintf(Target, "%d", Ctx->n); } -int conditional_ITERATE_FIRSTN(StrBuf * Target, WCTemplputParams * TP) { +int conditional_ITERATE_FIRSTN(StrBuf *Target, WCTemplputParams *TP) +{ IterateStruct *Ctx = CTX(CTX_ITERATE); return Ctx->n == 0; } -int conditional_ITERATE_LASTN(StrBuf * Target, WCTemplputParams * TP) { +int conditional_ITERATE_LASTN(StrBuf *Target, WCTemplputParams *TP) +{ IterateStruct *Ctx = CTX(CTX_ITERATE); return Ctx->LastN; } -int conditional_ITERATE_ISMOD(StrBuf * Target, WCTemplputParams * TP) { +int conditional_ITERATE_ISMOD(StrBuf *Target, WCTemplputParams *TP) +{ IterateStruct *Ctx = CTX(CTX_ITERATE); long divisor = GetTemplateTokenNumber(Target, TP, 2, 1); long expectRemainder = GetTemplateTokenNumber(Target, TP, 3, 0); - + return Ctx->n % divisor == expectRemainder; } @@ -1937,19 +2181,24 @@ int conditional_ITERATE_ISMOD(StrBuf * Target, WCTemplputParams * TP) { /*----------------------------------------------------------------------------- * Conditionals */ -int EvaluateConditional(StrBuf * Target, int Neg, int state, WCTemplputParams ** TPP) { +int EvaluateConditional(StrBuf *Target, int Neg, int state, WCTemplputParams **TPP) +{ ConditionalStruct *Cond; int rc = 0; int res; WCTemplputParams *TP = *TPP; - if ((TP->Tokens->Params[0]->len == 1) && (TP->Tokens->Params[0]->Start[0] == 'X')) { - return -(TP->Tokens->Params[1]->lvalue); + if ((TP->Tokens->Params[0]->len == 1) && + (TP->Tokens->Params[0]->Start[0] == 'X')) + { + return - (TP->Tokens->Params[1]->lvalue); } - + Cond = (ConditionalStruct *) TP->Tokens->PreEval; if (Cond == NULL) { - LogTemplateError(Target, "Conditional", ERR_PARM1, TP, "unknown!"); + LogTemplateError( + Target, "Conditional", ERR_PARM1, TP, + "unknown!"); return 0; } @@ -1961,20 +2210,27 @@ int EvaluateConditional(StrBuf * Target, int Neg, int state, WCTemplputParams ** if (res == Neg) rc = TP->Tokens->Params[1]->lvalue; - if (LoadTemplates > 5) - syslog(LOG_DEBUG, "<%s> : %d %d==%d\n", ChrPtr(TP->Tokens->FlatToken), rc, res, Neg); + if (LoadTemplates > 5) + syslog(LOG_DEBUG, "<%s> : %d %d==%d\n", + ChrPtr(TP->Tokens->FlatToken), + rc, res, Neg); - if (TP->Sub != NULL) { + if (TP->Sub != NULL) + { *TPP = TP->Sub; } return rc; } -void RegisterContextConditional(const char *Name, long len, - int nParams, WCConditionalFunc CondF, WCConditionalFunc ExitCtxCond, int ContextRequired) { +void RegisterContextConditional(const char *Name, long len, + int nParams, + WCConditionalFunc CondF, + WCConditionalFunc ExitCtxCond, + int ContextRequired) +{ ConditionalStruct *Cond; - Cond = (ConditionalStruct *) malloc(sizeof(ConditionalStruct)); + Cond = (ConditionalStruct*)malloc(sizeof(ConditionalStruct)); memset(Cond, 0, sizeof(ConditionalStruct)); Cond->PlainName = Name; Cond->Filter.nMaxArgs = nParams; @@ -1985,34 +2241,43 @@ void RegisterContextConditional(const char *Name, long len, Put(Conditionals, Name, len, Cond, NULL); } -void RegisterTokenParamDefine(const char *Name, long len, long Value) { +void RegisterTokenParamDefine(const char *Name, long len, + long Value) +{ long *PVal; - PVal = (long *) malloc(sizeof(long)); + PVal = (long*)malloc(sizeof(long)); *PVal = Value; Put(Defines, Name, len, PVal, NULL); } -long GetTokenDefine(const char *Name, long len, long DefValue) { +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; - } + if (GetHash(Defines, Name, len, &vPVal) && + (vPVal != NULL)) + { + return *(long*) vPVal; + } + else + { + return DefValue; + } } -void tmplput_DefStr(StrBuf * Target, WCTemplputParams * TP) { +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) { +void tmplput_DefVal(StrBuf *Target, WCTemplputParams *TP) +{ int val; val = GetTemplateTokenNumber(Target, TP, 0, 0); @@ -2024,11 +2289,13 @@ HashList *Defines; /*----------------------------------------------------------------------------- * Context Strings */ -void tmplput_ContextString(StrBuf * Target, WCTemplputParams * TP) { - StrBufAppendTemplate(Target, TP, (StrBuf *) CTX(CTX_STRBUF), 0); +void tmplput_ContextString(StrBuf *Target, WCTemplputParams *TP) +{ + StrBufAppendTemplate(Target, TP, (StrBuf*)CTX(CTX_STRBUF), 0); } -int ConditionalContextStr(StrBuf * Target, WCTemplputParams * TP) { - StrBuf *TokenText = (StrBuf *) CTX((CTX_STRBUF)); +int ConditionalContextStr(StrBuf *Target, WCTemplputParams *TP) +{ + StrBuf *TokenText = (StrBuf*) CTX((CTX_STRBUF)); const char *CompareToken; long len; @@ -2036,18 +2303,21 @@ int ConditionalContextStr(StrBuf * Target, WCTemplputParams * TP) { return strcmp(ChrPtr(TokenText), CompareToken) == 0; } -void tmplput_ContextStringArray(StrBuf * Target, WCTemplputParams * TP) { - HashList *Arr = (HashList *) CTX(CTX_STRBUFARR); +void tmplput_ContextStringArray(StrBuf *Target, WCTemplputParams *TP) +{ + HashList *Arr = (HashList*) CTX(CTX_STRBUFARR); void *pV; int val; val = GetTemplateTokenNumber(Target, TP, 0, 0); - if (GetHash(Arr, IKEY(val), &pV) && (pV != NULL)) { - StrBufAppendTemplate(Target, TP, (StrBuf *) pV, 1); + if (GetHash(Arr, IKEY(val), &pV) && + (pV != NULL)) { + StrBufAppendTemplate(Target, TP, (StrBuf*)pV, 1); } } -int ConditionalContextStrinArray(StrBuf * Target, WCTemplputParams * TP) { - HashList *Arr = (HashList *) CTX(CTX_STRBUFARR); +int ConditionalContextStrinArray(StrBuf *Target, WCTemplputParams *TP) +{ + HashList *Arr = (HashList*) CTX(CTX_STRBUFARR); void *pV; int val; const char *CompareToken; @@ -2055,8 +2325,9 @@ int ConditionalContextStrinArray(StrBuf * Target, WCTemplputParams * TP) { 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; + if (GetHash(Arr, IKEY(val), &pV) && + (pV != NULL)) { + return strcmp(ChrPtr((StrBuf*)pV), CompareToken) == 0; } else return 0; @@ -2066,7 +2337,8 @@ int ConditionalContextStrinArray(StrBuf * Target, WCTemplputParams * TP) { * Boxed-API */ -void tmpl_do_boxed(StrBuf * Target, WCTemplputParams * TP) { +void tmpl_do_boxed(StrBuf *Target, WCTemplputParams *TP) +{ WCTemplputParams SubTP; StrBuf *Headline = NULL; @@ -2078,13 +2350,17 @@ void tmpl_do_boxed(StrBuf * Target, WCTemplputParams * TP) { else { const char *Ch; long len; - GetTemplateTokenString(Target, TP, 1, &Ch, &len); + GetTemplateTokenString(Target, + TP, + 1, + &Ch, + &len); Headline = NewStrBufPlain(Ch, len); } } /* else TODO error? logging? */ - StackContext(TP, &SubTP, Headline, CTX_STRBUF, 0, NULL); + StackContext (TP, &SubTP, Headline, CTX_STRBUF, 0, NULL); { DoTemplate(HKEY("box_begin"), Target, &SubTP); } @@ -2103,7 +2379,8 @@ typedef struct _tab_struct { StrBuf *TabTitle; } tab_struct; -int preeval_do_tabbed(WCTemplateToken * Token) { +int preeval_do_tabbed(WCTemplateToken *Token) +{ WCTemplputParams TPP; WCTemplputParams *TP; const char *Ch; @@ -2114,30 +2391,49 @@ int preeval_do_tabbed(WCTemplateToken * Token) { 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"); + 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; - } + 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)) { + 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", + "Tab-Content %d needs to be able to produce a string, have %s", i, TP->Tokens->Params[i * 2 + 1]->Start); return 0; } @@ -2145,7 +2441,8 @@ int preeval_do_tabbed(WCTemplateToken * Token) { } -void tmpl_do_tabbed(StrBuf * Target, WCTemplputParams * TP) { +void tmpl_do_tabbed(StrBuf *Target, WCTemplputParams *TP) +{ StrBuf **TabNames; int i, ntabs, nTabs; tab_struct TS; @@ -2154,27 +2451,31 @@ void tmpl_do_tabbed(StrBuf * Target, WCTemplputParams * TP) { memset(&TS, 0, sizeof(tab_struct)); nTabs = ntabs = TP->Tokens->nParameters / 2; - TabNames = (StrBuf **) malloc(ntabs * sizeof(StrBuf *)); - memset(TabNames, 0, ntabs * sizeof(StrBuf *)); + TabNames = (StrBuf **) malloc(ntabs * sizeof(StrBuf*)); + memset(TabNames, 0, 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)) { + 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); + GetTemplateTokenString(Target, + TP, + i * 2, + &Ch, + &len); TabNames[i] = NewStrBufPlain(Ch, -1); } - else { - + else { /** A Tab without subject? we can't count that, add it as silent */ - nTabs--; + nTabs --; } } - StackContext(TP, &SubTP, &TS, CTX_TAB, 0, NULL); + StackContext (TP, &SubTP, &TS, CTX_TAB, 0, NULL); { StrTabbedDialog(Target, nTabs, TabNames); for (i = 0; i < ntabs; i++) { @@ -2185,20 +2486,22 @@ void tmpl_do_tabbed(StrBuf * Target, WCTemplputParams * TP) { DoTemplate(TKEY(i * 2 + 1), Target, &SubTP); StrEndTab(Target, i, nTabs); } - for (i = 0; i < ntabs; i++) + for (i = 0; i < ntabs; i++) FreeStrBuf(&TabNames[i]); free(TabNames); } UnStackContext(&SubTP); } -void tmplput_TAB_N(StrBuf * Target, WCTemplputParams * TP) { +void tmplput_TAB_N(StrBuf *Target, WCTemplputParams *TP) +{ tab_struct *Ctx = CTX(CTX_TAB); StrBufAppendPrintf(Target, "%d", Ctx->CurrentTab); } -void tmplput_TAB_TITLE(StrBuf * Target, WCTemplputParams * TP) { +void tmplput_TAB_TITLE(StrBuf *Target, WCTemplputParams *TP) +{ tab_struct *Ctx = CTX(CTX_TAB); StrBufAppendTemplate(Target, TP, Ctx->TabTitle, 0); } @@ -2208,12 +2511,16 @@ void tmplput_TAB_TITLE(StrBuf * Target, WCTemplputParams * TP) { */ -void RegisterSortFunc(const char *name, long len, +void RegisterSortFunc(const char *name, long len, const char *prepend, long preplen, - CompareFunc Forward, CompareFunc Reverse, CompareFunc GroupChange, CtxType ContextType) { + CompareFunc Forward, + CompareFunc Reverse, + CompareFunc GroupChange, + CtxType ContextType) +{ SortStruct *NewSort; - NewSort = (SortStruct *) malloc(sizeof(SortStruct)); + NewSort = (SortStruct*) malloc(sizeof(SortStruct)); memset(NewSort, 0, sizeof(SortStruct)); NewSort->Name = NewStrBufPlain(name, len); if (prepend != NULL) @@ -2228,17 +2535,19 @@ void RegisterSortFunc(const char *name, long len, syslog(LOG_WARNING, "sorting requires a context. CTX_NONE won't make it.\n"); exit(1); } - + Put(SortHash, name, len, NewSort, DestroySortStruct); } -CompareFunc RetrieveSort(WCTemplputParams * TP, - const char *OtherPrefix, long OtherPrefixLen, const char *Default, long ldefault, long DefaultDirection) { +CompareFunc RetrieveSort(WCTemplputParams *TP, + const char *OtherPrefix, long OtherPrefixLen, + const char *Default, long ldefault, long DefaultDirection) +{ const StrBuf *BSort = NULL; SortStruct *SortBy; void *vSortBy; long SortOrder = -1; - + if (havebstr("SortBy")) { BSort = sbstr("SortBy"); if (OtherPrefix == NULL) { @@ -2248,7 +2557,6 @@ CompareFunc RetrieveSort(WCTemplputParams * TP, 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"); @@ -2266,13 +2574,17 @@ CompareFunc RetrieveSort(WCTemplputParams * TP, } } - if (!GetHash(SortHash, SKEY(BSort), &vSortBy) || (vSortBy == NULL)) { - if (!GetHash(SortHash, Default, ldefault, &vSortBy) || (vSortBy == NULL)) { - LogTemplateError(NULL, "Sorting", ERR_PARM1, TP, "Illegal default sort: [%s]", Default); + if (!GetHash(SortHash, SKEY(BSort), &vSortBy) || + (vSortBy == NULL)) { + if (!GetHash(SortHash, Default, ldefault, &vSortBy) || + (vSortBy == NULL)) { + LogTemplateError( + NULL, "Sorting", ERR_PARM1, TP, + "Illegal default sort: [%s]", Default); wc_backtrace(LOG_WARNING); } } - SortBy = (SortStruct *) vSortBy; + SortBy = (SortStruct*)vSortBy; if (SortBy->ContextType != TP->Filter.ContextType) return NULL; @@ -2281,7 +2593,6 @@ CompareFunc RetrieveSort(WCTemplputParams * TP, if (havebstr("SortOrder")) { SortOrder = lbstr("SortOrder"); } - else { /** Try to fallback to our remembered values... */ StrBuf *Buf = NULL; if (SortBy->PrefPrepend == NULL) { @@ -2312,36 +2623,38 @@ CompareFunc RetrieveSort(WCTemplputParams * TP, enum { - eNO_SUCH_SORT, + eNO_SUCH_SORT, eNOT_SPECIFIED, eINVALID_PARAM, eFOUND }; ConstStr SortIcons[] = { - { HKEY("static/webcit_icons/sort_none.gif") }, - { HKEY("static/webcit_icons/up_pointer.gif") }, - { HKEY("static/webcit_icons/down_pointer.gif") }, + {HKEY("static/webcit_icons/sort_none.gif")}, + {HKEY("static/webcit_icons/up_pointer.gif")}, + {HKEY("static/webcit_icons/down_pointer.gif")}, }; ConstStr SortNextOrder[] = { - { HKEY("1") }, - { HKEY("2") }, - { HKEY("0") }, + {HKEY("1")}, + {HKEY("2")}, + {HKEY("0")}, }; -int GetSortMetric(WCTemplputParams * TP, SortStruct ** Next, SortStruct ** Param, long *SortOrder, int N) { +int GetSortMetric(WCTemplputParams *TP, SortStruct **Next, SortStruct **Param, long *SortOrder, int N) +{ int bSortError = eNOT_SPECIFIED; const StrBuf *BSort; void *vSort; - + *SortOrder = 0; *Next = NULL; - if (!GetHash(SortHash, TKEY(0), &vSort) || (vSort == NULL)) + if (!GetHash(SortHash, TKEY(0), &vSort) || + (vSort == NULL)) return eNO_SUCH_SORT; - *Param = (SortStruct *) vSort; - + *Param = (SortStruct*) vSort; + if (havebstr("SortBy")) { BSort = sbstr("SortBy"); @@ -2353,7 +2666,6 @@ int GetSortMetric(WCTemplputParams * TP, SortStruct ** Next, SortStruct ** Param 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"); @@ -2363,16 +2675,16 @@ int GetSortMetric(WCTemplputParams * TP, SortStruct ** Next, SortStruct ** Param } } - if (!GetHash(SortHash, SKEY(BSort), &vSort) || (vSort == NULL)) + if (!GetHash(SortHash, SKEY(BSort), &vSort) || + (vSort == NULL)) return bSortError; - *Next = (SortStruct *) vSort; + *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")); @@ -2388,24 +2700,29 @@ int GetSortMetric(WCTemplputParams * TP, SortStruct ** Next, SortStruct ** Param } -void tmplput_SORT_ICON(StrBuf * Target, WCTemplputParams * TP) { +void tmplput_SORT_ICON(StrBuf *Target, WCTemplputParams *TP) +{ long SortOrder; SortStruct *Next; SortStruct *Param; const ConstStr *SortIcon; - switch (GetSortMetric(TP, &Next, &Param, &SortOrder, 2)) { + switch (GetSortMetric(TP, &Next, &Param, &SortOrder, 2)){ case eNO_SUCH_SORT: - LogTemplateError(Target, "Sorter", ERR_PARM1, TP, " Sorter [%s] unknown!", TP->Tokens->Params[0]->Start); - break; + 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")); + 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]; } @@ -2413,42 +2730,55 @@ void tmplput_SORT_ICON(StrBuf * Target, WCTemplputParams * TP) { } } -void tmplput_SORT_NEXT(StrBuf * Target, WCTemplputParams * TP) { +void tmplput_SORT_NEXT(StrBuf *Target, WCTemplputParams *TP) +{ long SortOrder; SortStruct *Next; SortStruct *Param; - switch (GetSortMetric(TP, &Next, &Param, &SortOrder, 2)) { + switch (GetSortMetric(TP, &Next, &Param, &SortOrder, 2)){ case eNO_SUCH_SORT: - LogTemplateError(Target, "Sorter", ERR_PARM1, TP, " Sorter [%s] unknown!", TP->Tokens->Params[0]->Start); - break; + 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")); + 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) { +void tmplput_SORT_ORDER(StrBuf *Target, WCTemplputParams *TP) +{ long SortOrder; const ConstStr *SortOrderStr; SortStruct *Next; SortStruct *Param; - switch (GetSortMetric(TP, &Next, &Param, &SortOrder, 2)) { + switch (GetSortMetric(TP, &Next, &Param, &SortOrder, 2)){ case eNO_SUCH_SORT: - LogTemplateError(Target, "Sorter", ERR_PARM1, TP, " Sorter [%s] unknown!", TP->Tokens->Params[0]->Start); - break; + 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")); + 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]; } @@ -2457,25 +2787,34 @@ void tmplput_SORT_ORDER(StrBuf * Target, WCTemplputParams * TP) { } -void tmplput_long_vector(StrBuf * Target, WCTemplputParams * TP) { - long *LongVector = (long *) CTX(CTX_LONGVECTOR); +void tmplput_long_vector(StrBuf *Target, WCTemplputParams *TP) +{ + long *LongVector = (long*) CTX(CTX_LONGVECTOR); - if ((TP->Tokens->Params[0]->Type == TYPE_LONG) && (TP->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[TP->Tokens->Params[0]->lvalue]); } - else { + else + { if (TP->Tokens->Params[0]->Type != TYPE_LONG) { - LogTemplateError(Target, "Longvector", ERR_NAME, TP, "needs a numerical Parameter!"); + 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]); + 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) { +void dbg_print_longvector(long *LongVector) +{ StrBuf *Buf = NewStrBufPlain(HKEY("Longvector: [")); int nItems = LongVector[0]; int i; @@ -2491,33 +2830,48 @@ void dbg_print_longvector(long *LongVector) { FreeStrBuf(&Buf); } -int ConditionalLongVector(StrBuf * Target, WCTemplputParams * TP) { - long *LongVector = (long *) CTX(CTX_LONGVECTOR); +int ConditionalLongVector(StrBuf *Target, WCTemplputParams *TP) +{ + long *LongVector = (long*) CTX(CTX_LONGVECTOR); - 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]; + 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 + { + 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]); + 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) { +void tmplput_CURRENT_FILE(StrBuf *Target, WCTemplputParams *TP) +{ StrBufAppendTemplate(Target, TP, TP->Tokens->FileName, 0); } -void InitModule_SUBST(void) { +void +InitModule_SUBST +(void) +{ RegisterCTX(CTX_TAB); RegisterCTX(CTX_ITERATE); @@ -2543,10 +2897,18 @@ void InitModule_SUBST(void) { RegisterConditional("COND:LONGVECTOR", 4, ConditionalLongVector, CTX_LONGVECTOR); - RegisterConditional("COND:ITERATE:ISGROUPCHANGE", 2, conditional_ITERATE_ISGROUPCHANGE, CTX_ITERATE); - RegisterConditional("COND:ITERATE:LASTN", 2, conditional_ITERATE_LASTN, CTX_ITERATE); - RegisterConditional("COND:ITERATE:FIRSTN", 2, conditional_ITERATE_FIRSTN, CTX_ITERATE); - RegisterConditional("COND:ITERATE:ISMOD", 3, conditional_ITERATE_ISMOD, CTX_ITERATE); + RegisterConditional("COND:ITERATE:ISGROUPCHANGE", 2, + conditional_ITERATE_ISGROUPCHANGE, + CTX_ITERATE); + RegisterConditional("COND:ITERATE:LASTN", 2, + conditional_ITERATE_LASTN, + CTX_ITERATE); + RegisterConditional("COND:ITERATE:FIRSTN", 2, + conditional_ITERATE_FIRSTN, + CTX_ITERATE); + RegisterConditional("COND:ITERATE:ISMOD", 3, + conditional_ITERATE_ISMOD, + CTX_ITERATE); RegisterNamespace("ITERATE:ODDEVEN", 0, 0, tmplput_ITERATE_ODDEVEN, NULL, CTX_ITERATE); RegisterNamespace("ITERATE:KEY", 0, 0, tmplput_ITERATE_KEY, NULL, CTX_ITERATE); @@ -2561,7 +2923,10 @@ void InitModule_SUBST(void) { } -void ServerStartModule_SUBST(void) { +void +ServerStartModule_SUBST +(void) +{ textPlainType = NewStrBufPlain(HKEY("text/plain")); LocalTemplateCache = NewHash(1, NULL); TemplateCache = NewHash(1, NULL); @@ -2571,7 +2936,7 @@ void ServerStartModule_SUBST(void) { SortHash = NewHash(1, NULL); Defines = NewHash(1, NULL); CtxList = NewHash(1, NULL); - + PutContextType(HKEY("CTX_NONE"), 0); RegisterCTX(CTX_STRBUF); @@ -2579,16 +2944,22 @@ void ServerStartModule_SUBST(void) { RegisterCTX(CTX_LONGVECTOR); } -void FinalizeModule_SUBST(void) { +void +FinalizeModule_SUBST +(void) +{ } -void ServerShutdownModule_SUBST(void) { +void +ServerShutdownModule_SUBST +(void) +{ FreeStrBuf(&textPlainType); DeleteHash(&TemplateCache); DeleteHash(&LocalTemplateCache); - + DeleteHash(&GlobalNS); DeleteHash(&Iterators); DeleteHash(&Conditionals); @@ -2598,17 +2969,29 @@ void ServerShutdownModule_SUBST(void) { } -void SessionNewModule_SUBST(wcsession * sess) { +void +SessionNewModule_SUBST +(wcsession *sess) +{ } -void SessionAttachModule_SUBST(wcsession * sess) { +void +SessionAttachModule_SUBST +(wcsession *sess) +{ } -void SessionDetachModule_SUBST(wcsession * sess) { +void +SessionDetachModule_SUBST +(wcsession *sess) +{ FreeStrBuf(&sess->WFBuf); } -void SessionDestroyModule_SUBST(wcsession * sess) { +void +SessionDestroyModule_SUBST +(wcsession *sess) +{ }