void *load_template(StrBuf *filename, StrBuf *Key, HashList *PutThere);
int EvaluateConditional(StrBuf *Target, WCTemplateToken *Tokens, WCTemplate *pTmpl, void *Context, int Neg, int state, int ContextType);
+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 RegisterNS(const char *NSName,
long len,
int nMinArgs,
/**
* \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);
wcsubst *NewSubstVar(const char *keyname, int keylen, int type)
{
wcsubst* ptr;
- struct wcsession *WCC = WC;
+ wcsession *WCC = WC;
ptr = (wcsubst *) malloc(sizeof(wcsubst));
memset(ptr, 0, sizeof(wcsubst));
void *vPtr;
wcsubst *ptr = NULL;
size_t keylen;
- struct wcsession *WCC = WC;
+ wcsession *WCC = WC;
keylen = strlen(keyname);
/**
va_list arg_ptr;
void *vPtr;
wcsubst *ptr = NULL;
- struct wcsession *WCC = WC;
+ wcsession *WCC = WC;
/**
* First look if we're doing a replacement of
{
void *vPtr;
wcsubst *ptr = NULL;
- struct wcsession *WCC = WC;
+ wcsession *WCC = WC;
/**
{
void *vPtr;
wcsubst *ptr = NULL;
- struct wcsession *WCC = WC;
+ wcsession *WCC = WC;
/**
{
wcsubst *ptr;
void *vPtr;
- struct wcsession *WCC = WC;
+ wcsession *WCC = WC;
/**
* First look if we're doing a replacement of
{
wcsubst *ptr;
void *vPtr;
- struct wcsession *WCC = WC;
+ wcsession *WCC = WC;
/**
* First look if we're doing a replacement of
*len = Tokens->Params[N]->len;
break;
case TYPE_BSTR:
- Buf = (StrBuf*) SBstr(Tokens->Params[N]->Start,
- Tokens->Params[N]->len);
+ Buf = (StrBuf*) SBstr(TKEY(N));
*Value = ChrPtr(Buf);
*len = StrLength(Buf);
break;
case TYPE_PREFSTR:
- get_PREFERENCE(
- Tokens->Params[N]->Start,
- Tokens->Params[N]->len,
- &Buf);
+ get_PREFERENCE(TKEY(N), &Buf);
*Value = ChrPtr(Buf);
*len = StrLength(Buf);
break;
case TYPE_LONG:
case TYPE_PREFINT:
- break; ///todo: string to text?
+ break; /* todo: string to text? */
case TYPE_GETTEXT:
*Value = _(Tokens->Params[N]->Start);
*len = strlen(*Value);
break;
default:
break;
-//todo log error
+/*/todo log error */
}
}
* \param keyname get a key to print
*/
void print_value_of(StrBuf *Target, WCTemplateToken *Tokens, void *Context, int ContextType) {
- struct wcsession *WCC = WC;
+ wcsession *WCC = WC;
wcsubst *ptr;
void *vVar;
/*if (WCC->vars != NULL) PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/
- /// TODO: debricated!
+ /* TODO: depricated! */
if (Tokens->pName[0] == '=') {
DoTemplate(Tokens->pName+1, Tokens->NameEnd - 1, NULL, NULL, 0);
}
-//////TODO: if param[1] == "U" -> urlescape
-/// X -> escputs
+/*/////TODO: if param[1] == "U" -> urlescape
+/// X -> escputs */
/** Page-local variables */
if ((WCC->vars!= NULL) && GetHash(WCC->vars, Tokens->pName, Tokens->NameEnd, &vVar)) {
ptr = (wcsubst*) vVar;
int CompareSubstToToken(TemplateParam *ParamToCompare, TemplateParam *ParamToLookup)
{
- struct wcsession *WCC = WC;
+ wcsession *WCC = WC;
wcsubst *ptr;
void *vVar;
int CompareSubstToStrBuf(StrBuf *Compare, TemplateParam *ParamToLookup)
{
- struct wcsession *WCC = WC;
+ wcsession *WCC = WC;
wcsubst *ptr;
void *vVar;
void *Context, int ContextType,
const StrBuf *Source, int FormatTypeIndex)
{
- struct wcsession *WCC;
+ wcsession *WCC;
StrBuf *Buf;
char EscapeAs = ' ';
case SV_CUST_STR_CONDITIONAL:
case SV_CONDITIONAL:
case SV_NEG_CONDITIONAL:
- if (NewToken->Params[1]->lvalue == 0) {
+ if (NewToken->nParameters <2) {
lprintf(1, "Conditional (in '%s' line %ld); "
- "Conditional ID mustn't be 0! [%s]\n",
+ "require at least 2 parameters, you gave %ld params [%s]\n",
ChrPtr(pTmpl->FileName),
NewToken->Line,
+ NewToken->nParameters,
ChrPtr(NewToken->FlatToken));
NewToken->Flags = 0;
break;
}
- if (NewToken->nParameters <2) {
+ if (NewToken->Params[1]->lvalue == 0) {
lprintf(1, "Conditional (in '%s' line %ld); "
- "require at least 2 parameters, you gave %ld params [%s]\n",
+ "Conditional ID mustn't be 0! [%s]\n",
ChrPtr(pTmpl->FileName),
NewToken->Line,
- NewToken->nParameters,
ChrPtr(NewToken->FlatToken));
NewToken->Flags = 0;
break;
}
if (!GetHash(Conditionals,
- NewToken->Params[0]->Start,
- NewToken->Params[0]->len,
+ NewToken->Params[0]->Start,
+ NewToken->Params[0]->len,
&vVar) ||
(vVar == NULL)) {
if ((NewToken->Params[0]->len == 1) &&
pts = pch;
/** Found one? parse it. */
- for (; pch < pE - 1; pch ++) {
+ for (; pch <= pE - 1; pch ++) {
if (*pch == '"')
InDoubleQuotes = ! InDoubleQuotes;
else if (*pch == '\'')
break;
}
}
- if (pch + 1 >= pE)
+ if (pch + 1 > pE)
continue;
pte = pch;
PutNewToken(NewTemplate,
}
-///void PrintTemplate(const char *Key, void *vSubst, int odd)
const char* PrintTemplate(void *vSubst)
{
WCTemplate *Tmpl = vSubst;
long AppendMeLen;
HashHandler *Handler;
void *vVar;
-// much output, since pName is not terminated...
-// lprintf(1,"Doing token: %s\n",Token->pName);
+/* much output, since pName is not terminated...
+ lprintf(1,"Doing token: %s\n",Token->pName);
+*/
switch (Tokens->Flags) {
case SV_GETTEXT:
break;
case SV_SUBTEMPL:
if (Tokens->nParameters == 1)
- DoTemplate(Tokens->Params[0]->Start, Tokens->Params[0]->len, NULL, NULL, ContextType);
+ DoTemplate(TKEY(0), NULL, NULL, ContextType);
break;
case SV_PREEVALUATED:
Handler = (HashHandler*) Tokens->PreEval;
StrBufAppendPrintf(Target, "<pre>\ndidn't find Template [%s] %ld %ld\n</pre>",
templatename, len,
(long)strlen(templatename));
-/// dbg_PrintHash(Static, PrintTemplate, NULL);
-// PrintHash(Static, VarPrintTransition, PrintTemplate);
+#if 0
+ dbg_PrintHash(Static, PrintTemplate, NULL);
+ PrintHash(Static, VarPrintTransition, PrintTemplate);
+#endif
return;
}
if (vTmpl == NULL)
int AdditionalParams;
int ContextType;
int XPectContextType;
+ int Flags;
RetrieveHashlistFunc GetHash;
HashDestructorFunc Destructor;
SubTemplFunc DoSubTemplate;
SubTemplFunc DoSubTempl,
HashDestructorFunc Destructor,
int ContextType,
- int XPectContextType)
+ int XPectContextType,
+ int Flags)
{
HashIterator *It = (HashIterator*)malloc(sizeof(HashIterator));
It->StaticList = StaticList;
It->Destructor = Destructor;
It->ContextType = ContextType;
It->XPectContextType = XPectContextType;
+ It->Flags = Flags;
Put(Iterators, Name, len, It, NULL);
}
HashIterator *It;
HashList *List;
HashPos *it;
+ SortStruct *SortBy;
+ void *vSortBy;
+ int DetectGroupChange = 0;
int nMembersUsed;
int nMembersCounted = 0;
long len;
const char *Key;
void *vContext;
+ void *vLastContext;
StrBuf *SubBuf;
int oddeven = 0;
- if (!GetHash(Iterators,
- Tokens->Params[0]->Start,
- Tokens->Params[0]->len,
- &vIt)) {
+ if (!GetHash(Iterators, TKEY(0), &vIt)) {
lprintf(1, "unknown Iterator [%s] (in '%s' line %ld); "
" [%s]\n",
Tokens->Params[0]->Start,
else
List = It->StaticList;
+ DetectGroupChange = (It->Flags & IT_FLAG_DETECT_GROUPCHANGE) != 0;
+ if (DetectGroupChange) {
+ const StrBuf *BSort;
+ DetectGroupChange = 0;
+ if (havebstr("SortBy")) {
+ BSort = sbstr("SortBy");
+ if (GetHash(SortHash, SKEY(BSort), &vSortBy) &&
+ (vSortBy != NULL)) {
+ SortBy = (SortStruct*)vSortBy;
+ /** Ok, its us, lets see in which direction we should sort... */
+ if (havebstr("SortOrder")) {
+ int SortOrder;
+ SortOrder = LBSTR("SortOrder");
+ if (SortOrder != 0)
+ DetectGroupChange = 1;
+ }
+ }
+ }
+ }
nMembersUsed = GetCount(List);
SubBuf = NewStrBuf();
it = GetNewHashPos(List, 0);
while (GetNextHashPos(List, it, &len, &Key, &vContext)) {
+ 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);
if (It->DoSubTemplate != NULL)
It->DoSubTemplate(SubBuf, vContext, Tokens);
- DoTemplate(Tokens->Params[1]->Start,
- Tokens->Params[1]->len,
- SubBuf, vContext,
- It->ContextType);
+ DoTemplate(TKEY(1), SubBuf, vContext, It->ContextType);
StrBufAppendBuf(Target, SubBuf, 0);
FlushStrBuf(SubBuf);
oddeven = ~ oddeven;
+ vLastContext = vContext;
}
FreeStrBuf(&SubBuf);
DeleteHashPos(&it);
void *vsubst;
wcsubst *subst;
- if (!GetHash(WC->vars,
- Tokens->Params[2]->Start,
- Tokens->Params[2]->len,
- &vsubst))
+ if (!GetHash(WC->vars, TKEY(2), &vsubst))
return 0;
subst = (wcsubst*) vsubst;
if ((subst->ContextRequired != CTX_NONE) &&
case WCS_FUNCTION:
return (subst->wcs_function!=NULL);
case WCS_SERVCMD:
- lprintf(1, " -> Server [%s]\n", subst->wcs_value);////todo
+ lprintf(1, " -> Server [%s]\n", subst->wcs_value);/* TODO */
return 1;
case WCS_STRING:
case WCS_STRBUF:
if (nArgs == 2) {
if (Tokens->Params[1]->Type == TYPE_STR) {
Headline = NewStrBuf();
- DoTemplate(Tokens->Params[1]->Start,
- Tokens->Params[1]->len,
- Headline,
- Context,
- ContextType);
+ DoTemplate(TKEY(1), Headline, Context, ContextType);
}
else {
const char *Ch;
}
DoTemplate(HKEY("beginbox"), Target, Headline, CTX_STRBUF);
- DoTemplate(Tokens->Params[0]->Start,
- Tokens->Params[0]->len,
- Target,
- Context,
- ContextType);
+ DoTemplate(TKEY(0), Target, Context, ContextType);
DoTemplate(HKEY("endbox"), Target, Context, ContextType);
FreeStrBuf(&Headline);
}
for (i = 0; i < ntabs; i++) {
TabNames[i] = NewStrBuf();
if (Tokens->Params[i * 2]->len > 0) {
- DoTemplate(Tokens->Params[i * 2]->Start,
- Tokens->Params[i * 2]->len,
- TabNames[i],
- Context,
- ContextType);
+ DoTemplate(TKEY(i * 2), TabNames[i], Context, ContextType);
}
else {
/** A Tab without subject? we can't count that, add it as silent */
for (i = 0; i < ntabs; i++) {
StrBeginTab(Target, i, nTabs);
- DoTemplate(Tokens->Params[i * 2 + 1]->Start,
- Tokens->Params[i * 2 + 1]->len,
- Target,
- Context,
- ContextType);
+ DoTemplate(TKEY(i * 2 + 1), Target, Context, ContextType);
StrEndTab(Target, i, nTabs);
}
}
* Sorting-API
*/
-typedef struct _SortStruct {
- StrBuf *Name;
- StrBuf *PrefPrepend;
- CompareFunc Forward;
- CompareFunc Reverse;
-
- long ContextType;
-}SortStruct;
-
-void DestroySortStruct(void *vSort)
-{
- SortStruct *Sort = (SortStruct*) vSort;
- FreeStrBuf(&Sort->Name);
- FreeStrBuf(&Sort->PrefPrepend);
- free (Sort);
-}
void RegisterSortFunc(const char *name, long len,
const char *prepend, long preplen,
CompareFunc Forward,
CompareFunc Reverse,
+ CompareFunc GroupChange,
long ContextType)
{
SortStruct *NewSort = (SortStruct*) malloc(sizeof(SortStruct));
NewSort->PrefPrepend = NULL;
NewSort->Forward = Forward;
NewSort->Reverse = Reverse;
+ NewSort->GroupChange = GroupChange;
NewSort->ContextType = ContextType;
Put(SortHash, name, len, NewSort, DestroySortStruct);
}
const StrBuf *BSort;
SortStruct *SortBy;
void *vSortBy;
- long SortOrder;
+ long SortOrder = -1;
if (havebstr("SortBy")) {
BSort = sbstr("SortBy");
BSort = get_room_pref("sort");
}
else {
- ////todo: nail prefprepend to sort, and lookup this!
+ /*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);
}
}
SortOrder = LBSTR("SortOrder");
}
else { /** Try to fallback to our remembered values... */
+ StrBuf *Buf;
if (SortBy->PrefPrepend == NULL) {
- SortOrder = StrTol(get_room_pref("SortOrder"));
+ Buf = get_room_pref("SortOrder");
+ SortOrder = StrTol(Buf);
}
else {
- ////todo: nail prefprepend to sort, and lookup this!
+ /* 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:
*SortOrder = 0;
*Next = NULL;
- if (!GetHash(SortHash, Tokens->Params[0]->Start, Tokens->Params[0]->len, &vSort) ||
+ if (!GetHash(SortHash, TKEY(0), &vSort) ||
(vSort == NULL))
return eNO_SUCH_SORT;
*Param = (SortStruct*) vSort;
BSort = get_room_pref("sort");
}
else {
- ////todo: nail prefprepend to sort, and lookup this!
+ /* TODO: nail prefprepend to sort, and lookup this! */
}
}
*SortOrder = StrTol(get_room_pref("SortOrder"));
}
else {
- ////todo: nail prefprepend to sort, and lookup this!
+ /* TODO: nail prefprepend to sort, and lookup this! */
}
}
if (*SortOrder > 2)
}
}
+void dbg_print_longvector(long *LongVector)
+{
+ StrBuf *Buf = NewStrBufPlain(HKEY("Longvector: ["));
+ int nItems = LongVector[0];
+ int i;
+
+ for (i = 0; i < nItems; i++) {
+ if (i + 1 < nItems)
+ StrBufAppendPrintf(Buf, "%d: %ld | ", i, LongVector[i]);
+ else
+ StrBufAppendPrintf(Buf, "%d: %ld]\n", i, LongVector[i]);
+ }
+ lprintf(1, ChrPtr(Buf));
+ FreeStrBuf(&Buf);
+}
int ConditionalLongVector(WCTemplateToken *Tokens, void *Context, int ContextType)
{
projects / citadel.git / blobdiff