html-template-pro 0.0.1

data/Manifest.txt

@@ -0,0 +1,221 @@
+.autotest
+ARTISTIC
+History.txt
+LGPL
+Manifest.txt
+README.rdoc
+Rakefile
+benchmark.rb
+config/website.yml
+ext/html/template/internal/Pro.xs
+ext/html/template/internal/builtin_findfile.inc
+ext/html/template/internal/calc.h
+ext/html/template/internal/calc.inc
+ext/html/template/internal/callback_stubs.inc
+ext/html/template/internal/expr.c
+ext/html/template/internal/expr.y
+ext/html/template/internal/expr_iface.c
+ext/html/template/internal/exprpstr.h
+ext/html/template/internal/exprpstr.inc
+ext/html/template/internal/exprtool.h
+ext/html/template/internal/exprtool.inc
+ext/html/template/internal/exprtype.h
+ext/html/template/internal/exprval.h
+ext/html/template/internal/extconf.rb
+ext/html/template/internal/internal.c
+ext/html/template/internal/loadfile.h
+ext/html/template/internal/loadfile.inc
+ext/html/template/internal/pabidecl.h
+ext/html/template/internal/pabstract.h
+ext/html/template/internal/parse_expr.h
+ext/html/template/internal/pbuffer.c
+ext/html/template/internal/pbuffer.h
+ext/html/template/internal/pmiscdef.h
+ext/html/template/internal/pparam.h
+ext/html/template/internal/ppport.h
+ext/html/template/internal/procore.c
+ext/html/template/internal/procore.h
+ext/html/template/internal/proparam.c
+ext/html/template/internal/proparam.h
+ext/html/template/internal/proscope.h
+ext/html/template/internal/proscope.inc
+ext/html/template/internal/prostate.h
+ext/html/template/internal/prostate.inc
+ext/html/template/internal/provalue.h
+ext/html/template/internal/pstring.h
+ext/html/template/internal/pstrutils.h
+ext/html/template/internal/pstrutils.inc
+ext/html/template/internal/tagstack.h
+ext/html/template/internal/tagstack.inc
+ext/html/template/internal/tmpllog.c
+ext/html/template/internal/tmpllog.h
+ext/html/template/internal/tmplpro.h
+ext/html/template/internal/tmplpro_version.c
+lib/html/template/pro.rb
+script/console
+script/destroy
+script/generate
+script/txt2html
+tasks/extconf.rake
+tasks/extconf/tmplpro.rake
+templates-Pro/a.incl
+templates-Pro/empty.incl
+templates-Pro/include/1/a.incl
+templates-Pro/include/2.out
+templates-Pro/include/2.tmpl
+templates-Pro/include/2/a.incl
+templates-Pro/include/3.tmpl
+templates-Pro/include/4.tmpl
+templates-Pro/include/a.incl
+templates-Pro/test_broken.tmpl
+templates-Pro/test_broken1.out
+templates-Pro/test_broken1.tmpl
+templates-Pro/test_esc1.out
+templates-Pro/test_esc1.tmpl
+templates-Pro/test_esc2.out
+templates-Pro/test_esc2.tmpl
+templates-Pro/test_esc3.out
+templates-Pro/test_esc3.tmpl
+templates-Pro/test_esc4.out
+templates-Pro/test_esc4.tmpl
+templates-Pro/test_expr1.out
+templates-Pro/test_expr1.tmpl
+templates-Pro/test_expr2.out
+templates-Pro/test_expr2.tmpl
+templates-Pro/test_expr3.out
+templates-Pro/test_expr3.tmpl
+templates-Pro/test_expr4.out
+templates-Pro/test_expr4.tmpl
+templates-Pro/test_expr5.out
+templates-Pro/test_expr5.tmpl
+templates-Pro/test_expr6.out
+templates-Pro/test_expr6.tmpl
+templates-Pro/test_expr7.out
+templates-Pro/test_expr7.tmpl
+templates-Pro/test_expr8.out
+templates-Pro/test_expr8.tmpl
+templates-Pro/test_if1.out
+templates-Pro/test_if1.tmpl
+templates-Pro/test_if2.out
+templates-Pro/test_if2.tmpl
+templates-Pro/test_if3.out
+templates-Pro/test_if3.tmpl
+templates-Pro/test_if4.out
+templates-Pro/test_if4.tmpl
+templates-Pro/test_if5.out
+templates-Pro/test_if5.tmpl
+templates-Pro/test_if6.out
+templates-Pro/test_if6.tmpl
+templates-Pro/test_if7.out
+templates-Pro/test_if7.tmpl
+templates-Pro/test_include1.out
+templates-Pro/test_include1.tmpl
+templates-Pro/test_include2.out
+templates-Pro/test_include2.tmpl
+templates-Pro/test_include3.out
+templates-Pro/test_include3.tmpl
+templates-Pro/test_include4.out
+templates-Pro/test_include4.tmpl
+templates-Pro/test_include5.out
+templates-Pro/test_include5.tmpl
+templates-Pro/test_loop1.erb
+templates-Pro/test_loop1.out
+templates-Pro/test_loop1.tmpl
+templates-Pro/test_loop2.erb
+templates-Pro/test_loop2.out
+templates-Pro/test_loop2.tmpl
+templates-Pro/test_loop3.out
+templates-Pro/test_loop3.tmpl
+templates-Pro/test_loop4.out
+templates-Pro/test_loop4.tmpl
+templates-Pro/test_loop5.out
+templates-Pro/test_loop5.tmpl
+templates-Pro/test_loop6.out
+templates-Pro/test_loop6.tmpl
+templates-Pro/test_malloc.tmpl
+templates-Pro/test_userfunc1.out
+templates-Pro/test_userfunc1.tmpl
+templates-Pro/test_userfunc2.out
+templates-Pro/test_userfunc2.tmpl
+templates-Pro/test_userfunc3.out
+templates-Pro/test_userfunc3.tmpl
+templates-Pro/test_userfunc4.out
+templates-Pro/test_userfunc4.tmpl
+templates-Pro/test_userfunc5.out
+templates-Pro/test_userfunc5.tmpl
+templates-Pro/test_userfunc6.out
+templates-Pro/test_userfunc6.tmpl
+templates-Pro/test_var1.erb
+templates-Pro/test_var1.out
+templates-Pro/test_var1.tmpl
+templates-Pro/test_var2.erb
+templates-Pro/test_var2.out
+templates-Pro/test_var2.tmpl
+templates-Pro/test_var3.out
+templates-Pro/test_var3.tmpl
+templates/case_loop.tmpl
+templates/context.tmpl
+templates/counter.tmpl
+templates/default.tmpl
+templates/default_escape.tmpl
+templates/double_loop.tmpl
+templates/escape.tmpl
+templates/global-loops.tmpl
+templates/globals.tmpl
+templates/if.tmpl
+templates/ifelse.tmpl
+templates/include.tmpl
+templates/include_path/a.tmpl
+templates/include_path/b.tmpl
+templates/include_path/inner.tmpl
+templates/include_path/one.tmpl
+templates/include_path2/inner.tmpl
+templates/included.tmpl
+templates/included2.tmpl
+templates/js.tmpl
+templates/long_loops.tmpl
+templates/loop-context.tmpl
+templates/loop-if.tmpl
+templates/medium.tmpl
+templates/multiline_tags.tmpl
+templates/newline_test1.tmpl
+templates/newline_test2.tmpl
+templates/other-loop.tmpl
+templates/outer.tmpl
+templates/query-test.tmpl
+templates/query-test2.tmpl
+templates/recursive.tmpl
+templates/searchpath/included.tmpl
+templates/searchpath/three.tmpl
+templates/searchpath/two.tmpl
+templates/simple-loop-nonames.tmpl
+templates/simple-loop.tmpl
+templates/simple.tmpl
+templates/unless.tmpl
+templates/urlescape.tmpl
+templates/vanguard1.tmpl
+templates/vanguard2.tmpl
+test/templates/complex.tmpl
+test/templates/foo.tmpl
+test/templates/func.tmpl
+test/templates/loop.tmpl
+test/templates/negative.tmpl
+test/templates/numerics.tmpl
+test/templates/register.tmpl
+test/test_basic.rb
+test/test_coderefs.rb
+test/test_complex.rb
+test/test_helper.rb
+test/test_html_template.rb
+test/test_html_template_internal_extn.rb
+test/test_html_template_pro.rb
+test/test_path_like_variable_scope.rb
+test/test_random.rb
+test/test_realloc.rb
+test/test_register.rb
+test/test_tmplpro.rb
+test/tests.rb
+website/index.txt
+website/javascripts/rounded_corners_lite.inc.js
+website/stylesheets/screen.css
+website/template.html.erb

