html-template-pro 0.0.1

data/ext/html/template/internal/expr_iface.c

@@ -0,0 +1,94 @@
+/* 
+ * File: expr_iface.c
+ * Author: Igor Vlasenko <vlasenko@imath.kiev.ua>
+ * Created: Sat Apr 15 21:15:24 2006
+ */
+
+#include <string.h>
+#include "tmplpro.h"
+#include "exprval.h"
+#include "pparam.h"
+
+API_IMPL 
+void 
+APICALL
+tmplpro_set_expr_as_int64 (struct exprval* p,EXPR_int64 ival) {
+  p->type=EXPR_TYPE_INT;
+  p->val.intval=ival;
+}
+
+API_IMPL 
+void 
+APICALL
+tmplpro_set_expr_as_double (struct exprval* p,double dval) {
+  p->type=EXPR_TYPE_DBL;
+  p->val.dblval=dval;
+}
+
+API_IMPL 
+void 
+APICALL
+tmplpro_set_expr_as_string (struct exprval* p, const char* sval) {
+  p->type=EXPR_TYPE_PSTR;
+  p->val.strval.begin=sval;
+  p->val.strval.endnext=sval;
+  if (NULL!=sval) p->val.strval.endnext+=strlen(sval);
+}
+
+API_IMPL 
+void 
+APICALL
+tmplpro_set_expr_as_pstring (struct exprval* p,PSTRING pval) {
+  p->type=EXPR_TYPE_PSTR;
+  p->val.strval=pval;
+}
+
+API_IMPL 
+void 
+APICALL
+tmplpro_set_expr_as_null (struct exprval* p) {
+  p->type=EXPR_TYPE_PSTR;
+  p->val.strval.begin=NULL;
+  p->val.strval.endnext=NULL;
+}
+
+API_IMPL 
+int
+APICALL
+tmplpro_get_expr_type (struct exprval* p) {
+  if (p->type == EXPR_TYPE_PSTR) {
+    if (NULL==p->val.strval.begin) {
+      p->val.strval.endnext=NULL;
+      p->type = EXPR_TYPE_NULL;
+    } else if (NULL==p->val.strval.endnext) {
+      /* should never happen */
+      p->val.strval.endnext=p->val.strval.begin+strlen(p->val.strval.begin);
+    }
+  /* never happen; but let it be for future compatibility */
+  } else if (p->type == EXPR_TYPE_NULL) {
+      p->val.strval.begin=NULL;
+      p->val.strval.endnext=NULL;
+  }
+  return (int) p->type;
+}
+
+API_IMPL 
+EXPR_int64 
+APICALL
+tmplpro_get_expr_as_int64 (struct exprval* p) {
+  return p->val.intval;
+}
+
+API_IMPL 
+double
+APICALL
+tmplpro_get_expr_as_double (struct exprval* p) {
+  return p->val.dblval;
+}
+
+API_IMPL 
+PSTRING
+APICALL
+tmplpro_get_expr_as_pstring (struct exprval* p) {
+  return p->val.strval;
+}

data/ext/html/template/internal/exprpstr.h

@@ -0,0 +1,36 @@
+/* -*- c -*- 
+ * File: pstring.h
+ * Author: Igor Vlasenko <vlasenko@imath.kiev.ua>
+ * Created: Fri Jul  1 20:11:51 2005
+ *
+ * $Id$
+ */
+
+#ifndef _EXPR_TYPE_PSTR_H
+#define _EXPR_TYPE_PSTR_H	1
+
+#include "exprval.h"
+
+static
+PSTRING double_to_pstring (double, char* buf, size_t bufsize);
+static
+PSTRING int_to_pstring (EXPR_int64, char* buf, size_t bufsize);
+static
+int pstring_ge(PSTRING, PSTRING);
+static
+int pstring_le(PSTRING, PSTRING);
+static
+int pstring_ne(PSTRING, PSTRING);
+static
+int pstring_eq(PSTRING, PSTRING);
+static
+int pstring_gt(PSTRING, PSTRING);
+static
+int pstring_lt(PSTRING, PSTRING);
+
+static
+int re_like(PSTRING, PSTRING);
+static
+int re_notlike(PSTRING, PSTRING);
+
+#endif /* exprpstr.h */

