#define SV_GETTEXT 1
#define SV_CONDITIONAL 2
#define SV_NEG_CONDITIONAL 3
-#define SV_SUBTEMPL 4
+#define SV_CUST_STR_CONDITIONAL 4
+#define SV_SUBTEMPL 5
typedef struct _WCTemplate {
StrBuf *Data;
Template->Tokens[(Template->nTokensUsed)++] = NewToken;
}
-TemplateParam *GetNextParameter(StrBuf *Buf, const char **pCh, const char *pe)
+TemplateParam *GetNextParameter(StrBuf *Buf, const char **pCh, const char *pe, WCTemplateToken *Token, WCTemplate *pTmpl)
{
const char *pch = *pCh;
const char *pchs, *pche;
}
pche = pch;
if (*pch != quote) {
- lprintf(1, "Error evaluating template param [%s]\n", *pCh);
+ lprintf(1, "Error (in '%s' line %ld); "
+ "evaluating template param [%s] in Token [%s]\n",
+ ChrPtr(pTmpl->FileName),
+ Token->Line,
+ ChrPtr(Token->FlatToken),
+ *pCh);
pch ++;
free(Parm);
return NULL;
}
else {
StrBufPeek(Buf, pch, -1, '\0');
- lprintf(1, "DBG: got param [%s]\n", pchs);
+ if (LoadTemplates > 1) {
+ lprintf(1, "DBG: got param [%s] %ld %ld\n",
+ pchs, pche - pchs, strlen(pchs));
+ }
Parm->Start = pchs;
Parm->len = pche - pchs;
pch ++; /* move after trailing quote */
}
else {
Parm->lvalue = 0;
- lprintf(1, "Error evaluating template long param [%s]\n", *pCh);
+ lprintf(1, "Error (in '%s' line %ld); "
+ "evaluating long template param [%s] in Token [%s]\n",
+ ChrPtr(pTmpl->FileName),
+ Token->Line,
+ ChrPtr(Token->FlatToken),
+ *pCh);
free(Parm);
return NULL;
}
WCTemplateToken *NewTemplateSubstitute(StrBuf *Buf,
const char *pStart,
const char *pTmplStart,
- const char *pTmplEnd)
+ const char *pTmplEnd,
+ long Line,
+ WCTemplate *pTmpl)
{
const char *pch;
TemplateParam *Param;
WCTemplateToken *NewToken = (WCTemplateToken*)malloc(sizeof(WCTemplateToken));
NewToken->Flags = 0;
+ NewToken->Line = Line + 1;
NewToken->pTokenStart = pTmplStart;
NewToken->TokenStart = pTmplStart - pStart;
NewToken->TokenEnd = (pTmplEnd - pStart) - NewToken->TokenStart;
NewToken->pTokenEnd = pTmplEnd;
NewToken->NameEnd = NewToken->TokenEnd - 2;
+ NewToken->FlatToken = NewStrBufPlain(pTmplStart, pTmplEnd - pTmplStart);
StrBufPeek(Buf, pTmplStart, + 1, '\0');
StrBufPeek(Buf, pTmplEnd, -1, '\0');
NewToken->NameEnd = pch - NewToken->pName;
pch ++;
while (pch < pTmplEnd - 1) {
- Param = GetNextParameter(Buf, &pch, pTmplEnd - 1);
+ Param = GetNextParameter(Buf, &pch, pTmplEnd - 1, NewToken, pTmpl);
if (Param != NULL) {
NewToken->HaveParameters = 1;
if (NewToken->nParameters > MAXPARAM) {
else if ((NewToken->nParameters == 1) &&
(*(NewToken->pName) == '='))
NewToken->Flags = SV_SUBTEMPL;
+ else if ((NewToken->nParameters >= 2) &&
+ (*(NewToken->pName) == '%'))
+ NewToken->Flags = SV_CUST_STR_CONDITIONAL;
else if ((NewToken->nParameters >= 2) &&
(*(NewToken->pName) == '?'))
NewToken->Flags = SV_CONDITIONAL;
void FreeToken(WCTemplateToken **Token)
{
int i;
+ FreeStrBuf(&(*Token)->FlatToken);
if ((*Token)->HaveParameters)
for (i = 0; i < (*Token)->nParameters; i++)
free((*Token)->Params[i]);
}
-int EvaluateConditional(WCTemplateToken *Token, void *Context, int Neg, int state)
+int EvaluateConditional(WCTemplateToken *Token, WCTemplate *pTmpl, void *Context, int Neg, int state)
{
void *vConditional;
ConditionalStruct *Cond;
Token->Params[0]->Start,
Token->Params[0]->len,
&vConditional)) {
- lprintf(1, "Conditional %s Not found!\n",
- Token->Params[0]->Start);
+ lprintf(1, "Conditional [%s] (in '%s' line %ld); Not found![%s]\n",
+ Token->Params[0]->Start,
+ ChrPtr(pTmpl->FileName),
+ Token->Line,
+ ChrPtr(Token->FlatToken));
}
Cond = (ConditionalStruct *) vConditional;
if (Cond == NULL) {
- lprintf(1, "Conditional %s Not found!\n",
- Token->Params[0]->Start);
+ lprintf(1, "Conditional [%s] (in '%s' line %ld); Not found![%s]\n",
+ Token->Params[0]->Start,
+ ChrPtr(pTmpl->FileName),
+ Token->Line,
+ ChrPtr(Token->FlatToken));
return 0;
}
if (Token->nParameters < Cond->nParams) {
- lprintf(1, "Conditional [%s] needs %ld Params!\n",
+ lprintf(1, "Conditional [%s] (in '%s' line %ld); needs %ld Params![%s]\n",
Token->Params[0]->Start,
- Cond->nParams);
+ ChrPtr(pTmpl->FileName),
+ Token->Line,
+ Cond->nParams,
+ ChrPtr(Token->FlatToken));
return 0;
}
if (Cond->CondF(Token, Context) == Neg)
return 0;
}
-int EvaluateToken(StrBuf *Target, WCTemplateToken *Token, void *Context, int state)
+int EvaluateToken(StrBuf *Target, WCTemplateToken *Token, WCTemplate *pTmpl, void *Context, int state)
{
void *vVar;
// much output, since pName is not terminated...
case SV_GETTEXT:
TmplGettext(Target, Token->nParameters, Token);
break;
- case SV_CONDITIONAL:
- return EvaluateConditional(Token, Context, 1, state);
+ case SV_CONDITIONAL: /** Forward conditional evaluation */
+ return EvaluateConditional(Token, pTmpl, Context, 1, state);
break;
- case SV_NEG_CONDITIONAL:
- return EvaluateConditional(Token, Context, 0, state);
+ case SV_NEG_CONDITIONAL: /** Reverse conditional evaluation */
+ return EvaluateConditional(Token, pTmpl, Context, 0, state);
+ break;
+ case SV_CUST_STR_CONDITIONAL: /** Conditional put custom strings from params */
+ if (Token->nParameters >= 6) {
+ if (EvaluateConditional(Token, pTmpl, Context, 0, state))
+ StrBufAppendBufPlain(Target,
+ Token->Params[5]->Start,
+ Token->Params[5]->len,
+ 0);
+ else
+ StrBufAppendBufPlain(Target,
+ Token->Params[4]->Start,
+ Token->Params[4]->len,
+ 0);
+ }
break;
case SV_SUBTEMPL:
if (Token->nParameters == 1)
const char *pData, *pS;
long len;
- if (LoadTemplates != 0) {
+ if (LoadTemplates != 0) {
+ if (LoadTemplates > 1)
+ lprintf(1, "DBG: ----- loading: [%s] ------ \n",
+ ChrPtr(Tmpl->FileName));
pTmpl = load_template(Tmpl->FileName, NULL, NULL);
}
StrBufAppendBufPlain(
Target, pData,
pTmpl->Tokens[i]->pTokenStart - pData, 0);
- state = EvaluateToken(Target, pTmpl->Tokens[i], Context, state);
+ state = EvaluateToken(Target, pTmpl->Tokens[i], pTmpl, Context, state);
while ((state != 0) && (i+1 < pTmpl->nTokensUsed)) {
/* condition told us to skip till its end condition */
i++;
if ((pTmpl->Tokens[i]->Flags == SV_CONDITIONAL) ||
(pTmpl->Tokens[i]->Flags == SV_NEG_CONDITIONAL)) {
if (state == EvaluateConditional(pTmpl->Tokens[i],
+ pTmpl,
Context,
pTmpl->Tokens[i]->Flags,
state))
int fd;
struct stat statbuf;
const char *pS, *pE, *pch, *Err;
+ long Line;
int pos;
WCTemplate *NewTemplate;
NewTemplate = (WCTemplate *) malloc(sizeof(WCTemplate));
NewTemplate->Data = NewStrBufPlain(NULL, statbuf.st_size);
- NewTemplate->FileName = NULL;
+ NewTemplate->FileName = NewStrBufDup(filename);
NewTemplate->nTokensUsed = 0;
NewTemplate->TokenSpace = 0;
NewTemplate->Tokens = NULL;
}
close(fd);
+ Line = 0;
pS = pch = ChrPtr(NewTemplate->Data);
pE = pS + StrLength(NewTemplate->Data);
while (pch < pE) {
for (; pch < pE; pch ++) {
if ((*pch=='<')&&(*(pch + 1)=='?'))
break;
+ if (*pch=='\n') Line ++;
}
if (pch >= pE)
continue;
continue;
pte = pch;
PutNewToken(NewTemplate,
- NewTemplateSubstitute(NewTemplate->Data, pS, pts, pte));
+ NewTemplateSubstitute(NewTemplate->Data, pS, pts, pte, Line, NewTemplate));
pch ++;
}
if (LoadTemplates == 0)
return NewTemplate;
}
+
+///void PrintTemplate(const char *Key, void *vSubst, int odd)
+const char* PrintTemplate(void *vSubst)
+{
+ WCTemplate *Tmpl = vSubst;
+
+ return ChrPtr(Tmpl->FileName);
+
+}
+
+
/**
* \brief Display a variable-substituted template
* \param templatename template file to load
if (!GetHash(StaticLocal, templatename, len, &vTmpl) &&
!GetHash(Static, templatename, len, &vTmpl)) {
- printf ("didn't find %s\n", templatename);
+ printf ("didn't find %s %ld %ld\n", templatename, len , (long)strlen(templatename));
+/// dbg_PrintHash(Static, PrintTemplate, NULL);
+// PrintHash(Static, VarPrintTransition, PrintTemplate);
return;
}
if (vTmpl == NULL)
void tmpl_do_tabbed(StrBuf *Target, int nArgs, WCTemplateToken *Tokens, void *Context)
{
StrBuf **TabNames;
- int i, ntabs;
+ int i, ntabs, nTabs;
- ntabs = Tokens->nParameters / 2;
+ nTabs = ntabs = Tokens->nParameters / 2;
TabNames = (StrBuf **) malloc(ntabs * sizeof(StrBuf*));
for (i = 0; i < ntabs; i++) {
TabNames[i] = NewStrBuf();
- DoTemplate(Tokens->Params[i * 2]->Start,
- Tokens->Params[0]->len,
- Context,
- TabNames[i]);
+ if (Tokens->Params[i * 2]->len > 0) {
+ DoTemplate(Tokens->Params[i * 2]->Start,
+ Tokens->Params[i * 2]->len,
+ Context,
+ TabNames[i]);
+ }
+ else {
+ /** A Tab without subject? we can't count that, add it as silent */
+ nTabs --;
+ }
}
- StrTabbedDialog(Target, ntabs, TabNames);
+ StrTabbedDialog(Target, nTabs, TabNames);
for (i = 0; i < ntabs; i++) {
- StrBeginTab(Target, ntabs, i);
+ StrBeginTab(Target, i, nTabs);
DoTemplate(Tokens->Params[i * 2 + 1]->Start,
Tokens->Params[i * 2 + 1]->len,
Context,
Target);
- StrEndTab(Target, ntabs, i);
+ StrEndTab(Target, i, nTabs);
}
}
InitModule_SUBST
(void)
{
- RegisterNamespace("SERV_PID", 0, 0, tmplput_serv_ip);
- RegisterNamespace("SERV_NODENAME", 0, 0, tmplput_serv_nodename);
- RegisterNamespace("SERV_HUMANNODE", 0, 0, tmplput_serv_humannode);
- RegisterNamespace("SERV_FQDN", 0, 0, tmplput_serv_fqdn);
- RegisterNamespace("SERV_SOFTWARE", 0, 0, tmmplput_serv_software);
- RegisterNamespace("SERV_REV_LEVEL", 0, 0, tmplput_serv_rev_level);
- RegisterNamespace("SERV_BBS_CITY", 0, 0, tmmplput_serv_bbs_city);
+ RegisterNamespace("SERV:PID", 0, 0, tmplput_serv_ip);
+ RegisterNamespace("SERV:NODENAME", 0, 0, tmplput_serv_nodename);
+ RegisterNamespace("SERV:HUMANNODE", 0, 0, tmplput_serv_humannode);
+ RegisterNamespace("SERV:FQDN", 0, 0, tmplput_serv_fqdn);
+ RegisterNamespace("SERV:SOFTWARE", 0, 0, tmmplput_serv_software);
+ RegisterNamespace("SERV:REV_LEVEL", 0, 0, tmplput_serv_rev_level);
+ RegisterNamespace("SERV:BBS_CITY", 0, 0, tmmplput_serv_bbs_city);
+/// RegisterNamespace("SERV:LDAP_SUPP", 0, 0, tmmplput_serv_ldap_enabled);
RegisterNamespace("CURRENT_USER", 0, 0, tmplput_current_user);
RegisterNamespace("CURRENT_ROOM", 0, 0, tmplput_current_room);
RegisterNamespace("ITERATE", 2, 4, tmpl_iterate_subtmpl);
projects / citadel.git / blobdiff