data/README.rdoc

@@ -0,0 +1,52 @@
+= tmplpro
+
+* http://github.com/tom-lpsd/ruby-html-template-pro
+
+== DESCRIPTION:
+
+A Ruby port of HTML::Template::Pro (template engine originally written
+in Perl and XS). 
+
+== FEATURES/PROBLEMS:
+
+* Fast. (Main part is written in C.)
+* Simple. (It avoids mixing up complex logic in View.)
+
+== SYNOPSIS:
+
+  # foo.rb
+  require 'html/template/pro'
+  
+  template = HTML::Template::Pro.new(:filename => 'foo.tmpl')
+  template.param(:param1 => 100)
+  puts template.output
+  
+  # foo.tmpl
+  <html>
+    <head></head>
+    <body>
+      <h1><TMPL_VAR NAME="param1"></h1>
+    </body>
+  </html>
+
+  # results
+  $ ruby foo.rb
+  <html>
+    <head></head>
+    <body>
+      <h1>100</h1>
+    </body>
+  </html>
+  
+
+== REQUIREMENTS:
+
+* C99 C compiler.
+
+== INSTALL:
+
+* sudo gem install html-template-pro
+
+== LICENSE:
+
+LGPL

data/Rakefile

@@ -0,0 +1,18 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+
+Hoe.plugin :newgem
+Hoe.plugin :website
+
+$hoe = Hoe.spec 'html-template-pro' do
+  self.developer 'Tsuruhara Tom', 'tom.lpsd@gmail.com'
+  self.rubyforge_name = 'tmplpro'
+  self.version = "0.0.1"
+  self.summary = 'A Ruby port of HTML::Template::Pro'
+  self.extra_rdoc_files = ['README.rdoc']
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }

data/benchmark.rb