data/ext/html/template/internal/exprpstr.inc

@@ -0,0 +1,144 @@
+/* -*- c -*- 
+ * File: pstring.h
+ * Author: Igor Vlasenko <vlasenko@imath.kiev.ua>
+ * Created: Fri Jul  1 20:11:51 2005
+ *
+ * $Id$
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdio.h>
+#include <string.h>
+#include "pstring.h"
+#include "tmpllog.h"
+#include "exprval.h"
+#include "pmiscdef.h" /*for snprintf */
+
+static
+PSTRING 
+double_to_pstring (double number, char buffer[], size_t bufsize) {
+  size_t len=0;
+  size_t tmplen=0;
+  PSTRING retval;
+  snprintf(buffer,bufsize,"%f",number);
+  len=strlen(buffer);
+  tmplen=len;
+  /* removing trailing 0 as 2.00000... */
+  while (buffer[tmplen-1]=='0' && tmplen-->0); 
+  if (buffer[tmplen-1]=='.') {
+    tmplen--;
+    len=tmplen;
+  }
+  retval.begin=buffer;
+  retval.endnext=buffer+len;
+  return retval;
+}
+
+static
+PSTRING 
+int_to_pstring (EXPR_int64 number, char buffer[], size_t bufsize) {
+  size_t len=0;
+  PSTRING retval;
+  snprintf(buffer, bufsize,"%" EXPR_PRId64 , number);
+  len=strlen(buffer);
+  retval.begin=buffer;
+  retval.endnext=buffer+len;
+  return retval;
+}
+
+static
+int 
+pstring_ge(PSTRING a, PSTRING b) {
+  const char* in_a=a.begin;
+  const char* in_b=b.begin;
+  while (in_a<a.endnext && in_b < b.endnext && *in_a++==*in_b++);
+  if ((in_a==a.endnext && in_b==b.endnext) || *(--in_a) >= *(--in_b) ) return 1; else return 0;
+}
+
+static
+int 
+pstring_le(PSTRING a, PSTRING b) {
+  const char* in_a=a.begin;
+  const char* in_b=b.begin;
+  while (in_a<a.endnext && in_b < b.endnext && *in_a++==*in_b++);
+  if ((in_a==a.endnext && in_b==b.endnext) || *(--in_a) <= *(--in_b) ) return 1; else return 0;
+}
+
+static
+int 
+pstring_ne(PSTRING a, PSTRING b) {
+  const char* in_a=a.begin;
+  const char* in_b=b.begin;
+  while (in_a<a.endnext && in_b < b.endnext && *in_a++==*in_b++);
+  if (in_a==a.endnext && in_b==b.endnext && *(--in_a) == *(--in_b)) return 0; else return 1;
+}
+
+static
+int 
+pstring_eq(PSTRING a, PSTRING b) {
+  const char* in_a=a.begin;
+  const char* in_b=b.begin;
+  while (in_a<a.endnext && in_b < b.endnext && *in_a++==*in_b++);
+  if (in_a==a.endnext && in_b==b.endnext && *(--in_a) == *(--in_b)) return 1; else return 0;
+}
+
+static
+int 
+pstring_gt(PSTRING a, PSTRING b) {
+  const char* in_a=a.begin;
+  const char* in_b=b.begin;
+  while (in_a<a.endnext && in_b < b.endnext && *in_a++==*in_b++);
+  if ((in_b==b.endnext && in_a!=a.endnext)
+      || (*(--in_a) > *(--in_b)) ) return 1; else return 0;
+}
+
+static
+int 
+pstring_lt(PSTRING a, PSTRING b) {
+  const char* in_a=a.begin;
+  const char* in_b=b.begin;
+  while (in_a<a.endnext && in_b < b.endnext && *in_a++==*in_b++);
+  if ((in_b!=b.endnext && in_a==a.endnext)
+      ||  *(--in_a) < *(--in_b) ) return 1; else return 0;
+}
+
+static
+int 
+re_notlike(PSTRING a, PSTRING b) {
+  return ! re_like(a,b);
+}
+
+#ifndef HAVE_PCRE
+static
+int 
+re_like(PSTRING a, PSTRING b) {
+    tmpl_log(TMPL_LOG_ERROR," (sorry, Stanislav Yadykin regexp extension is disabled at compile time) \n");
+  return 0;
+}
+#else
+#include <pcre.h>
+static
+int 
+re_like(PSTRING a, PSTRING b) {
+  pcre* re;
+  int ovector[30];
+  int rc, erroffset;
+  const char* error;
+  const char* subject=a.begin;
+  int subject_length=(int)(a.endnext-a.begin);
+  char* pattern=(char*)malloc(b.endnext-b.begin);
+  strncpy(pattern, b.begin, (b.endnext-b.begin));
+  *(pattern+(b.endnext-b.begin))=0;
+  re = pcre_compile(pattern, 0, &error, &erroffset, NULL); /* default character set */
+  free(pattern);
+  if (re==NULL) {
+    tmpl_log(TMPL_LOG_ERROR, "PCRE compilation failed at offset %d: %s\n",
+      erroffset, error);
+    return 0;
+  }
+  rc=pcre_exec(re, NULL, subject, subject_length, 0, 0, ovector, 30);
+  return (rc<0)?0:1;
+}
+#endif

