template.c

   1 /*
   2  * cOpyright (c) 2004 Teodor Sigaev <teodor@sigaev.ru>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *        notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *        notice, this list of conditions and the following disclaimer in the
  12  *        documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the author nor the names of any co-contributors
  14  *        may be used to endorse or promote products derived from this software
  15  *        without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY CONTRIBUTORS ``AS IS'' AND ANY EXPRESS
  18  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED. IN NO EVENT SHALL CONTRIBUTORS BE LIABLE FOR ANY
  21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  23  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  25  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  26  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  27  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include <sys/types.h>
  31 #include <string.h>
  32
  33 #include "tmalloc.h"
  34 #include "tlog.h"
  35 #include "template.h"
  36
  37 /*
  38  * Simple list implementation
  39  */
  40 #define TListPush(l,c)  do      {                                               \
  41         (c)->nextCell = NULL;                                                   \
  42         if ( (l)->tailList == NULL ) {                                  \
  43                 (l)->headList = (l)->tailList = (c);            \
  44         } else {                                                                                \
  45                 (l)->tailList->nextCell = (c);                          \
  46                 (l)->tailList = (c);                                            \
  47         }                                                                                               \
  48 } while(0)
  49
  50 #define TListUnShift(l,c)  do  {                                        \
  51         (c)->nextCell = (l)->headList;                                  \
  52         if ( (l)->headList == NULL ) {                                  \
  53                 (l)->headList = (l)->tailList = (c);            \
  54         } else {                                                                                \
  55                 (l)->headList = (c);                                            \
  56         }                                                                                               \
  57 } while(0)
  58
  59 #define TListShift(l,c)  do  {                                          \
  60         (c) = (l)->headList;                                                    \
  61         if ( (c) != NULL )      {                                                       \
  62                 (l)->headList = (c)->nextCell;                          \
  63                 if ( (l)->headList == NULL )                            \
  64                         (l)->tailList = NULL;                                   \
  65         }                                                                                               \
  66 } while(0)
  67
  68 #define TListIsEmpty(l)         ( (l)->headList == NULL )
  69
  70 /*
  71  * Default operations and functions
  72  */
  73
  74 static int
  75 isVariable(VariableValue value) {
  76         if ( value == NULL )
  77                 return 0;
  78
  79         if ( (value->flags & TND_DEFINED) == 0 ) {
  80                 return 0;
  81         } else {
  82                 switch (value->type) {
  83                         case valueInt:
  84                                 return (value->value.intValue == 0) ? 0 : 1;
  85                         case valueString:
  86                                 if ( value->value.stringValue == NULL || *value->value.stringValue == '\0' )
  87                                         return 0;
  88                                 return 1;
  89                         case valueTime:
  90                                 return ( value->value.timeValue > 0 ) ? 1 : 0;
  91                         case valueBool:
  92                                 return value->value.boolValue;
  93                         case valueDouble:
  94                                 return (value->value.doubleValue == 0) ? 0 : 1;
  95                         case valuePointer:
  96                         default:
  97                                 return 0;
  98                 }
  99         }
 100
 101         return 0;
 102 }
 103
 104 static VariableValue
 105 makeBoolValue(TemplateInstance tmpl, int v) {
 106         VariableValue   outvalue = mcalloc(tmpl->templateContext, sizeof(VariableValueData));
 107
 108         outvalue->type = valueBool;
 109         outvalue->flags= TND_DEFINED;
 110         outvalue->value.boolValue = (v) ? 1 : 0;
 111         return outvalue;
 112 }
 113
 114 static VariableValue
 115 copyValue(TemplateInstance tmpl, VariableValue in) {
 116         VariableValue   out= mcalloc(tmpl->templateContext, sizeof(VariableValueData));
 117
 118         if (in)
 119                 memcpy(out, in, sizeof(VariableValueData));
 120         else {
 121                 out->type = valueBool; /* something */
 122                 out->flags = 0;
 123         }
 124         return out;
 125 }
 126
 127 static VariableValue
 128 isDefinedFn(TemplateInstance tmpl, int n, VariableValue *vals) {
 129         return makeBoolValue(tmpl, vals[0]->flags & TND_DEFINED );
 130 }
 131
 132 static int
 133 strmblen(char *str) {
 134         int len = strlen(str);
 135         int     totlen = 0, clen;
 136
 137         mblen(NULL,0); /* reset internal state */
 138         while( len > 0 ) {
 139                 clen = mblen( str, len );
 140                 str += clen;
 141                 len -= clen;
 142                 totlen++;
 143         }
 144
 145         return totlen;
 146 }
 147
 148 static VariableValue
 149 LengthFn(TemplateInstance tmpl, int n, VariableValue *vals) {
 150         VariableValue   outvalue = NULL;
 151
 152         outvalue = copyValue( tmpl, NULL );
 153         outvalue->type = valueInt;
 154
 155         if ( vals[0]->type == valueString && vals[0]->value.stringValue &&
 156                                                                 (vals[0]->flags & TND_DEFINED) ) {
 157                 outvalue->flags |= TND_DEFINED;
 158                 outvalue->value.intValue = strmblen( vals[0]->value.stringValue );
 159         } else
 160                 outvalue->flags &= ~TND_DEFINED;
 161
 162         return outvalue;
 163 }
 164
 165 static VariableValue
 166 NotFn(TemplateInstance tmpl, int n, VariableValue *vals) {
 167         return makeBoolValue(tmpl, !isVariable(vals[0]));
 168 }
 169
 170 static VariableValue
 171 AndFn(TemplateInstance tmpl, int n, VariableValue *vals) {
 172         return makeBoolValue(tmpl, isVariable(vals[0]) && isVariable(vals[1]) );
 173 }
 174
 175 static VariableValue
 176 OrFn(TemplateInstance tmpl, int n, VariableValue *vals) {
 177         return makeBoolValue(tmpl, isVariable(vals[0]) || isVariable(vals[1]) );
 178 }
 179
 180 static VariableValue
 181 CondFn(TemplateInstance tmpl, int n, VariableValue *vals) {
 182         return isVariable(vals[0]) ? vals[1] : vals[2];
 183 }
 184
 185 static VariableValue
 186 ModFn(TemplateInstance tmpl, int n, VariableValue *vals) {
 187         VariableValue   outvalue = copyValue( tmpl, NULL );
 188
 189         outvalue->type = valueInt;
 190
 191         if ( (vals[0]->flags & vals[1]->flags & TND_DEFINED) &&
 192                                         vals[0]->type == valueInt && vals[1]->type == valueInt) {
 193
 194                 outvalue->flags |= TND_DEFINED;
 195                 outvalue->value.intValue = vals[0]->value.intValue % vals[1]->value.intValue;
 196         } else
 197                 outvalue->flags &= ~TND_DEFINED;
 198
 199         return outvalue;
 200 }
 201
 202 static VariableValue
 203 UnaryMinesFn(TemplateInstance tmpl, int n, VariableValue *vals) {
 204         VariableValue   outvalue = copyValue( tmpl, vals[0] );
 205
 206         if (outvalue->type == valueInt)
 207                 outvalue->value.intValue = -outvalue->value.intValue;
 208         else if (outvalue->type == valueDouble)
 209                 outvalue->value.doubleValue = -outvalue->value.doubleValue;
 210         else
 211                 outvalue->flags &= ~TND_DEFINED;
 212
 213         return outvalue;
 214 }
 215
 216 #define ISNUM(v)        ( ((v)->type == valueDouble || (v)->type == valueInt) && ((v)->flags & TND_DEFINED)  )
 217
 218 #define ARIPHACT(OP)                                                                                                                                                            \
 219         VariableValue outvalue = copyValue( tmpl, NULL );                                                                                               \
 220         if ( !(ISNUM(vals[0]) && ISNUM(vals[1])) ) {                                                                                                    \
 221                 outvalue->flags &= ~TND_DEFINED;                                                                                                                        \
 222         } else if ( vals[0]->type == valueDouble || vals[1]->type == valueDouble ) {                                    \
 223                 outvalue->flags |= TND_DEFINED;                                                                                                                         \
 224                 outvalue->type = valueDouble;                                                                                                                           \
 225                 if ( vals[0]->type == valueDouble )                                                                                                                     \
 226                         outvalue->value.doubleValue = vals[0]->value.doubleValue;                                                               \
 227                 else                                                                                                                                                                            \
 228                         outvalue->value.doubleValue = vals[0]->value.intValue;                                                                  \
 229                 if ( vals[1]->type == valueDouble )                                                                                                                     \
 230                         outvalue->value.doubleValue OP##= vals[1]->value.doubleValue;                                                   \
 231                 else                                                                                                                                                                            \
 232                         outvalue->value.doubleValue OP##= vals[1]->value.intValue;                                                              \
 233         } else {                                                                                                                                                                                \
 234                 outvalue->flags |= TND_DEFINED;                                                                                                                         \
 235                 outvalue->type = valueInt;                                                                                                                                      \
 236                 outvalue->value.intValue = vals[0]->value.intValue OP vals[1]->value.intValue;                          \
 237         }
 238
 239 static VariableValue
 240 PlusFn(TemplateInstance tmpl, int n, VariableValue *vals) {
 241         ARIPHACT(+)
 242         return outvalue;
 243 }
 244
 245 static VariableValue
 246 MinesFn(TemplateInstance tmpl, int n, VariableValue *vals) {
 247         ARIPHACT(-)
 248         return outvalue;
 249 }
 250
 251 static VariableValue
 252 MulFn(TemplateInstance tmpl, int n, VariableValue *vals) {
 253         ARIPHACT(*)
 254         return outvalue;
 255 }
 256
 257 static VariableValue
 258 DivFn(TemplateInstance tmpl, int n, VariableValue *vals) {
 259         ARIPHACT(/)
 260         return outvalue;
 261 }
 262
 263 #define CMPACT(OP)                                                                                                                                                                      \
 264         VariableValue outvalue = copyValue( tmpl, NULL );                                                                                               \
 265         outvalue->type = valueBool;                                                                                                                                             \
 266         if ( !(ISNUM(vals[0]) && ISNUM(vals[1])) ) {                                                                                                    \
 267                 outvalue->flags &= ~TND_DEFINED;                                                                                                                        \
 268         } else if ( vals[0]->type == valueDouble || vals[1]->type == valueDouble ) {                                    \
 269                 outvalue->flags |= TND_DEFINED;                                                                                                                         \
 270                 if ( vals[0]->type == valueDouble && vals[1]->type == valueDouble )                                             \
 271                         outvalue->value.boolValue = (vals[0]->value.doubleValue OP vals[1]->value.doubleValue)  \
 272                                                                 ? 1 : 0;                                                                                                                        \
 273                 else if ( vals[0]->type == valueDouble )                                                                                                        \
 274                         outvalue->value.boolValue = (vals[0]->value.doubleValue OP vals[1]->value.intValue)     \
 275                                                                 ? 1 : 0;                                                                                                                        \
 276                 else                                                                                                                                                                            \
 277                         outvalue->value.boolValue = (vals[0]->value.intValue OP vals[1]->value.doubleValue)     \
 278                                                                 ? 1 : 0;                                                                                                                        \
 279         } else {                                                                                                                                                                                \
 280                 outvalue->flags |= TND_DEFINED;                                                                                                                         \
 281                 outvalue->value.boolValue = (vals[0]->value.intValue OP vals[1]->value.intValue) ? 1 : 0;       \
 282         }
 283
 284 static VariableValue
 285 LtFn(TemplateInstance tmpl, int n, VariableValue *vals) {
 286         CMPACT(<)
 287         return outvalue;
 288 }
 289
 290 static VariableValue
 291 LeFn(TemplateInstance tmpl, int n, VariableValue *vals) {
 292         CMPACT(<=)
 293         return outvalue;
 294 }
 295
 296 static VariableValue
 297 EqFn(TemplateInstance tmpl, int n, VariableValue *vals) {
 298         CMPACT(==)
 299         return outvalue;
 300 }
 301
 302 static VariableValue
 303 GeFn(TemplateInstance tmpl, int n, VariableValue *vals) {
 304         CMPACT(>=)
 305         return outvalue;
 306 }
 307
 308 static VariableValue
 309 GtFn(TemplateInstance tmpl, int n, VariableValue *vals) {
 310         CMPACT(>)
 311         return outvalue;
 312 }
 313
 314 static VariableValue
 315 NeFn(TemplateInstance tmpl, int n, VariableValue *vals) {
 316         CMPACT(!=)
 317         return outvalue;
 318 }
 319
 320 static executeFunctionDescData Functions[] = {
 321         {"defined",     1,      isDefinedFn},
 322         {"length",      1,      LengthFn},
 323         {"+",           2,      PlusFn},
 324         {"-",           2,      MinesFn},
 325         {"*",           2,      MulFn},
 326         {"/",           2,      DivFn},
 327         {"%",           2,      ModFn},
 328         {"-",           1,      UnaryMinesFn},
 329         {"?",           3,      CondFn},
 330         {"||",          2,      OrFn},
 331         {"&&",          2,      AndFn},
 332         {"!",           1,      NotFn},
 333         {"<",           2,      LtFn},
 334         {"<=",          2,      LeFn},
 335         {"==",          2,      EqFn},
 336         {">=",          2,      GeFn},
 337         {">",           2,      GtFn},
 338         {"!=",          2,      NeFn},
 339         {"<>",          2,      NeFn},
 340         {NULL,          -1,     NULL}
 341 };
 342
 343
 344 /*
 345  * Initialize functions
 346  */
 347
 348 #define MAXDEPTH        (128)
 349
 350 typedef struct ParseState {
 351         int                     depth;
 352         char            *basename;
 353         Template        tmpl;
 354 } ParseState;
 355
 356 static  char *
 357 getFilename(ParseState *state, char *filename) {
 358         int     len = 1 /* \0 */ + 1 /* / */ + strlen(filename);
 359         char    *res;
 360
 361         if ( *filename == '/' )
 362                 return filename;
 363
 364         if ( state->basename && *state->basename )
 365                 len += strlen(state->basename);
 366
 367         res = mcalloc(state->tmpl->templateContext, sizeof(char) * len);
 368         len = 0;
 369
 370         if ( state->basename && *state->basename ) {
 371                 len = strlen(state->basename);
 372                 memcpy( res, state->basename, len );
 373                 res[len++] = '/';
 374         }
 375
 376         memcpy( res+len, filename, strlen(filename));
 377         res[ len + strlen(filename) ] = '\0';
 378
 379         return res;
 380 }
 381
 382 static int recursiveReadTemplate( ParseState *state, Template  tmptmpl, char *filename );
 383
 384 static int
 385 findIncludes(ParseState *state, TemplateNode *node) {
 386         TemplateData    tmp;
 387         GListCell               *cell;
 388
 389         tmp.templateContext = state->tmpl->templateContext;
 390
 391         if (node == NULL || *node == NULL)
 392                 return 0;
 393
 394         switch((*node)->type) {
 395                 case    IncludeNode:
 396                         tmp.tree = NULL;
 397                         if ( recursiveReadTemplate(state, &tmp, (*node)->nodeData.includeFile) != 0 )
 398                                 return 1;
 399                         *node = tmp.tree;
 400                         break;
 401                 case    LoopNode:
 402                         state->tmpl->templateInstanceSize += sizeof( LoopTemplateInstanceData );
 403                         if ( findIncludes(state, &( (*node)->nodeData.loop.bodyNode )) != 0 )
 404                                 return 1;
 405                         break;
 406                 case    ConditionNode:
 407                         if ( findIncludes(state, &( (*node)->nodeData.condition.ifNode )) != 0 ||
 408                                         findIncludes(state, &( (*node)->nodeData.condition.elseNode )) != 0  ||
 409                                         findIncludes(state, &( (*node)->nodeData.condition.expressionNode )) != 0 )
 410                                 return 1;
 411                         break;
 412                 case    CollectionNode:
 413                         GListForeach(cell, (*node)->nodeData.children) {
 414                                 TemplateNode    chld = (TemplateNode)GLCELL_DATA(cell);
 415
 416                                 if ( findIncludes(state, &chld) != 0 )
 417                                         return 1;
 418
 419                                 GLCELL_DATA(cell) = chld;
 420                         }
 421                         break;
 422                 case    VariableNode:
 423                         state->tmpl->templateInstanceSize += sizeof( VariableValueData );
 424                         break;
 425                 case    ExpressionNode:
 426                         GListForeach(cell, (*node)->nodeData.expression.argsNode) {
 427                                 TemplateNode    chld = (TemplateNode)GLCELL_DATA(cell);
 428
 429                                 if ( findIncludes(state, &chld) != 0 )
 430                                         return 1;
 431                                 GLCELL_DATA(cell) = chld;
 432                         }
 433                         break;
 434                 case    PrintNode:
 435                         if ( findIncludes(state, &( (*node)->nodeData.print.expressionNode )) )
 436                                 return 1;
 437                         break;
 438                 case    ConstNode:
 439                 case    TextNode:
 440                 case    NestNode:
 441                         break;
 442                 default:
 443                         tlog(TL_CRIT|TL_EXIT, "unknown node type: %d", (*node)->type);
 444         }
 445
 446         return 0;
 447 }
 448
 449 static int
 450 recursiveReadTemplate( ParseState *state, Template      tmptmpl, char *filename ) {
 451         int     err;
 452         char    *fn = getFilename(state, filename);
 453
 454         if ( state->depth > MAXDEPTH ) {
 455                 tlog(TL_ALARM, "too many depth of included templates");
 456                 return 4;
 457         }
 458
 459         if ( tmptmpl == NULL )
 460                 tmptmpl = state->tmpl;
 461
 462         if ( (err=parseTemplateFile( tmptmpl, fn )) != 0 )
 463                 return err;
 464
 465         state->depth++;
 466
 467         if ( (err=findIncludes(state, &(tmptmpl->tree))) != 0 )
 468                 return err;
 469
 470         state->depth--;
 471
 472         return 0;
 473 }
 474
 475 static char*
 476 qualifyVarname(Template tmpl, TemplateNode loopParentNode, char *varName, int *varNameLength) {
 477         int len;
 478         char *tmp;
 479
 480         if ( ! loopParentNode )
 481                 return varName;
 482
 483         len = loopParentNode->nodeData.loop.varNameLength + *varNameLength + 2;
 484         tmp = mcalloc(tmpl->templateContext, len);
 485         len = loopParentNode->nodeData.loop.varNameLength;
 486         memcpy( tmp, loopParentNode->nodeData.loop.varName, len);
 487         tmp[ len++ ] = '.';
 488         memcpy( tmp + len, varName, *varNameLength);
 489         len+=*varNameLength;
 490         tmp[ len ] = '\0';
 491
 492         *varNameLength = len;
 493         return tmp;
 494 }
 495
 496 static int
 497 checkSpecialVariable(int flags, char *varName) {
 498         if ( strcmp(varName, "__first") == 0 ) {
 499                 flags &= ~TND_GLOBAL; /* special vars cannot be global */
 500                 flags |= TND___FIRST;
 501         } else if ( strcmp(varName, "__last") == 0 ) {
 502                 flags &= ~TND_GLOBAL; /* special vars cannot be global */
 503                 flags |= TND___LAST;
 504         } else if ( strcmp(varName, "__counter") == 0 ) {
 505                 flags &= ~TND_GLOBAL; /* special vars cannot be global */
 506                 flags |= TND___COUNTER;
 507         } else if ( strcmp(varName, "__odd") == 0 ) {
 508                 flags &= ~TND_GLOBAL; /* special vars cannot be global */
 509                 flags |= TND___ODD;
 510         } else if ( strcmp(varName, "__even") == 0 ) {
 511                 flags &= ~TND_GLOBAL; /* special vars cannot be global */
 512                 flags |= TND___EVEN;
 513         } else if ( strcmp(varName, "__size") == 0 ) {
 514                 flags &= ~TND_GLOBAL; /* special vars cannot be global */
 515                 flags |= TND___SIZE;
 516         } else if ( strcmp(varName, "__level") == 0 ) {
 517                 flags &= ~TND_GLOBAL; /* special vars cannot be global */
 518                 flags |= TND___LEVEL;
 519         }
 520
 521         return flags;
 522 }
 523
 524 static Offset
 525 findVariable( Template tmpl, TemplateNode loopParentNode, int flags, char *varName, int varNameLength ) {
 526         Offset                  *pOffset;
 527
 528         if ( (pOffset = SFSFindData(&tmpl->variables, varName, varNameLength)) == NULL ) {
 529                 Offset                          offset = tmpl->templateInstanceSize;
 530                 VariableValue           pdata = (VariableValue)(tmpl->templateInstance + tmpl->templateInstanceSize);
 531                 SFSDataIO                       in;
 532
 533                 in.key = varName;
 534                 in.keylen = varNameLength;
 535                 in.data = &offset;
 536
 537                 tmpl->templateInstanceSize += sizeof(VariableValueData);
 538
 539                 SFSAdd(&tmpl->variables, &in);
 540
 541                 pdata->flags = 0;
 542
 543                 if ( loopParentNode && (flags & TND_GLOBAL) == 0 ) {
 544                         /*
 545                          * copy special flags to support loopParentNode
 546                          */
 547                         pdata->flags |=  flags & TND__SPECIALMASK;
 548                         pdata->type = valuePointer;
 549                         pdata->value.ptrValue = NULL;
 550
 551                         loopParentNode->nodeData.loop.listVarValues =
 552                                         GListPush( loopParentNode->nodeData.loop.listVarValues, (void*)offset );
 553                 }
 554
 555                 return offset;
 556         }
 557
 558         return *pOffset;
 559 }
 560
 561 static int
 562 addLoop(Template tmpl, TemplateNode node, TemplateNode loopParentNode) {
 563         SFSDataIO                               in;
 564         LoopTemplateInstance    lti;
 565
 566         if ( SFSFindData(&tmpl->variables, node->nodeData.loop.varName, node->nodeData.loop.varNameLength) != NULL ) {
 567                 tlog(TL_CRIT,"Loop marked '%s' is already defined", node->nodeData.loop.varName);
 568                 return 1;
 569         }
 570
 571         in.key = node->nodeData.loop.varName;
 572         in.keylen = node->nodeData.loop.varNameLength;
 573         in.data = &tmpl->templateInstanceSize;
 574
 575         SFSAdd(&tmpl->variables, &in);
 576
 577         node->nodeData.loop.loopDataOffset = tmpl->templateInstanceSize;
 578         lti = (LoopTemplateInstance)(tmpl->templateInstance + tmpl->templateInstanceSize);
 579         memset(lti, 0, sizeof( LoopTemplateInstanceData ));
 580         lti->type = LoopData;
 581         lti->loopNode = node;
 582
 583         tmpl->templateInstanceSize += sizeof( LoopTemplateInstanceData );
 584
 585         if ( loopParentNode ) {
 586                 loopParentNode->nodeData.loop.childrenLoop =
 587                         GListPush( loopParentNode->nodeData.loop.childrenLoop, node );
 588
 589                 if ( loopParentNode->nodeData.loop.selfNode )
 590                         loopParentNode->nodeData.loop.selfNode->nodeData.nest.childrenLoopAfterSelf =
 591                                 GListPush( loopParentNode->nodeData.loop.selfNode->nodeData.nest.childrenLoopAfterSelf, node );
 592         }
 593
 594         return 0;
 595 }
 596
 597 static void
 598 findFunction(Template tmpl, TemplateNode node) {
 599         executeFunctionDesc     ptr = tmpl->functions;
 600
 601         tassert(ptr != NULL);
 602
 603         while(ptr && ptr->name) {
 604                 if ( node->nodeData.expression.nargs < 0 || node->nodeData.expression.nargs == ptr->nargs ) {
 605                         if ( strcmp( node->nodeData.expression.functionName, ptr->name ) == 0 ) {
 606                                 node->nodeData.expression.function = ptr;
 607                                 return;
 608                         }
 609                 }
 610
 611                 ptr++;
 612         }
 613         tlog(TL_CRIT|TL_EXIT, "Can not find function named '%s' with %d arguments",
 614                                                                                 node->nodeData.expression.functionName,
 615                                                                                 node->nodeData.expression.nargs);
 616 }
 617
 618 static int
 619 compileTree( Template tmpl, TemplateNode node, TemplateNode loopParentNode ) {
 620         GListCell               *cell;
 621
 622         if ( !node )
 623                 return 0;
 624
 625         switch(node->type) {
 626                 case LoopNode:
 627                         node->nodeData.loop.varName = qualifyVarname(tmpl, loopParentNode,
 628                                                                                         node->nodeData.loop.varName,
 629                                                                                         &node->nodeData.loop.varNameLength);
 630                         if ( compileTree(tmpl, node->nodeData.loop.bodyNode, node) )
 631                                         return 1;
 632
 633                         if ( addLoop( tmpl, node, loopParentNode ) )
 634                                 return 1;
 635                         break;
 636                 case NestNode:
 637                         node->nodeData.nest.loop = loopParentNode;
 638                         if ( loopParentNode ) {
 639                                 if ( loopParentNode->nodeData.loop.selfNode )
 640                                         tlog(TL_WARN,"Loop '%s' has duplicated nested call", node->nodeData.loop.varName);
 641                                 else
 642                                         loopParentNode->nodeData.loop.selfNode = node;
 643                         } else
 644                                 tlog(TL_WARN,"SELF tag without loop");
 645                         break;
 646                 case ConditionNode:
 647                         if ( compileTree(tmpl, node->nodeData.condition.expressionNode, loopParentNode) )
 648                                         return 1;
 649                         if ( compileTree(tmpl, node->nodeData.condition.ifNode, loopParentNode) )
 650                                         return 1;
 651                         if ( compileTree(tmpl, node->nodeData.condition.elseNode, loopParentNode) )
 652                                         return 1;
 653                         break;
 654                 case CollectionNode:
 655                         GListForeach(cell, node->nodeData.children) {
 656                                 TemplateNode    chld = (TemplateNode)GLCELL_DATA(cell);
 657
 658                                 if ( compileTree(tmpl, chld, loopParentNode) )
 659                                         return 1;
 660                         }
 661                         break;
 662                 case VariableNode:
 663                         node->nodeData.variable.flags = checkSpecialVariable(
 664                                                                                                 node->nodeData.variable.flags,
 665                                                                                                 node->nodeData.variable.varName );
 666
 667                         if ( (node->nodeData.variable.flags & TND_GLOBAL) == 0 )
 668                                 node->nodeData.variable.varName = qualifyVarname(tmpl, loopParentNode,
 669                                                                                                         node->nodeData.variable.varName,
 670                                                                                                         &node->nodeData.variable.varNameLength);
 671
 672                         node->nodeData.variable.varValueOffset = findVariable( tmpl, loopParentNode,
 673                                                                                                 node->nodeData.variable.flags,
 674                                                                                                 node->nodeData.variable.varName,
 675                                                                                                 node->nodeData.variable.varNameLength );
 676                         break;
 677                 case PrintNode:
 678                         if ( compileTree(tmpl, node->nodeData.print.expressionNode, loopParentNode) )
 679                                 return 1;
 680                         break;
 681                 case ExpressionNode:
 682                         node->nodeData.expression.nargs = GLIST_LENGTH(node->nodeData.expression.argsNode);
 683                         findFunction(tmpl, node);
 684
 685                         node->nodeData.expression.argsValue = mcalloc(tmpl->templateContext, sizeof(VariableValue) *
 686                                                                                                                                 node->nodeData.expression.nargs );
 687
 688                         GListForeach(cell, node->nodeData.expression.argsNode)
 689                                 if ( compileTree(tmpl, (TemplateNode)GLCELL_DATA(cell), loopParentNode) )
 690                                         return 1;
 691                         break;
 692                 case IncludeNode:
 693                         tlog(TL_CRIT|TL_EXIT, "unexpected IncludeNode");
 694                         break;
 695                 case ConstNode:
 696                 case TextNode:
 697                         break;
 698                 default:
 699                         tlog(TL_CRIT|TL_EXIT, "unknown node type: %d", node->type);
 700         }
 701
 702         return 0;
 703 }
 704
 705 int
 706 initTemplate( Template tmpl, MemoryContext *mc, executeFunctionDesc functions, char *basedir, char *filename ) {
 707         ParseState      state;
 708         int err;
 709
 710         state.depth = 0;
 711         state.tmpl = tmpl;
 712         state.basename = basedir;
 713
 714         memset(tmpl, 0, sizeof(TemplateData));
 715         tmpl->templateContext = mc;
 716         SFSInit_dp(&tmpl->variables, sizeof(Offset), NULL);
 717
 718         if ( functions ) {
 719                 executeFunctionDesc     ptr = functions;
 720                 int n=0;
 721
 722                 while(ptr->name)
 723                         ptr++;
 724
 725                 n = ptr - functions;
 726                 tmpl->functions = mcalloc(tmpl->templateContext,
 727                         sizeof(executeFunctionDescData) * n + sizeof(Functions));
 728
 729                 memcpy( tmpl->functions, functions, sizeof(executeFunctionDescData) * n );
 730                 memcpy( tmpl->functions + n, Functions, sizeof(Functions));
 731         } else
 732                 tmpl->functions = Functions;
 733
 734         if ( (err=recursiveReadTemplate(&state, NULL, filename))!=0 )
 735                 return err;
 736
 737         tmpl->templateInstance = mcalloc( tmpl->templateContext, tmpl->templateInstanceSize );
 738         tmpl->templateInstanceSize = 0;
 739         if ( (err=compileTree( tmpl, tmpl->tree, NULL ))!=0 )
 740                 return err;
 741
 742         return 0;
 743 }
 744
 745 /*
 746  * cleanup
 747  */
 748
 749 static void
 750 freeNode( TemplateNode node ) {
 751         GListCell   *cell;
 752
 753         if (!node)
 754                 return;
 755
 756         switch (node->type) {
 757                 case    LoopNode:
 758                         freeNode( node->nodeData.loop.bodyNode ); /* selfNode is somewhere inside bodyNode */
 759                         GListFree( node->nodeData.loop.childrenLoop );
 760                         GListFree( node->nodeData.loop.listVarValues );
 761                         break;
 762                 case    CollectionNode:
 763                         GListForeach( cell, node->nodeData.children )
 764                                 freeNode( (TemplateNode)GLCELL_DATA(cell) );
 765                         GListFree( node->nodeData.children );
 766                         break;
 767                 case    ConditionNode:
 768                         freeNode( node->nodeData.condition.expressionNode );
 769                         freeNode( node->nodeData.condition.ifNode );
 770                         freeNode( node->nodeData.condition.elseNode );
 771                         break;
 772                 case    PrintNode:
 773                         freeNode( node->nodeData.print.expressionNode);
 774                         break;
 775                 case    ExpressionNode:
 776                         GListForeach(cell, node->nodeData.expression.argsNode)
 777                                 freeNode( GLCELL_DATA(cell) );
 778                         GListFree( node->nodeData.expression.argsNode );
 779                         break;
 780                 case    NestNode:
 781                         GListFree( node->nodeData.nest.childrenLoopAfterSelf );
 782                         break;
 783                 case    VariableNode:
 784                 case    IncludeNode:
 785                 case    TextNode:
 786                 case    ConstNode:
 787                 default:
 788                         break;
 789         }
 790 }
 791
 792 void
 793 freeTemplate( Template tmpl ) {
 794         SFSFree( &tmpl->variables, NULL );
 795         freeNode( tmpl->tree );
 796 }
 797
 798 /*
 799  * Set value routines
 800  */
 801
 802 TemplateInstance
 803 newTemplateInstance(Template tmpl, MemoryContext *mc) {
 804         TemplateInstance        ti;
 805
 806         if (mc == NULL)
 807                 mc = tmpl->templateContext;
 808
 809         ti = mcalloc(mc, sizeof(TemplateInstanceData) + tmpl->templateInstanceSize);
 810         ti->tmpl = tmpl;
 811         ti->templateContext = mc;
 812         memcpy( ti->instanceData, tmpl->templateInstance, tmpl->templateInstanceSize);
 813
 814         return ti;
 815 }
 816
 817 static void
 818 newLoopInstance( TemplateInstance tmpl, TemplateNode node ) {
 819         LoopInstance                    upper = NULL;
 820         LoopTemplateInstance    loopData = (LoopTemplateInstance)
 821                                                         (tmpl->instanceData + node->nodeData.loop.loopDataOffset);
 822
 823         if ( loopData->currentInstance )
 824                 upper = loopData->currentInstance->upperInstance;
 825
 826         loopData->currentInstance =
 827                                 mc0alloc(tmpl->templateContext, sizeof(LoopInstanceData) );
 828         loopData->currentInstance->upperInstance = upper;
 829
 830         TListPush( loopData, loopData->currentInstance );
 831
 832         loopData->lastRow = NULL;
 833 }
 834
 835 int
 836 addTemplateRow( TemplateInstance tmpl, char * key) {
 837         Offset                  *pOffset;
 838         TemplateNode    node;
 839         LoopTemplateInstance    loopData;
 840         char            *lkey = strlower(mcstrdup(tmpl->templateContext, key));
 841         GListCell               *cell;
 842         int                             i=0, nvar;
 843         LoopRow                 rowData;
 844
 845         pOffset = SFSFindData(&tmpl->tmpl->variables, lkey, 0);
 846         mcfree(lkey);
 847
 848         if ( pOffset == NULL )
 849                 return TVAR_NOTFOUND;
 850
 851         loopData = (LoopTemplateInstance)(tmpl->instanceData + *pOffset);
 852
 853         if ( loopData->type != LoopData )
 854                 return TVAR_FORBIDDEN;
 855         node = loopData->loopNode;
 856
 857         tassert( *pOffset == node->nodeData.loop.loopDataOffset );
 858
 859         nvar = GLIST_LENGTH( node->nodeData.loop.listVarValues );
 860         if ( nvar == 0 )
 861                 /* loop without vars can not be looped */
 862                 return TVAR_NOROW;
 863
 864         if ( TListIsEmpty(loopData) )
 865                 newLoopInstance(tmpl, node);
 866
 867         GListForeach( cell, node->nodeData.loop.childrenLoop )
 868                 newLoopInstance( tmpl, GLCELL_DATA(cell) );
 869
 870         loopData->lastRow = rowData = mcalloc( tmpl->templateContext, LRDHDRSZ + sizeof(VariableValueData) * nvar );
 871         rowData->loop = node;
 872         rowData->nestedInstance = NULL;
 873
 874         GListForeach( cell, node->nodeData.loop.listVarValues ) {
 875                 VariableValue   vv = (VariableValue) (tmpl->instanceData + ((Offset)GLCELL_DATA(cell)));
 876
 877                 vv->value.ptrValue = rowData->varvals + i;
 878                 rowData->varvals[i].flags = 0;
 879                 i++;
 880         }
 881
 882         loopData->currentInstance->nrow++;
 883         TListPush( loopData->currentInstance, rowData );
 884
 885         return TVAR_OK;
 886 }
 887
 888 int
 889 addTemplateNestedLoop( TemplateInstance tmpl, char * key) {
 890         Offset                  *pOffset;
 891         TemplateNode    node;
 892         LoopTemplateInstance    loopData;
 893         char            *lkey = strlower(mcstrdup(tmpl->templateContext, key));
 894         GListCell               *cell;
 895
 896         pOffset = SFSFindData(&tmpl->tmpl->variables, lkey, 0);
 897         mcfree(lkey);
 898
 899         if ( pOffset == NULL )
 900                 return TVAR_NOTFOUND;
 901
 902         loopData = (LoopTemplateInstance)(tmpl->instanceData + *pOffset);
 903
 904         if ( loopData->type != LoopData )
 905                 return TVAR_FORBIDDEN;
 906         node = loopData->loopNode;
 907
 908         if ( node->nodeData.loop.selfNode == NULL )
 909                 return TVAR_FORBIDDEN;
 910
 911         if ( TListIsEmpty(loopData) || loopData->lastRow == NULL )
 912                 return TVAR_NOROW;
 913
 914         GListForeach( cell, node->nodeData.loop.childrenLoop ) {
 915                 LoopTemplateInstance    childData = (LoopTemplateInstance)
 916                                 (tmpl->instanceData + ((TemplateNode)GLCELL_DATA(cell))->nodeData.loop.loopDataOffset);
 917
 918                 childData->lastRow = NULL;
 919         }
 920
 921         loopData->lastRow->nestedInstance =
 922                                 mc0alloc(tmpl->templateContext, sizeof(LoopInstanceData) );
 923         loopData->lastRow->nestedInstance->upperInstance =
 924                                 loopData->currentInstance;
 925         loopData->currentInstance =
 926                                 loopData->lastRow->nestedInstance;
 927         loopData->lastRow = NULL;
 928
 929         return TVAR_OK;
 930 }
 931
 932 int
 933 returnTemplateNestedLoop( TemplateInstance tmpl, char * key) {
 934         Offset                  *pOffset;
 935         TemplateNode    node;
 936         LoopTemplateInstance    loopData;
 937         char            *lkey = strlower(mcstrdup(tmpl->templateContext, key));
 938         GListCell               *cell;
 939
 940         pOffset = SFSFindData(&tmpl->tmpl->variables, lkey, 0);
 941         mcfree(lkey);
 942
 943         if ( pOffset == NULL )
 944                 return TVAR_NOTFOUND;
 945
 946         loopData = (LoopTemplateInstance)(tmpl->instanceData + *pOffset);
 947
 948         if ( loopData->type != LoopData )
 949                 return TVAR_FORBIDDEN;
 950         node = loopData->loopNode;
 951
 952         if ( node->nodeData.loop.selfNode == NULL )
 953                 return TVAR_FORBIDDEN;
 954
 955         if ( TListIsEmpty(loopData) )
 956                 return TVAR_NOROW;
 957
 958         if ( loopData->currentInstance == NULL )
 959                 return TVAR_NOROW;
 960
 961         GListForeach( cell, node->nodeData.loop.childrenLoop ) {
 962                 LoopTemplateInstance    childData = (LoopTemplateInstance)
 963                                 (tmpl->instanceData + ((TemplateNode)GLCELL_DATA(cell))->nodeData.loop.loopDataOffset);
 964
 965                 childData->lastRow = NULL;
 966         }
 967
 968         loopData->currentInstance = loopData->currentInstance->upperInstance;
 969         loopData->lastRow = NULL;
 970
 971         return TVAR_OK;
 972
 973 }
 974
 975 static VariableValueData storage;
 976
 977 static int
 978 setTemplateValue( TemplateInstance tmpl, char *key) {
 979         Offset                  *pOffset;
 980         VariableValue   varval;
 981         char                    *lkey = strlower(mcstrdup(tmpl->templateContext, key));
 982
 983         pOffset = SFSFindData(&tmpl->tmpl->variables, lkey, 0);
 984         mcfree(lkey);
 985
 986         if ( pOffset == NULL )
 987                 return TVAR_NOTFOUND;
 988
 989         varval = (VariableValue)(tmpl->instanceData + *pOffset);
 990
 991         if ( varval->type != 0 && varval->type < valueInt ) {
 992                 return TVAR_LOOPMARK;
 993         } else if ( varval->type == valuePointer ) {
 994                 /* looped variable */
 995                 varval = varval->value.ptrValue;
 996
 997                 if ( varval == NULL )
 998                         return TVAR_NOROW;
 999
1000                 tassert( (varval->flags & TND_GLOBAL) == 0 );
1001         }
1002
1003         if ( varval->flags & TND__SPECIALMASK )
1004                 return TVAR_FORBIDDEN;
1005
1006         if ( storage.flags & TND_DEFINED ) {
1007                 varval->flags |= TND_DEFINED;
1008                 varval->type = storage.type;
1009                 varval->value = storage.value;
1010         } else {
1011                 varval->flags &= ~TND_DEFINED;
1012         }
1013
1014         return TVAR_OK;
1015 }
1016
1017
1018 int
1019 setTemplateValueInt( TemplateInstance tmpl, char * key, int64_t val ) {
1020         storage.flags = TND_DEFINED;
1021         storage.type = valueInt;
1022         storage.value.intValue = val;
1023         return setTemplateValue( tmpl, key );
1024 }
1025
1026 int
1027 setTemplateValueString( TemplateInstance tmpl, char * key, char * val ) {
1028         storage.flags = TND_DEFINED;
1029         storage.type = valueString;
1030         storage.value.stringValue = val;
1031         return setTemplateValue( tmpl, key );
1032 }
1033
1034 int
1035 setTemplateValueTime( TemplateInstance tmpl, char * key, time_t val ) {
1036         storage.flags = TND_DEFINED;
1037         storage.type = valueTime;
1038         storage.value.timeValue = val;
1039         return setTemplateValue( tmpl, key );
1040 }
1041
1042 int
1043 setTemplateValueBool( TemplateInstance tmpl, char * key, int val ) {
1044         storage.flags = TND_DEFINED;
1045         storage.type = valueBool;
1046         storage.value.boolValue = val;
1047         return setTemplateValue( tmpl, key );
1048 }
1049
1050 int
1051 setTemplateValueDouble( TemplateInstance tmpl, char * key, double val ) {
1052         storage.flags = TND_DEFINED;
1053         storage.type = valueDouble;
1054         storage.value.doubleValue = val;
1055         return setTemplateValue( tmpl, key );
1056 }
1057
1058 int
1059 setTemplateValueUndefined( TemplateInstance tmpl, char * key ) {
1060         storage.flags = 0;
1061         return setTemplateValue( tmpl, key );
1062 }
1063
1064 /*
1065  * output routines
1066  */
1067
1068 static char *
1069 printVal( TemplateInstance tmpl, VariableValue value, int *len, char *format ) {
1070         int             printedlen;
1071         char    *res;
1072
1073         *len = 0;
1074
1075         if ( value->type == valueTime ) {
1076                 printedlen = 64;
1077                 res = mcalloc( tmpl->templateContext, printedlen+1 );
1078
1079                 while ( (printedlen = strftime(NULL, 0, (format) ? format : "%Y-%m-%d %H:%M:%S",
1080                                                                                                 localtime(&value->value.timeValue))) == 0 ) {
1081                         printedlen *= 2;
1082                         res=mcrealloc(res, printedlen);
1083                 }
1084
1085                 *len = printedlen;
1086                 return res;
1087         }
1088
1089         switch (value->type) {
1090                 case valueInt:
1091                         printedlen = snprintf(NULL, 0, (format) ? format : "%lld", value->value.intValue);
1092                         break;
1093                 case valueString:
1094                         if ( value->value.stringValue == NULL || *value->value.stringValue == '\0' )
1095                                 return NULL;
1096                         printedlen = snprintf(NULL, 0, (format) ? format : "%s", value->value.stringValue);
1097                         break;
1098                 case valueBool:
1099                         printedlen = snprintf(NULL, 0, "%s", (value->value.boolValue) ? "true" : "false" );
1100                         break;
1101                 case valueDouble:
1102                         printedlen = snprintf(NULL, 0, (format) ? format : "%f", value->value.doubleValue);
1103                         break;
1104                 case valuePointer:
1105                 case valueTime:
1106                 default:
1107                         return NULL;
1108         }
1109
1110         res = mcalloc( tmpl->templateContext, printedlen+1 );
1111
1112         switch (value->type) {
1113                 case valueInt:
1114                         printedlen = snprintf(res, printedlen+1, (format) ? format : "%lld", value->value.intValue);
1115                         break;
1116                 case valueString:
1117                         printedlen = snprintf(res, printedlen+1, (format) ? format : "%s", value->value.stringValue);
1118                         break;
1119                 case valueBool:
1120                         printedlen = snprintf(res, printedlen+1, "%s", (value->value.boolValue) ? "true" : "false" );
1121                         break;
1122                 case valueDouble:
1123                         printedlen = snprintf(res, printedlen+1, (format) ? format : "%f", value->value.doubleValue);
1124                         break;
1125                 case valuePointer:
1126                 case valueTime:
1127                 default:
1128                         return NULL;
1129         }
1130
1131         *len = printedlen;
1132
1133         return res;
1134 }
1135
1136
1137 static VariableValue
1138 executeExpression( TemplateInstance tmpl, TemplateNode node ) {
1139         VariableValue   outvalue = NULL;
1140         GListCell               *cell;
1141         int                             i = 0;
1142
1143
1144         switch (node->type) {
1145                 case ConstNode:
1146                         outvalue = &node->nodeData.value;
1147                         break;
1148                 case VariableNode:
1149                         outvalue = (VariableValue)(tmpl->instanceData + node->nodeData.variable.varValueOffset);
1150
1151                         tassert( (outvalue->flags & TND_DEFINED) == 0 || (outvalue->type >= valueInt && outvalue->type <= valuePointer) );
1152
1153                         if ( outvalue->type == valuePointer )
1154                                 outvalue = outvalue->value.ptrValue;
1155                         break;
1156                 case ExpressionNode:
1157                         GListForeach(cell, node->nodeData.expression.argsNode)
1158                                 node->nodeData.expression.argsValue[i++] =
1159                                         executeExpression( tmpl, (TemplateNode)GLCELL_DATA(cell) );
1160
1161                         outvalue = node->nodeData.expression.function->execFn(tmpl,
1162                                                                                                         node->nodeData.expression.nargs,
1163                                                                                                         node->nodeData.expression.argsValue);
1164                         break;
1165                 case TextNode:
1166                 case IncludeNode:
1167                 case LoopNode:
1168                 case ConditionNode:
1169                 case CollectionNode:
1170                 case PrintNode:
1171                 case NestNode:
1172                         tlog(TL_CRIT|TL_EXIT, "Unexpected node type: %d", node->type);
1173                         break;
1174                 default:
1175                         tlog(TL_CRIT|TL_EXIT, "Unknown node type: %d", node->type);
1176                         break;
1177         }
1178
1179         tassert( outvalue!=NULL );
1180
1181         return outvalue;
1182 }
1183
1184 static void
1185 printNode( TemplateInstance tmpl, TemplateNode node, LoopInstance loopInstance, int level ) {
1186         GListCell       *cell;
1187         VariableValue   value;
1188         int                             i;
1189
1190         if (!node)
1191                 return;
1192
1193         switch (node->type) {
1194                 case    LoopNode:
1195                         {
1196                                 LoopTemplateInstance    loopData = (LoopTemplateInstance)
1197                                                                                 (tmpl->instanceData + node->nodeData.loop.loopDataOffset);
1198                                 GListCell               *cell;
1199                                 LoopInstance    instance;
1200
1201                                 if ( loopInstance ) {
1202                                         instance = loopInstance;
1203                                 } else {
1204                                         TListShift( loopData, instance );
1205                                         if ( instance == NULL )
1206                                                 return;
1207                                 }
1208
1209                                 for(i=0; i<instance->nrow;i++) {
1210                                         LoopRow                 rowData;
1211                                         int                             j = 0;
1212                                         VariableValue   realValue;
1213
1214                                         TListShift( instance, rowData );
1215
1216                                         GListForeach( cell, node->nodeData.loop.listVarValues ) {
1217                                                 value = (VariableValue) (tmpl->instanceData + ((Offset)GLCELL_DATA(cell)));
1218
1219                                                 tassert( value->type == valuePointer );
1220                                                 realValue = value->value.ptrValue = rowData->varvals+j;
1221
1222                                                 if ( value->flags & TND___FIRST ) {
1223                                                         realValue->type = valueInt;
1224                                                         if ( i==0 ) {
1225                                                                 realValue->flags |= TND_DEFINED;
1226                                                                 realValue->value.intValue = 1;
1227                                                         }  else {
1228                                                                 realValue->flags &= ~TND_DEFINED;
1229                                                                 realValue->value.intValue = 0;
1230                                                         }
1231                                                 } else if ( value->flags & TND___LAST ) {
1232                                                         realValue->type = valueInt;
1233                                                         if ( i==instance->nrow - 1 ) {
1234                                                                 realValue->flags |= TND_DEFINED;
1235                                                                 realValue->value.intValue = 1;
1236                                                         }  else {
1237                                                                 realValue->flags &= ~TND_DEFINED;
1238                                                                 realValue->value.intValue = 0;
1239                                                         }
1240                                                 } else if ( value->flags & TND___COUNTER ) {
1241                                                         realValue->type = valueInt;
1242                                                         realValue->flags |= TND_DEFINED;
1243                                                         realValue->value.intValue = i+1;
1244                                                 } else if ( value->flags & TND___LEVEL ) {
1245                                                         realValue->type = valueInt;
1246                                                         realValue->flags |= TND_DEFINED;
1247                                                         realValue->value.intValue = level;
1248                                                 } else if ( value->flags & TND___SIZE ) {
1249                                                         realValue->type = valueInt;
1250                                                         realValue->flags |= TND_DEFINED;
1251                                                         realValue->value.intValue = instance->nrow;
1252                                                 } else if ( value->flags & TND___ODD ) {
1253                                                         realValue->type = valueBool;
1254                                                         realValue->flags |= TND_DEFINED;
1255                                                         realValue->value.boolValue = (i%2) ? 0 : 1 ;
1256                                                 } else if ( value->flags & TND___EVEN ) {
1257                                                         realValue->type = valueBool;
1258                                                         realValue->flags |= TND_DEFINED;
1259                                                         realValue->value.boolValue = (i%2) ? 1 : 0 ;
1260                                                 }
1261
1262                                                 j++;
1263                                         }
1264
1265                                         if ( node->nodeData.loop.selfNode )
1266                                                 node->nodeData.loop.selfNode->nodeData.nest.savedRowData = rowData;
1267
1268                                         printNode( tmpl, node->nodeData.loop.bodyNode, NULL, level );
1269                                 }
1270                         }
1271                         break;
1272                 case    NestNode:
1273                         if ( node->nodeData.nest.loop && node->nodeData.nest.savedRowData ) {
1274                                 LoopRow                 savedRowData = node->nodeData.nest.savedRowData; /* save current row */
1275                                 LoopInstance    *savedChildrenInstance = NULL;
1276
1277                                 /*
1278                                  *   Save child's instances for current loop
1279                                  */
1280                                 if ( GLIST_LENGTH(node->nodeData.nest.childrenLoopAfterSelf) ) {
1281                                         savedChildrenInstance = mcalloc(tmpl->templateContext, sizeof(LoopInstance) *
1282                                                                                                         GLIST_LENGTH(node->nodeData.nest.childrenLoopAfterSelf));
1283
1284                                         i=0;
1285                                         GListForeach( cell, node->nodeData.nest.childrenLoopAfterSelf) {
1286                                                 TemplateNode    chld = GLCELL_DATA(cell);
1287                                                 LoopTemplateInstance    loopData = (LoopTemplateInstance)
1288                                                                                                         (tmpl->instanceData + chld->nodeData.loop.loopDataOffset);
1289                                                 LoopInstance    cellInstance;
1290
1291                                                 TListShift( loopData, cellInstance );
1292
1293                                                 savedChildrenInstance[i++] = cellInstance;
1294                                         }
1295                                 }
1296
1297                                 printNode( tmpl, node->nodeData.nest.loop, savedRowData->nestedInstance, level+1 );
1298
1299                                 /*
1300                                  * Restore saved datas
1301                                  */
1302                                 i=0;
1303                                 GListForeach( cell, node->nodeData.nest.loop->nodeData.loop.listVarValues ) {
1304                                         value = (VariableValue) (tmpl->instanceData + ((Offset)GLCELL_DATA(cell)));
1305                                         value->value.ptrValue = savedRowData->varvals + i;
1306                                         i++;
1307                                 }
1308
1309                                 if ( GLIST_LENGTH(node->nodeData.nest.childrenLoopAfterSelf) ) {
1310                                         i=0;
1311                                         GListForeach( cell, node->nodeData.nest.childrenLoopAfterSelf) {
1312                                                 TemplateNode    chld = GLCELL_DATA(cell);
1313                                                 LoopTemplateInstance    loopData = (LoopTemplateInstance)
1314                                                                                                         (tmpl->instanceData + chld->nodeData.loop.loopDataOffset);
1315
1316                                                 if ( savedChildrenInstance[i] )
1317                                                         TListUnShift( loopData, savedChildrenInstance[i] );
1318                                                 i++;
1319                                         }
1320                                 }
1321                         }
1322                         break;
1323                 case    ConditionNode:
1324                         value = executeExpression( tmpl, node->nodeData.condition.expressionNode );
1325
1326                         if ( isVariable(value) )
1327                                 printNode( tmpl, node->nodeData.condition.ifNode, loopInstance, level );
1328                         else
1329                                 printNode( tmpl, node->nodeData.condition.elseNode, loopInstance, level );
1330                         break;
1331                 case    CollectionNode:
1332                         GListForeach( cell, node->nodeData.children )
1333                                 printNode( tmpl, (TemplateNode)GLCELL_DATA(cell), loopInstance, level );
1334                         break;
1335                 case    PrintNode:
1336                         value = executeExpression( tmpl, node->nodeData.condition.expressionNode );
1337
1338                         if ( value && (value->flags & TND_DEFINED) != 0 ) {
1339                                 int len;
1340                                 char *res;
1341
1342                                 res = printVal(tmpl, value, &len, node->nodeData.print.formatValue);
1343
1344                                 if ( (node->nodeData.variable.flags & TND_HTMLESCAPE) && tmpl->tmpl->htmlEscape )
1345                                         res = tmpl->tmpl->htmlEscape(res, &len);
1346                                 if ( (node->nodeData.variable.flags & TND_URLESCAPE) && tmpl->tmpl->urlEscape )
1347                                         res = tmpl->tmpl->urlEscape(res, &len);
1348
1349                                 if ( res && len>0  ) {
1350                                         tmpl->tmpl->printString( res, len );
1351                                         mcfree(res);
1352                                 }
1353                         } else if ( node->nodeData.print.defaultValue ) {
1354                                 tmpl->tmpl->printString( node->nodeData.print.defaultValue,
1355                                                                         strlen( node->nodeData.print.defaultValue ) );
1356                         }
1357                         break;
1358                 case    TextNode:
1359                         tmpl->tmpl->printString( node->nodeData.text.value,  node->nodeData.text.valueLength );
1360                         break;
1361                 case    IncludeNode:
1362                 case    VariableNode:
1363                 case    ConstNode:
1364                 case    ExpressionNode:
1365                         tlog(TL_CRIT|TL_EXIT, "Unexpected node type: %d", node->type);
1366                         break;
1367                 default:
1368                         tlog(TL_CRIT|TL_EXIT, "Unknown node type: %d", node->type);
1369                         break;
1370         }
1371 }
1372
1373 int
1374 printTemplate( TemplateInstance tmpl ) {
1375         if (!tmpl->tmpl->printString)
1376                 return 1;
1377
1378         printNode(tmpl, tmpl->tmpl->tree, NULL, 0);
1379
1380         return 0;
1381 }
1382
1383 static
1384 void printLevel(int level) {
1385         while(level-- > 0 )
1386                 fputs("  ", stdout);
1387 }
1388 static void
1389 recursiveDump(Template tmpl,  TemplateNode node, int level) {
1390         GListCell               *cell;
1391
1392         printLevel(level);
1393         if (node == NULL ) {
1394                 printf("VOID\n");
1395                 return;
1396         }
1397
1398         switch(node->type) {
1399                 case    IncludeNode:
1400                         printf("IncludeNode\n");
1401                         break;
1402                 case    LoopNode:
1403                         printf("LoopNode '%s'\n", node->nodeData.loop.varName);
1404                         recursiveDump(tmpl, node->nodeData.loop.bodyNode, level+1);
1405                         break;
1406                 case    ConditionNode:
1407                         printf("ConditionNode\n");
1408                         recursiveDump(tmpl, node->nodeData.condition.expressionNode, level+1);
1409                         recursiveDump(tmpl, node->nodeData.condition.ifNode, level+1);
1410                         recursiveDump(tmpl, node->nodeData.condition.elseNode, level+1);
1411                         break;
1412                 case    CollectionNode:
1413                         printf("CollectionNode\n");
1414                         GListForeach(cell, node->nodeData.children)
1415                                 recursiveDump(tmpl, (TemplateNode)GLCELL_DATA(cell), level+1);
1416                         break;
1417                 case    TextNode:
1418                         printf("TextNode len:%d\n", node->nodeData.text.valueLength);
1419                         break;
1420                 case    VariableNode:
1421                         printf("VariableNode '%s'\n", node->nodeData.variable.varName);
1422                         break;
1423                 case    ExpressionNode:
1424                         printf("ExpressionNode '%s'\n", node->nodeData.expression.functionName);
1425                         GListForeach(cell, node->nodeData.expression.argsNode)
1426                                 recursiveDump( tmpl, GLCELL_DATA(cell) ,level + 1);
1427                         break;
1428                 case    PrintNode:
1429                         printf("PrintNode\n");
1430                         recursiveDump( tmpl, node->nodeData.print.expressionNode, level + 1 );
1431                         break;
1432                 case    ConstNode:
1433                         printf("ConstNode\n");
1434                         break;
1435                 case    NestNode:
1436                         printf("NestNode\n");
1437                         break;
1438                 default:
1439                         tlog(TL_CRIT|TL_EXIT, "unknown node type: %d", node->type);
1440         }
1441 }
1442
1443 void
1444 dumpTemplate( Template tmpl ) {
1445         recursiveDump(tmpl, tmpl->tree, 0);
1446 }