@@ -0,0 +1,136 @@
+require 'benchmark'
+require 'erb'
+require 'erubis'
+require 'html/template/pro'
+
+varset1 = { :VAR1 => 'VAR1', :VAR2 => 'VAR2', :VAR3 => 'VAR3', :VAR10 => 'VAR10' }
+varset2 = { :STUFF1 => '<>"; %FA' }
+
+refset1 = {
+  :HASHREF0=>[],
+  :HASHREF2=>[{},{}],
+  :HASHREF1=>[
+              {:LOOPVAR1=>'LOOP1-VAR1',:LOOPVAR2=>'LOOP1-VAR2',:LOOPVAR3=>'LOOP1-VAR3',:LOOPVAR10=>'LOOP1-VAR10'},
+              {:LOOPVAR1=>'LOOP2-VAR1',:LOOPVAR2=>'LOOP2-VAR2',:LOOPVAR3=>'LOOP2-VAR3',:LOOPVAR10=>'LOOP2-VAR10'},
+              {:LOOPVAR1=>'LOOP3-VAR1',:LOOPVAR2=>'LOOP3-VAR2',:LOOPVAR3=>'LOOP3-VAR3',:LOOPVAR10=>'LOOP3-VAR10'},
+              {:LOOPVAR1=>'LOOP4-VAR1',:LOOPVAR2=>'LOOP4-VAR2',:LOOPVAR3=>'LOOP4-VAR3',:LOOPVAR10=>'LOOP4-VAR10'},
+             ]
+}
+
+# -------------------------
+
+def test_tmpl(file, *args)
+  params = args.inject({}) do |result, item|
+    result.update(item)
+  end
+  testname = file
+  test_tmpl_complete(testname, params)
+  test_tmpl_output(testname, params)
+end
+
+def test_tmpl_output(testname, params)
+  Dir.chdir 'templates-Pro'
+  file = testname  
+  count = 1000
+
+  tmplo = HTML::Template::Pro.new(:filename => file + '.tmpl',
+                                  :die_on_bad_params => false,
+                                  :strict => false,
+                                  :case_sensitive => false,
+                                  :loop_context_vars => true
+                                  )
+  tmplo.param(params);
+
+  File.open('/dev/null', 'w') do |file|
+    puts "Template::Pro " + '-' * 40
+    puts Benchmark::CAPTION
+    puts Benchmark.measure{
+      count.times do
+        tmplo.output(:print_to => file)
+      end
+    }
+  end
+
+  erb = ERB.new(File.read(file + '.erb'))
+  File.open('/dev/null', 'w') do |file|
+    puts "ERB " + '-' * 40
+    puts Benchmark::CAPTION
+    puts Benchmark.measure{
+      count.times do
+        file.puts erb.result(binding)
+      end
+    }
+  end
+
+  erubis = Erubis::FastEruby.new(File.read(file + '.erb'))
+  File.open('/dev/null', 'w') do |file|
+    puts "Erubis " + '-' * 40
+    puts Benchmark::CAPTION
+    puts Benchmark.measure{
+      count.times do
+        file.puts erubis.result(binding)
+      end
+    }
+  end
+
+  Dir.chdir '..'
+end
+
+def test_tmpl_complete(testname, params)
+  Dir.chdir 'templates-Pro';
+  file = testname
+  count = 1000
+
+  File.open('/dev/null', 'w') do |file|
+    puts "Template::Pro " + '-' * 40
+    puts Benchmark::CAPTION
+    puts Benchmark.measure{
+      count.times do
+	tmpl = HTML::Template::Pro.new(:filename => testname + '.tmpl',
+                                       :loop_context_vars => true,
+                                       :case_sensitive => false,
+                                       :die_on_bad_params => false)
+	tmpl.param(params)
+	tmpl.output(:print_to => file)
+      end
+    }
+  end
+
+  File.open('/dev/null', 'w') do |file|
+    puts "ERB " + '-' * 40
+    puts Benchmark::CAPTION
+    puts Benchmark.measure{
+      count.times do
+        erb = ERB.new(File.read(testname + '.erb'))
+        file.puts erb.result(binding)
+      end
+    }
+  end
+
+  File.open('/dev/null', 'w') do |file|
+    puts "Erubis " + '-' * 40
+    puts Benchmark::CAPTION
+    puts Benchmark.measure{
+      count.times do
+        erubis = Erubis::FastEruby.new(File.read(testname + '.erb'))
+        file.puts erubis.result(binding)
+      end
+    }
+  end
+
+  Dir.chdir '..'
+end
+
+test_tmpl('test_var1', varset1);
+test_tmpl('test_var2', varset1);
+test_tmpl('test_loop1', varset1, refset1);
+test_tmpl('test_loop2', varset1, refset1);
+
+__END__
+test_tmpl('test_var3', varset1, varset2);
+test_tmpl('test_if1',  varset1);
+test_tmpl('test_if2',  varset1);
+test_tmpl('test_if3',  refset1);
+test_tmpl('test_loop3', varset1, refset1);
+test_tmpl('test_loop4', varset1, refset1);
+test_tmpl('test_loop5', varset1, refset1);

data/config/website.yml

@@ -0,0 +1,2 @@
+host: tom-lpsd@rubyforge.org
+remote_dir: /var/www/gforge-projects/tmplpro

data/ext/html/template/internal/Pro.xs