data/ext/html/template/internal/exprtool.h

@@ -0,0 +1,99 @@
+/* -*- c -*- 
+ * File: exprtool.h
+ * Author: Igor Vlasenko <vlasenko@imath.kiev.ua>
+ * Created: Mon Jul 25 15:29:04 2005
+ *
+ * $Id$
+ */
+
+#ifndef _EXPRTOOL_H
+#define _EXPRTOOL_H	1
+
+#include "pstring.h"
+#include "exprval.h"
+
+struct expr_parser {
+  struct tmplpro_state* state;
+  PSTRING exprarea;
+  const char* expr_curpos;
+  /* for callbacks */
+  struct exprval userfunc_call;
+  /* 
+   * is_expect_quote_like allows recognization of quotelike.
+   * if not is_expect_quote_like we look only for 'str' and, possibly, "str"
+   * if is_expect_quote_like we also look for /str/.
+   */
+  int is_expect_quote_like;
+};
+
+#define DO_MATHOP(exprobj, z,op,x,y) switch (z.type=expr_to_int_or_dbl(exprobj, &x,&y)) { \
+case EXPR_TYPE_INT: z.val.intval=x.val.intval op y.val.intval;break; \
+case EXPR_TYPE_DBL: z.val.dblval=x.val.dblval op y.val.dblval;break; \
+}
+
+#define DO_LOGOP(exprobj, z,op,x,y) z.type=EXPR_TYPE_INT; switch (expr_to_int_or_dbl_logop(exprobj, &x,&y)) { \
+case EXPR_TYPE_INT: z.val.intval=x.val.intval op y.val.intval;break; \
+case EXPR_TYPE_DBL: z.val.intval=x.val.dblval op y.val.dblval;break; \
+}
+
+#define DO_LOGOP1(exprobj,z,op,x) z.type=EXPR_TYPE_INT; switch (expr_to_int_or_dbl_logop1(exprobj, &x)) { \
+case EXPR_TYPE_INT: z.val.intval= op x.val.intval;break; \
+case EXPR_TYPE_DBL: z.val.intval= op x.val.dblval;break; \
+}
+
+#define DO_CMPOP(exprobj, z,op,x,y) switch (expr_to_int_or_dbl(exprobj, &x,&y)) { \
+case EXPR_TYPE_INT: z.val.intval=x.val.intval op y.val.intval;break; \
+case EXPR_TYPE_DBL: z.val.intval=x.val.dblval op y.val.dblval;break; \
+}; z.type=EXPR_TYPE_INT;
+
+#define DO_TXTOP(z,op,x,y,buf) expr_to_str(buf, &x,&y); z.type=EXPR_TYPE_INT; z.val.intval = op (x.val.strval,y.val.strval);
+
+static
+EXPR_char expr_to_int_or_dbl (struct expr_parser* exprobj, struct exprval* val1, struct exprval* val2);
+static
+EXPR_char expr_to_int_or_dbl1 (struct expr_parser* exprobj, struct exprval* val1);
+static
+EXPR_char expr_to_int_or_dbl_logop (struct expr_parser* exprobj, struct exprval* val1, struct exprval* val2);
+static
+EXPR_char expr_to_int_or_dbl_logop1 (struct expr_parser* exprobj, struct exprval* val1);
+static
+void expr_to_dbl (struct expr_parser* exprobj, struct exprval* val1, struct exprval* val2);
+static
+void expr_to_int (struct expr_parser* exprobj, struct exprval* val1, struct exprval* val2);
+static
+void expr_to_dbl1 (struct expr_parser* exprobj, struct exprval* val);
+static
+void expr_to_int1 (struct expr_parser* exprobj, struct exprval* val1);
+static
+void expr_to_str (struct tmplpro_state* state, struct exprval* val1, struct exprval* val2);
+static
+void expr_to_str1 (struct tmplpro_state* state, struct exprval* val1);
+static
+void expr_to_num (struct expr_parser* exprobj, struct exprval* val1);
+static
+void expr_to_bool (struct expr_parser* exprobj, struct exprval* val1);
+static
+struct exprval exp_read_number (struct expr_parser* exprobj, const char* *curposptr, const char* endchars);
+
+/* this stuff is defined or used in expr.y */
+static
+void log_expr(struct expr_parser* exprobj, int loglevel, const char* fmt, ...) FORMAT_PRINTF(3,4);
+
+static
+PSTRING expr_unescape_pstring_val(pbuffer* pbuff, PSTRING val);
+
+static
+void _tmplpro_expnum_debug (struct exprval val, char* msg);
+
+
+struct user_func_call {
+  ABSTRACT_USERFUNC* func;  /* for user-defined function name */
+  ABSTRACT_ARGLIST* arglist;
+};
+
+static
+struct exprval call_expr_userfunc(struct expr_parser* exprobj, struct tmplpro_param* param, struct user_func_call extfunc);
+static
+void pusharg_expr_userfunc(struct expr_parser* exprobj, struct tmplpro_param* param, struct user_func_call extfunc, struct exprval arg);
+
+#endif /* exprtool.h */

data/ext/html/template/internal/exprtool.inc

@@ -0,0 +1,289 @@
+/* -*- c -*- 
+ * File: exprtool.c
+ * Author: Igor Vlasenko <vlasenko@imath.kiev.ua>
+ * Created: Mon Jul 25 15:29:17 2005
+ *
+ * $Id$
+ */
+
+/*
+#include "exprtool.h"
+#include <ctype.h> // for yylex alnum
+#include <stdio.h> // for printf
+*/
+
+#define EXPR_CHECK_NUMBER(exprobj, ptr)   switch (ptr->type) {	\
+  case EXPR_TYPE_INT: case EXPR_TYPE_DBL: break; \
+  case EXPR_TYPE_UPSTR: case EXPR_TYPE_PSTR: expr_to_num(exprobj, ptr); break;	\
+  default: _tmplpro_expnum_debug(*ptr, "FATAL:internal expr type error. please report\n"); \
+  ptr->type = EXPR_TYPE_INT; \
+}
+
+#define EXPR_CHECK_LOGICAL(exprobj, ptr)   switch (ptr->type) {	\
+  case EXPR_TYPE_INT: case EXPR_TYPE_DBL: break; \
+  case EXPR_TYPE_UPSTR: case EXPR_TYPE_PSTR: expr_to_bool(exprobj, ptr); break;		\
+  default: _tmplpro_expnum_debug(*ptr, "FATAL:internal expr type error. please report\n"); \
+  ptr->type = EXPR_TYPE_INT; \
+}
+
+static
+EXPR_char 
+expr_to_int_or_dbl (struct expr_parser* exprobj, struct exprval* val1, struct exprval* val2) {
+  EXPR_CHECK_NUMBER(exprobj, val1);
+  EXPR_CHECK_NUMBER(exprobj, val2);
+  if ((val1->type == EXPR_TYPE_INT) && (val2->type == EXPR_TYPE_INT))
+    return EXPR_TYPE_INT;
+  if ((val1->type == EXPR_TYPE_DBL) && (val2->type == EXPR_TYPE_DBL))
+    return EXPR_TYPE_DBL;
+  if (val1->type == EXPR_TYPE_INT) {
+    val1->type=EXPR_TYPE_DBL;
+    val1->val.dblval=(double) val1->val.intval;
+  }
+  if (val2->type == EXPR_TYPE_INT) {
+    val1->type=EXPR_TYPE_DBL;
+    val2->val.dblval=(double) val2->val.intval;
+  }
+  return EXPR_TYPE_DBL;
+}
+
+static
+EXPR_char 
+expr_to_int_or_dbl_logop (struct expr_parser* exprobj, struct exprval* val1, struct exprval* val2) {
+  EXPR_CHECK_LOGICAL(exprobj, val1);
+  EXPR_CHECK_LOGICAL(exprobj, val2);
+  if (val1->type == EXPR_TYPE_INT && val2->type == EXPR_TYPE_INT)
+    return EXPR_TYPE_INT;
+  if (val1->type == EXPR_TYPE_DBL && val2->type == EXPR_TYPE_DBL)
+    return EXPR_TYPE_DBL;
+  if (val1->type == EXPR_TYPE_INT) {
+    val1->type=EXPR_TYPE_DBL;
+    val1->val.dblval=(double) val1->val.intval;
+  }
+  if (val2->type == EXPR_TYPE_INT) {
+    val1->type=EXPR_TYPE_DBL;
+    val2->val.dblval=(double) val2->val.intval;
+  }
+  return EXPR_TYPE_DBL;
+}
+
+static
+EXPR_char 
+expr_to_int_or_dbl_logop1 (struct expr_parser* exprobj, struct exprval* val1) {
+  EXPR_CHECK_LOGICAL(exprobj, val1);
+  return val1->type;
+}
+
+static
+EXPR_char 
+expr_to_int_or_dbl1 (struct expr_parser* exprobj, struct exprval* val1) {
+  EXPR_CHECK_NUMBER(exprobj, val1);
+  return val1->type;
+}
+
+static
+void 
+expr_to_dbl1 (struct expr_parser* exprobj, struct exprval* val1) {
+  EXPR_CHECK_NUMBER(exprobj, val1);
+  if (val1->type == EXPR_TYPE_INT) {
+    val1->type=EXPR_TYPE_DBL;
+    val1->val.dblval=(double) val1->val.intval;
+  }
+}
+
+static
+void 
+expr_to_int1 (struct expr_parser* exprobj, struct exprval* val1) {
+  EXPR_CHECK_NUMBER(exprobj, val1);
+  if (val1->type == EXPR_TYPE_DBL) {
+    val1->type=EXPR_TYPE_INT;
+    val1->val.intval=(EXPR_int64) val1->val.dblval;
+    /* _tmplpro_expnum_debug(*val1, "WARN:converting to `int' from `double'"); */
+  }
+}
+
+static
+void 
+expr_to_dbl (struct expr_parser* exprobj, struct exprval* val1, struct exprval* val2) {
+  expr_to_dbl1(exprobj, val1);
+  expr_to_dbl1(exprobj, val2);
+}
+
+static
+void 
+expr_to_int (struct expr_parser* exprobj, struct exprval* val1, struct exprval* val2) {
+  expr_to_int1(exprobj, val1);
+  expr_to_int1(exprobj, val2);
+}
+
+#define EXPR_CHECK_STRING(pbuff, ptr)   switch (ptr->type) {	\
+  case EXPR_TYPE_PSTR: break; \
+  case EXPR_TYPE_UPSTR: ptr->val.strval=expr_unescape_pstring_val(pbuff,ptr->val.strval); break; \
+  case EXPR_TYPE_INT: ptr->val.strval=int_to_pstring(ptr->val.intval,pbuffer_string(pbuff),pbuffer_size(pbuff)); break; \
+  case EXPR_TYPE_DBL: ptr->val.strval=double_to_pstring(ptr->val.dblval,pbuffer_string(pbuff),pbuffer_size(pbuff)); break; \
+  default: _tmplpro_expnum_debug(*ptr, "FATAL:internal expr string error. please report\n"); \
+  } \
+  ptr->type = EXPR_TYPE_PSTR;
+
+static
+void 
+expr_to_str (struct tmplpro_state* state, struct exprval* val1, struct exprval* val2) {
+  EXPR_CHECK_STRING(&(state->expr_left_pbuffer), val1);
+  EXPR_CHECK_STRING(&(state->expr_right_pbuffer), val2);
+}
+
+static
+void 
+expr_to_str1 (struct tmplpro_state* state, struct exprval* val1) {
+  EXPR_CHECK_STRING(&(state->expr_left_pbuffer), val1);
+}
+
+static
+int 
+is_float_lex (char c)
+{
+  return (c == '.' || isdigit (c));
+}
+
+static
+struct exprval 
+exp_read_number (struct expr_parser* exprobj, const char* *curposptr, const char* endchars) {
+  char c = **curposptr;
+  struct exprval retval;
+  EXPR_int64 iretval=0;
+  double dretval=0;
+  EXPR_int64 offset=0;
+  int sign=1;
+  retval.type=EXPR_TYPE_INT;
+  retval.val.intval=0;
+  if ((*curposptr)<endchars && '-' == c) {
+    sign=-1;
+    c = *(++(*curposptr));
+  }
+  if (! (c == '.' || isdigit (c))) return retval;
+  /* double reader
+     yylval.dblval=atof(fill_symbuf(is_float_lex).begin);
+     return dblNUM;
+  */
+  while ((*curposptr)<endchars && is_float_lex(c)) {
+    if (c == '.') {
+      if (retval.type == EXPR_TYPE_INT) {
+	retval.type = EXPR_TYPE_DBL;
+	dretval=iretval;
+	offset=1;
+      } else {
+	/* (*curposptr)--; ??? */
+	log_expr(exprobj, TMPL_LOG_ERROR, "while reading number: %s\n", "uninspected declimal point");
+	retval.val.dblval=dretval*sign;
+	retval.type=EXPR_TYPE_DBL;
+	return retval;
+      }
+    } else {
+      offset*=10;
+      if (retval.type == EXPR_TYPE_INT) {
+	iretval=iretval*10+c-'0';
+      } else {
+	dretval=dretval*10+c-'0';
+      }
+    }
+    c = *(++(*curposptr));
+  }
+  if (retval.type == EXPR_TYPE_INT) {
+    retval.val.intval=iretval*sign;
+  } else {
+    if (offset) dretval/=offset;
+    retval.val.dblval=dretval*sign;
+  }
+  return retval;
+}
+
+static
+void 
+expr_to_num (struct expr_parser* exprobj, struct exprval* val1)
+{
+  const char* curpos=val1->val.strval.begin;
+  EXPR_char type = val1->type;
+  if (type == EXPR_TYPE_PSTR || type == EXPR_TYPE_UPSTR) {
+    if (NULL==curpos) {
+      val1->type = EXPR_TYPE_INT;
+      val1->val.intval = 0;
+    } else {
+      /* escaped string can't be read properly anyway */
+      *val1=exp_read_number (exprobj, &curpos, val1->val.strval.endnext);
+    }
+  }
+}
+
+static
+void 
+expr_to_bool (struct expr_parser* exprobj, struct exprval* val1)
+{
+  if (val1->type == EXPR_TYPE_PSTR || val1->type == EXPR_TYPE_UPSTR) {
+    const char* begin=val1->val.strval.begin;
+    const char* end=val1->val.strval.endnext;
+    const char* curpos=begin;
+    if (begin==end) {
+      val1->type = EXPR_TYPE_INT;
+      val1->val.intval = 0;
+    } else {
+      *val1=exp_read_number (exprobj, &curpos, end);
+      if (val1->type == EXPR_TYPE_INT) {
+	if (val1->val.intval || (curpos == end)) return;
+	else val1->val.intval=1; /* strings are true in perl */
+      }
+      else
+	if (val1->type == EXPR_TYPE_DBL) {
+	  if (val1->val.dblval || (curpos == end)) return;
+	  else val1->val.dblval=1.0; /* strings are true in perl */
+	}
+    }
+  }
+}
+
+static
+void 
+_tmplpro_expnum_debug (struct exprval val, char* msg) 
+{
+  tmpl_log(TMPL_LOG_DEBUG,"--> debug %s:type %c ",msg,val.type);
+  if (val.type == EXPR_TYPE_INT)
+    tmpl_log(TMPL_LOG_DEBUG,"ival=%" EXPR_PRId64 "\n",val.val.intval);
+  else if (val.type == EXPR_TYPE_DBL)
+    tmpl_log(TMPL_LOG_DEBUG,"dval=%f\n",val.val.dblval);
+  else if (val.type == EXPR_TYPE_PSTR) {
+    tmpl_log(TMPL_LOG_DEBUG,"pstr(%c):",(int) val.type);
+    if (NULL==val.val.strval.begin) tmpl_log(TMPL_LOG_DEBUG,"{begin=NULL}");
+    if (NULL==val.val.strval.endnext) tmpl_log(TMPL_LOG_DEBUG,"{endnext=NULL}");
+    tmpl_log(TMPL_LOG_DEBUG,"sval=%.*s\n",(int)(val.val.strval.endnext-val.val.strval.begin),val.val.strval.begin);
+  } else if (val.type == EXPR_TYPE_NULL) {
+    tmpl_log(TMPL_LOG_DEBUG,"NULL\n");
+    if (NULL!=val.val.strval.begin) tmpl_log(TMPL_LOG_DEBUG,"{begin!=NULL}");
+    if (NULL!=val.val.strval.endnext) tmpl_log(TMPL_LOG_DEBUG,"{endnext!=NULL}");
+  } else {
+    tmpl_log(TMPL_LOG_DEBUG,"unknown(%c) as ival=%" EXPR_PRId64 "\n",(int) val.type,val.val.intval);
+  }
+}
+
+/* 
+ * checks if it is stringval and unescape it (copies to the buffer).
+ * it implies that only one string at a time can use buffer.
+ */
+static
+PSTRING
+expr_unescape_pstring_val(pbuffer* pbuff, PSTRING val) {
+  PSTRING retval;
+    const char* curpos = val.begin;
+    const char* endnext= val.endnext;
+    char* buf=pbuffer_resize(pbuff, endnext-curpos+1);
+    char* bufpos = buf;
+    while (curpos < endnext) {
+      if (*curpos == '\\') {
+	*bufpos=*(++curpos);
+      } else {
+	*bufpos=*curpos;
+      }
+      curpos++;
+      bufpos++;
+    }
+    retval.begin = buf;
+    retval.endnext = bufpos;
+    return retval;
+}