@@ -0,0 +1,679 @@
+#define PERLIO_NOT_STDIO 0    /* For co-existence with stdio only */
+#define PERL_NO_GET_CONTEXT     /* we want efficiency */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "EXTERN.h"
+#include "perl.h"
+#include "XSUB.h"
+#ifdef __cplusplus
+}
+#endif
+
+#include <string.h>
+#include <stdio.h>
+
+#include "ppport.h"
+
+#ifdef USE_SYSTEM_HTP_HEADER
+#include <tmplpro.h>
+#else
+#include "tmplpro.h"
+#endif
+
+typedef PerlIO *        OutputStream;
+
+struct perl_callback_state {
+  SV* perl_obj_self_ptr;
+  AV* filtered_tmpl_array;
+  AV* pool_for_perl_vars;
+  int force_untaint;
+};
+
+static 
+int debuglevel=0;
+
+/* endnext points on next character to end of interval as in c++ */
+static void write_chars_to_file (ABSTRACT_WRITER* OutputFile, const char* begin, const char* endnext) {
+  dTHX;       /* fetch context */
+  PerlIO_write((PerlIO*)OutputFile,begin, endnext-begin);
+}
+
+/* endnext points on next to end character of the interval */
+static void write_chars_to_string (ABSTRACT_WRITER* OutputString, const char* begin, const char* endnext) {
+  dTHX;       /* fetch context */
+  sv_catpvn((SV*)OutputString, begin, endnext-begin);
+}
+
+static
+ABSTRACT_VALUE* get_ABSTRACT_VALUE_impl (ABSTRACT_DATASTATE* none, ABSTRACT_MAP* ptr_HV, PSTRING name) {
+  dTHX;       /* fetch context */
+  return hv_fetch((HV*) ptr_HV,name.begin, name.endnext-name.begin, 0);
+}
+
+static 
+SV* 
+call_coderef (SV* coderef) {
+  SV* SVretval;
+  I32 count;
+  dTHX;       /* fetch context */
+  /* TODO: G_EVAL and error handler */
+  dSP;
+
+  /* let perl clean up mortals after the end of output() call
+     ENTER;
+     SAVETMPS;*/
+
+  PUSHMARK(SP);
+  PUTBACK; /* in fact, isn't needed -- nothing is pushed and G_NOARGS is used */
+
+  count = call_sv(coderef, G_EVAL|G_SCALAR|G_NOARGS);
+  SPAGAIN;
+    
+  /* Check the eval first */
+  if (SvTRUE(ERRSV))
+    {
+      STRLEN n_a;
+      printf ("Pro.xs: param tree code reference exited abnormally - %s\n", SvPV(ERRSV, n_a));
+      SVretval=POPs; /* undef */
+    }
+  else
+    {
+      if (count != 1)
+	croak("Pro.xs: internal context error (got %d) while calling CODE reference\n", count);
+      SVretval=POPs;
+    }
+
+  PUTBACK;
+  /* let perl clean up mortals after the end of output() call
+     FREETMPS;
+     LEAVE;*/
+  return SVretval;
+}
+
+static
+PSTRING ABSTRACT_VALUE2PSTRING_impl (ABSTRACT_DATASTATE* callback_state, ABSTRACT_VALUE* valptr) {
+  STRLEN len=0;
+  PSTRING retval={NULL,NULL};
+  SV* SVval;
+  dTHX;       /* fetch context */
+  if (valptr==NULL) return retval;
+  SVval = *((SV**) valptr);
+  SvGETMAGIC(SVval);
+  if (SvOK(SVval) && SvROK(SVval)) {
+    if (SvTYPE(SvRV(SVval))==SVt_PVCV) {
+      SVval = call_coderef(SVval);
+    } else {
+      SVval = SvRV(SVval);
+    }
+    SvGETMAGIC(SVval);
+  }
+  if (!SvOK(SVval)) return retval;
+  /* TODO param resource deallocation */
+  if (((struct perl_callback_state*) callback_state)->force_untaint && SVval && SvTAINTED(SVval))
+    croak("force_untaint: got tainted value %" SVf, SVval);
+
+  retval.begin=SvPV(SVval, len);
+  retval.endnext=retval.begin+len;
+  return retval;
+}
+
+static
+int is_ABSTRACT_VALUE_true_impl (ABSTRACT_DATASTATE* none, ABSTRACT_VALUE* valptr) {
+  SV* SVval;
+  dTHX;       /* fetch context */
+  if (valptr==NULL) return 0;
+  SVval = *((SV**) valptr);
+  if (SvROK(SVval)) {
+    if ((SvTYPE(SvRV(SVval)) == SVt_PVCV)) {
+      SVval = call_coderef(SVval);
+    } else
+    /* arrayptr : in HTML::Template, true if len(array)>0 */
+      if ((SvTYPE(SvRV(SVval)) == SVt_PVAV)
+	&& (av_len((AV *)SvRV(SVval))<0)) {
+      return 0;
+    } else return 1;
+  }
+  /* in any place where I receive a value of which I don't know the origin, 
+     I should call SvGETMAGIC first. */
+  SvGETMAGIC(SVval);
+  if(SvTRUE(SVval)) return 1;
+  return 0;
+}
+
+static 
+ABSTRACT_ARRAY* ABSTRACT_VALUE2ABSTRACT_ARRAY_impl (ABSTRACT_DATASTATE* none, ABSTRACT_VALUE* abstrvalptr) {
+  SV* val = *((SV**) abstrvalptr);
+  dTHX;       /* fetch context */
+  SvGETMAGIC(val);
+  if ((!SvROK(val)) || (SvTYPE(SvRV(val)) != SVt_PVAV)) return 0;
+  return (ABSTRACT_ARRAY*) SvRV(val);
+}
+
+static 
+int get_ABSTRACT_ARRAY_length_impl (ABSTRACT_DATASTATE* none, ABSTRACT_ARRAY* loops_AV) {
+  dTHX;       /* fetch context */
+  SvGETMAGIC((SV *)loops_AV);
+  return av_len((AV *)loops_AV)+1;
+}
+
+static 
+ABSTRACT_MAP* get_ABSTRACT_MAP_impl (ABSTRACT_DATASTATE* none, ABSTRACT_ARRAY* loops_AV, int loop) {
+  dTHX;       /* fetch context */
+  SV* val;
+  SV** arrayvalptr = av_fetch((AV*)loops_AV, loop, 0);
+  if (arrayvalptr==NULL) return NULL;
+  val = *arrayvalptr;
+  SvGETMAGIC(val);
+  if ((!SvROK(val)) || (SvTYPE(SvRV(val)) != SVt_PVHV)) {
+    return NULL;
+  } else {
+    return (ABSTRACT_MAP *)SvRV(*arrayvalptr);
+  }
+}
+
+static 
+const char* get_filepath (ABSTRACT_FINDFILE* callback_state, const char* filename, const char* prevfilename) {
+  dTHX;       /* fetch context */
+  dSP ;
+  int count ;
+  STRLEN len;
+  char* filepath;
+  SV* perlprevfile;
+  SV* PerlSelfHTMLTemplatePro = ((struct perl_callback_state*)callback_state)->perl_obj_self_ptr;
+  SV* perlretval = sv_2mortal(newSVpv(filename,0));
+  if (prevfilename) {
+    perlprevfile=sv_2mortal(newSVpv(prevfilename,0));
+  } else {
+    perlprevfile=sv_2mortal(newSV(0));
+  }
+  ENTER ;
+  SAVETMPS;
+  PUSHMARK(SP) ;
+  XPUSHs((SV*)PerlSelfHTMLTemplatePro);
+  XPUSHs(perlretval);
+  XPUSHs(perlprevfile);
+  PUTBACK ;
+  count = call_pv("_get_filepath", G_SCALAR);
+  SPAGAIN ;
+  if (count != 1) croak("Big troublen") ;
+  perlretval=POPs;
+  /* any memory leaks??? */  
+  if (SvOK(perlretval)) {
+    filepath = SvPV(perlretval, len);
+    av_push(((struct perl_callback_state*)callback_state)->pool_for_perl_vars,perlretval);
+    SvREFCNT_inc(perlretval);
+  } else {
+    filepath = NULL;
+  }
+  PUTBACK ;
+  FREETMPS ;
+  LEAVE ;
+  return filepath;
+}
+
+static 
+PSTRING load_file (ABSTRACT_FILTER* callback_state, const char* filepath) {
+  dTHX;       /* fetch context */
+  dSP ;
+  int count ;
+  STRLEN len;
+  PSTRING tmpl;
+  SV* templateptr;
+  SV* perlretval = sv_2mortal(newSVpv(filepath,0));
+  ENTER ;
+  SAVETMPS;
+  PUSHMARK(SP) ;
+  XPUSHs(((struct perl_callback_state*)callback_state)->perl_obj_self_ptr);
+  XPUSHs(perlretval);
+  PUTBACK ;
+  count = call_pv("_load_template", G_SCALAR);
+  SPAGAIN ;
+  if (count != 1) croak("Big troublen") ;
+  templateptr=POPs;
+  /* any memory leaks??? */  
+  if (SvOK(templateptr) && SvROK(templateptr)) {
+    tmpl.begin = SvPV(SvRV(templateptr), len);
+    tmpl.endnext=tmpl.begin+len;
+    av_push(((struct perl_callback_state*)callback_state)->filtered_tmpl_array,templateptr);
+    SvREFCNT_inc(SvRV(templateptr));
+  } else {
+    croak("Big trouble! _load_template internal fatal error\n") ;
+  }
+  PUTBACK ;
+  FREETMPS ;
+  LEAVE ;
+  return tmpl;
+}
+
+static
+int unload_file(ABSTRACT_FILTER* callback_state, PSTRING memarea) {
+  dTHX;       /* fetch context */
+  /*
+   * scalar is already mortal so we don't need to dereference it
+   * SvREFCNT_dec(SvRV(av_pop(((struct perl_callback_state*)callback_state)->filtered_tmpl_array)));
+   */
+  av_pop(((struct perl_callback_state*)callback_state)->filtered_tmpl_array); 
+  return 0;
+}
+
+static 
+ABSTRACT_USERFUNC* is_expr_userfnc (ABSTRACT_FUNCMAP* FuncHash, PSTRING name) {
+  dTHX;       /* fetch context */
+  SV** hashvalptr=hv_fetch((HV *) FuncHash, name.begin, name.endnext-name.begin, 0);
+  return hashvalptr;
+}
+
+static 
+void free_expr_arglist(ABSTRACT_ARGLIST* arglist)
+{
+  dTHX;       /* fetch context */
+  if (NULL!=arglist) {
+    av_undef((AV*) arglist);
+    SvREFCNT_dec(arglist);
+  }
+}
+
+static 
+ABSTRACT_ARGLIST* init_expr_arglist(ABSTRACT_CALLER* none)
+{
+  dTHX;       /* fetch context */
+  return newAV();
+}
+
+static 
+void push_expr_arglist(ABSTRACT_ARGLIST* arglist, ABSTRACT_EXPRVAL* exprval)
+{
+  dTHX;       /* fetch context */
+  SV* val=NULL;
+  int exprval_type=tmplpro_get_expr_type(exprval);
+  PSTRING parg;
+  switch (exprval_type) {
+  case EXPR_TYPE_NULL: val=newSV(0);break;
+  case EXPR_TYPE_INT:  val=newSViv(tmplpro_get_expr_as_int64(exprval));break;
+  case EXPR_TYPE_DBL:  val=newSVnv(tmplpro_get_expr_as_double(exprval));break;
+  case EXPR_TYPE_PSTR: parg=tmplpro_get_expr_as_pstring(exprval);
+                 val=newSVpvn(parg.begin, parg.endnext-parg.begin);break;
+  default: die ("Perl wrapper: FATAL INTERNAL ERROR:Unsupported type %d in exprval", exprval_type);
+  }
+  av_push ((AV*) arglist, val);
+}
+
+static 
+void call_expr_userfnc (ABSTRACT_CALLER* callback_state, ABSTRACT_ARGLIST* arglist, ABSTRACT_USERFUNC* hashvalptr, ABSTRACT_EXPRVAL* exprval) {
+  dTHX;       /* fetch context */
+  dSP ;
+  char* empty="";
+  char* strval;
+  SV ** arrval;
+  SV * svretval;
+  I32 i;
+  I32 numretval;
+  I32 arrlen=av_len((AV *) arglist);
+  PSTRING retvalpstr = { empty, empty };
+  retvalpstr.begin=empty;
+  retvalpstr.endnext=empty;
+  if (hashvalptr==NULL) {
+    die ("FATAL INTERNAL ERROR:Call_EXPR:function called but not exists");
+    tmplpro_set_expr_as_pstring(exprval,retvalpstr);
+    return;
+  } else if (! SvROK(*((SV**) hashvalptr)) || (SvTYPE(SvRV(*((SV**) hashvalptr))) != SVt_PVCV)) {
+    die ("FATAL INTERNAL ERROR:Call_EXPR:not a function reference");
+    tmplpro_set_expr_as_pstring(exprval,retvalpstr);
+    return;
+  }
+  
+  ENTER ;
+  SAVETMPS ;
+  
+  PUSHMARK(SP) ;
+  for (i=0;i<=arrlen;i++) {
+    arrval=av_fetch((AV *) arglist,i,0);
+    if (arrval) XPUSHs(*arrval);
+    else warn("INTERNAL: call: strange arrval");
+  }
+  PUTBACK ;
+  numretval=call_sv(*((SV**) hashvalptr), G_SCALAR);
+  SPAGAIN ;
+  if (numretval) {
+    svretval=POPs;
+    SvGETMAGIC(svretval);
+    if (SvOK(svretval)) {
+      if (SvIOK(svretval)) {
+	tmplpro_set_expr_as_int64(exprval,SvIV(svretval));
+      } else if (SvNOK(svretval)) {
+	tmplpro_set_expr_as_double(exprval,SvNV(svretval));
+      } else {
+	STRLEN len=0;
+	strval =SvPV(svretval, len);
+	/* hack !!! */
+	av_push(((struct perl_callback_state*)callback_state)->pool_for_perl_vars,svretval);
+	SvREFCNT_inc(svretval);
+	retvalpstr.begin=strval;
+	retvalpstr.endnext=strval +len;
+	tmplpro_set_expr_as_pstring(exprval,retvalpstr);
+      }
+    } else {
+      if (debuglevel>1) warn ("user defined function returned undef\n");
+    }
+  } else {
+    if (debuglevel) warn ("user defined function returned nothing\n");
+  }
+
+  FREETMPS ;
+  LEAVE ;
+
+  return;
+}
+
+typedef void (*set_int_option_functype) (struct tmplpro_param*, int);
+
+static 
+void set_integer_from_hash(pTHX_ HV* TheHash, char* key, struct tmplpro_param* param, set_int_option_functype setfunc) {
+  SV** hashvalptr=hv_fetch(TheHash, key, strlen(key), 0);
+  if (hashvalptr==NULL) return;
+  setfunc(param,SvIV(*hashvalptr));
+}
+
+static 
+int get_integer_from_hash(pTHX_ HV* TheHash, char* key) {
+  SV** hashvalptr=hv_fetch(TheHash, key, strlen(key), 0);
+  if (hashvalptr==NULL) return 0;
+  return SvIV(*hashvalptr);
+}
+
+static 
+PSTRING get_string_from_hash(pTHX_ HV* TheHash, char* key) {
+  SV** hashvalptr=hv_fetch(TheHash, key, strlen(key), 0);
+  STRLEN len=0;
+  char * begin;
+  PSTRING retval={NULL,NULL};
+  if (hashvalptr==NULL) return retval;
+  if (SvROK(*hashvalptr)) {
+    /* if (SvTYPE(SvRV(*hashvalptr))!=SVt_PV) return (PSTRING) {NULL,NULL}; */
+    begin=SvPV(SvRV(*hashvalptr),len);
+  } else {
+    if (! SvPOK(*hashvalptr)) return retval;
+    begin=SvPV(*hashvalptr,len);
+  }
+  retval.begin=begin;
+  retval.endnext=begin+len;
+  return retval;
+}
+
+
+static 
+char** get_array_of_strings_from_hash(pTHX_ HV* TheHash, char* key, struct perl_callback_state* callback_state) {
+  SV** valptr=hv_fetch(TheHash, key, strlen(key), 0);
+  int amax;
+  char** path=NULL;
+  AV* pathAV;
+  int i =0;
+  char** j;
+  SV* store;
+  if (valptr!=NULL && SvROK(*valptr) && (SvTYPE(SvRV(*valptr)) == SVt_PVAV) ) {
+    pathAV=(AV *)SvRV(*valptr);
+    amax=av_len(pathAV);
+    if (amax<0) {
+      return NULL;
+    } else {
+      store = newSV(sizeof(char*)*(amax+2));
+      path = (char**) SvGROW(store, sizeof(char*)*(amax+2));
+      av_push(((struct perl_callback_state*)callback_state)->pool_for_perl_vars,store);
+      SvREFCNT_inc(store);
+      //path=(char**) malloc(sizeof(char*)*(amax+2));
+      j=path;
+      for (i=0; i<=amax;i++) {
+	valptr = av_fetch(pathAV,i,0);
+	if (valptr!=NULL) {
+	  *j=SvPV_nolen(*valptr);
+	  j++;
+	}
+	*j=NULL;
+      }
+    }
+  } else {
+    warn ("get_array_of_strings:option %s not found :(\n", key);
+  }
+  return path;
+}
+
+static 
+struct tmplpro_param* process_tmplpro_options (struct perl_callback_state* callback_state) {
+  dTHX;       /* fetch context */
+  HV* SelfHash;
+  SV** hashvalptr;
+  const char* tmpstring;
+  SV* PerlSelfPtr=callback_state->perl_obj_self_ptr;
+  int default_escape=HTML_TEMPLATE_OPT_ESCAPE_NO;
+
+  /* main arguments */
+  PSTRING filename;
+  PSTRING scalarref;
+
+  /* internal initialization */
+  struct tmplpro_param* param=tmplpro_param_init();
+
+  /*   setting initial hooks */
+  tmplpro_set_option_WriterFuncPtr(param, &write_chars_to_string);
+  tmplpro_set_option_GetAbstractValFuncPtr(param, &get_ABSTRACT_VALUE_impl);
+  tmplpro_set_option_AbstractVal2pstringFuncPtr(param, &ABSTRACT_VALUE2PSTRING_impl);
+  tmplpro_set_option_AbstractVal2abstractArrayFuncPtr(param, &ABSTRACT_VALUE2ABSTRACT_ARRAY_impl);
+  tmplpro_set_option_GetAbstractArrayLengthFuncPtr(param, &get_ABSTRACT_ARRAY_length_impl);
+  tmplpro_set_option_IsAbstractValTrueFuncPtr(param, &is_ABSTRACT_VALUE_true_impl);
+  tmplpro_set_option_GetAbstractMapFuncPtr(param, &get_ABSTRACT_MAP_impl);
+  tmplpro_set_option_LoadFileFuncPtr(param, &load_file);
+  tmplpro_set_option_UnloadFileFuncPtr(param, &unload_file);
+
+  /*   setting initial Expr hooks */
+  tmplpro_set_option_InitExprArglistFuncPtr(param, &init_expr_arglist);
+  tmplpro_set_option_FreeExprArglistFuncPtr(param, &free_expr_arglist);
+  tmplpro_set_option_PushExprArglistFuncPtr(param, &push_expr_arglist);
+  tmplpro_set_option_CallExprUserfncFuncPtr(param, &call_expr_userfnc);
+  tmplpro_set_option_IsExprUserfncFuncPtr(param, &is_expr_userfnc);
+  /* end setting initial hooks */
+
+  /*   setting perl globals */
+  tmplpro_set_option_ext_findfile_state(param,callback_state);
+  tmplpro_set_option_ext_filter_state(param,callback_state);
+  tmplpro_set_option_ext_calluserfunc_state(param,callback_state);
+  tmplpro_set_option_ext_data_state(param,callback_state);
+  /*  end setting perl globals */
+
+  if ((!SvROK(PerlSelfPtr)) || (SvTYPE(SvRV(PerlSelfPtr)) != SVt_PVHV))
+    {
+      die("FATAL:SELF:hash pointer was expected but not found");
+    }
+  SelfHash=(HV *)SvRV(PerlSelfPtr);
+
+  /* checking main arguments */
+  filename=get_string_from_hash(aTHX_ SelfHash,"filename");
+  scalarref=get_string_from_hash(aTHX_ SelfHash,"scalarref");
+  tmplpro_set_option_filename(param, filename.begin);
+  tmplpro_set_option_scalarref(param, scalarref);
+  if (filename.begin==NULL && scalarref.begin==NULL) {
+    die ("bad arguments: expected filename or scalarref");
+  }
+  
+  /* setting expr_func */
+  hashvalptr=hv_fetch(SelfHash, "expr_func", 9, 0); /* 9=strlen("expr_func") */
+  if (!hashvalptr || !SvROK(*hashvalptr) || (SvTYPE(SvRV(*hashvalptr)) != SVt_PVHV))
+    die("FATAL:output:EXPR user functions not found");
+  tmplpro_set_option_expr_func_map(param, (HV *) SvRV(*hashvalptr));
+  /* end setting expr_func */
+
+  /* setting param_map */
+  tmplpro_clear_option_param_map(param);
+  hashvalptr=hv_fetch(SelfHash, "associate", 9, 0); /* 9=strlen("associate") */
+  if (hashvalptr!=NULL && SvROK(*hashvalptr) && (SvTYPE(SvRV(*hashvalptr)) == SVt_PVAV)) {
+    AV* associate = (AV*) SvRV(*hashvalptr);
+    I32 i = av_len(associate);
+    SV** arrayvalptr;
+    while (i>=0) {
+      arrayvalptr = av_fetch(associate, i, 0);
+      if (arrayvalptr!=NULL && SvROK(*arrayvalptr))
+	tmplpro_push_option_param_map(param, (ABSTRACT_MAP *)SvRV(*arrayvalptr), 0);
+      i--;
+    }
+  }
+  hashvalptr=hv_fetch(SelfHash, "param_map", 9, 0); /* 9=strlen("param_map") */
+  /* TODO param deallocation on warn/die */
+  if (!hashvalptr || !SvROK(*hashvalptr) || (SvTYPE(SvRV(*hashvalptr)) != SVt_PVHV))
+    die("FATAL:output:param_map not found");
+  tmplpro_push_option_param_map(param, (ABSTRACT_MAP *)SvRV(*hashvalptr), 0);
+  /* end setting param_map */
+
+  /* setting filter */
+  hashvalptr=hv_fetch(SelfHash, "filter", 6, 0); /* 6=strlen("filter") */
+  if (!hashvalptr || !SvROK(*hashvalptr) || (SvTYPE(SvRV(*hashvalptr)) != SVt_PVAV))
+    die("FATAL:output:filter not found");
+  if (av_len((AV*)SvRV(*hashvalptr))>=0) tmplpro_set_option_filters(param, 1);
+  /* end setting param_map */
+
+  if (!get_integer_from_hash(aTHX_ SelfHash,"case_sensitive")) {
+    tmplpro_set_option_tmpl_var_case(param, ASK_NAME_LOWERCASE);
+  }
+
+  set_integer_from_hash(aTHX_ SelfHash,"tmpl_var_case",param,tmplpro_set_option_tmpl_var_case);
+  set_integer_from_hash(aTHX_ SelfHash,"max_includes",param,tmplpro_set_option_max_includes);
+  set_integer_from_hash(aTHX_ SelfHash,"no_includes",param,tmplpro_set_option_no_includes);
+  set_integer_from_hash(aTHX_ SelfHash,"search_path_on_include",param,tmplpro_set_option_search_path_on_include);
+  set_integer_from_hash(aTHX_ SelfHash,"global_vars",param,tmplpro_set_option_global_vars);
+  set_integer_from_hash(aTHX_ SelfHash,"debug",param,tmplpro_set_option_debug);
+  debuglevel = tmplpro_get_option_debug(param);
+  set_integer_from_hash(aTHX_ SelfHash,"loop_context_vars",param,tmplpro_set_option_loop_context_vars);
+  set_integer_from_hash(aTHX_ SelfHash,"path_like_variable_scope",param,tmplpro_set_option_path_like_variable_scope);
+  /* still unsupported */
+  set_integer_from_hash(aTHX_ SelfHash,"strict",param,tmplpro_set_option_strict);
+ 
+  tmpstring=get_string_from_hash(aTHX_ SelfHash,"default_escape").begin;
+  if (tmpstring && *tmpstring) {
+    switch (*tmpstring) {
+    case '1': case 'H': case 'h': 	/* HTML*/
+      default_escape = HTML_TEMPLATE_OPT_ESCAPE_HTML;
+      break;
+    case 'U': case 'u': 		/* URL */
+      default_escape = HTML_TEMPLATE_OPT_ESCAPE_URL;
+      break;
+    case 'J': case 'j':		/* JS  */
+      default_escape = HTML_TEMPLATE_OPT_ESCAPE_JS;
+      break;
+    case '0': case 'N': case 'n': /* 0 or NONE */
+      default_escape = HTML_TEMPLATE_OPT_ESCAPE_NO;
+      break;
+    default:
+      warn("unsupported value of default_escape=%s. Valid values are HTML, URL or JS.\n",tmpstring);
+    }
+    tmplpro_set_option_default_escape(param, default_escape);
+
+  }
+
+  /* setting callback_state */
+  callback_state->force_untaint=get_integer_from_hash(aTHX_ SelfHash,"force_untaint");
+  /* end setting callback_state */
+
+  if (get_integer_from_hash(aTHX_ SelfHash,"__use_perl_find_file")) {
+    tmplpro_set_option_FindFileFuncPtr(param, &get_filepath);
+  } else {
+    tmplpro_set_option_path(param, get_array_of_strings_from_hash(aTHX_ SelfHash, "path", callback_state));
+    tmplpro_set_option_FindFileFuncPtr(param, NULL);
+  }
+  return param;
+}
+
+static void
+release_tmplpro_options(struct tmplpro_param* param, struct perl_callback_state callback_state)
+{
+  dTHX;       /* fetch context */
+  av_undef(callback_state.filtered_tmpl_array);
+  av_undef(callback_state.pool_for_perl_vars);
+  tmplpro_param_free(param);
+}
+
+
+
+MODULE = HTML::Template::Pro		PACKAGE = HTML::Template::Pro
+
+void 
+_init()
+    CODE:
+	tmplpro_procore_init();
+
+void 
+_done()
+    CODE:
+	tmplpro_procore_done();
+
+
+int
+exec_tmpl(self_ptr,possible_output)
+	SV* self_ptr;
+	SV* possible_output;
+ PREINIT:
+	struct perl_callback_state callback_state = {self_ptr,newAV(),newAV(),0};
+	struct tmplpro_param* proparam=process_tmplpro_options(&callback_state);
+    CODE:
+	OutputStream output_stream;
+	SvGETMAGIC(possible_output);
+	if (!SvOK(possible_output)) {
+	  tmplpro_set_option_WriterFuncPtr(proparam,NULL);
+	} else {
+	  output_stream = IoOFP(sv_2io(possible_output));
+	  if (output_stream == NULL){
+	    warn("Pro.xs:output: bad file descriptor in print_to option. Use stdout\n");
+	    tmplpro_set_option_WriterFuncPtr(proparam,NULL);
+	  } else {
+	    tmplpro_set_option_ext_writer_state(proparam,output_stream);
+	    tmplpro_set_option_WriterFuncPtr(proparam,&write_chars_to_file);
+	  }
+	}
+	RETVAL = tmplpro_exec_tmpl(proparam);
+	release_tmplpro_options(proparam,callback_state);
+	if (RETVAL!=0) warn ("Pro.xs: non-zero exit code %d",RETVAL);
+    OUTPUT:
+	RETVAL
+
+
+SV*
+exec_tmpl_string(self_ptr)
+	SV* self_ptr;
+ PREINIT:
+	int retstate;
+	/* made mortal automatically */
+	SV* outputString;
+	struct perl_callback_state callback_state = {self_ptr,newAV(),newAV(),0};
+	struct tmplpro_param* proparam=process_tmplpro_options(&callback_state);
+    CODE:
+	outputString=newSV(4000); /* 4000 allocated bytes -- should be approx. filesize*/
+	sv_setpvn(outputString, "", 0);
+	tmplpro_set_option_WriterFuncPtr(proparam,&write_chars_to_string);
+	tmplpro_set_option_ext_writer_state(proparam,outputString);
+	retstate = tmplpro_exec_tmpl(proparam);
+	release_tmplpro_options(proparam,callback_state);
+	if (retstate!=0) warn ("Pro.xs: non-zero exit code %d",retstate);
+	RETVAL = outputString;
+    OUTPUT:
+	RETVAL
+
+
+SV*
+exec_tmpl_string_builtin(self_ptr)
+	SV* self_ptr;
+ PREINIT:
+	int retstate;
+	SV* outputString;
+	MPSTRING inString;
+	struct perl_callback_state callback_state = {self_ptr,newAV(),newAV(),0};
+	struct tmplpro_param* proparam=process_tmplpro_options(&callback_state);
+    CODE:
+	inString = tmplpro_tmpl2pstring(proparam, &retstate);
+	outputString=newSV(inString.endnext-inString.begin+2);
+	sv_setpvn(outputString, inString.begin, inString.endnext-inString.begin);
+	free(inString.begin);
+	release_tmplpro_options(proparam,callback_state);
+	if (retstate!=0) warn ("Pro.xs: non-zero exit code %d",retstate);
+	RETVAL = outputString;
+    OUTPUT:
+	RETVAL
+