kwartz 3.0.0 → 3.1.0

data/lib/kwartz/binding/eruby.rb

@@ -1,11 +1,12 @@
 ###
-### $Rev: 111 $
-### $Release: 3.0.0 $
+### $Rev: 124 $
+### $Release: 3.1.0 $
 ### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
 ###
 
 require 'kwartz/converter'
 require 'kwartz/translator'
+require 'kwartz/binding/ruby'
 
 
 
@@ -16,124 +17,8 @@ module Kwartz
   ##
   ## directive handler for eRuby
   ##
-  class ErubyHandler < Handler
-
-
-    ERUBY_DIRECTIVE_PATTERN = /\A(\w+)(?:[:\s]\s*(.*))?\z/
-
-    def directive_pattern
-      return ERUBY_DIRECTIVE_PATTERN
-    end
-
-
-    ERUBY_MAPPING_PATTERN = /\A'([-:\w]+)'\s+(.*)\z/
-
-    def mapping_pattern
-      return ERUBY_MAPPING_PATTERN
-    end
-
-
-    ERUBY_DIRECTIVE_FORMAT = '%s: %s'
-
-    def directive_format
-      return ERUBY_DIRECTIVE_FORMAT
-    end
-
-
-    def handle(directive_name, directive_arg, directive_str, stag_info, etag_info, cont_stmts, attr_info, append_exprs, stmt_list)
-      ret = super
-      return ret if ret
-
-      d_name = directive_name
-      d_arg  = directive_arg
-      d_str  = directive_str
-
-      case directive_name
-
-      when :for, :For, :FOR, :list, :List, :LIST
-        unless d_arg =~ /\A(\w+)(?:,\s*(\w+))?\s+in\s+(.*)\z/ || d_arg =~ /\A(\w+)(?:,(\w+))?\s*[:=]\s*(.*)\z/
-          raise convert_error("#'{d_str}': invalid argument.", stag_info.linenum)
-        end
-        loopvar = $1 ;  loopval = $2 ;  looplist = $3
-        is_foreach = d_name == :for || d_name == :For || d_name == :FOR
-        counter = d_name == :for || d_name == :list ? nil : "#{loopvar}_ctr"
-        toggle  = d_name != :FOR && d_name != :LIST ? nil : "#{loopvar}_tgl"
-        stmt_list  <<  build_print_stmt(stag_info, attr_info, append_exprs)   if !is_foreach
-        stmt_list  <<  NativeStatement.new("#{counter} = 0") if counter
-        if loopval
-          stmt_list << NativeStatement.new("#{looplist}.each do |#{loopvar}, #{loopval}|", :foreach)
-        else
-          stmt_list << NativeStatement.new("for #{loopvar} in #{looplist} do", :foreach)
-        end
-        stmt_list  <<  NativeStatement.new("  #{counter} += 1") if counter
-        stmt_list  <<  NativeStatement.new("  #{toggle} = #{counter}%2==0 ? #{self.even} : #{self.odd}") if toggle
-        stmt_list  <<  build_print_stmt(stag_info, attr_info, append_exprs)   if is_foreach
-        stmt_list.concat(cont_stmts)
-        stmt_list  <<  build_print_stmt(etag_info, nil, nil)                  if is_foreach
-        stmt_list  <<  NativeStatement.new("end", :foreach)
-        stmt_list  <<  build_print_stmt(etag_info, nil, nil)                  if !is_foreach
-
-      when :while, :loop
-        is_while = d_name == :while
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)   if !is_while
-        stmt_list << NativeStatement.new("while #{d_arg} do", :while)
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)   if is_while
-        stmt_list.concat(cont_stmts)
-        stmt_list << build_print_stmt(etag_info, nil, nil)                  if is_while
-        stmt_list << NativeStatement.new("end", :while)
-        stmt_list << build_print_stmt(etag_info, nil, nil)                  if !is_while
-
-      when :set
-        stmt_list << NativeStatement.new(d_arg, :set)
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
-        stmt_list.concat(cont_stmts)
-        stmt_list << build_print_stmt(etag_info, nil, nil)
-
-      when :if
-        stmt_list << NativeStatement.new("if #{d_arg} then", :if)
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
-        stmt_list.concat(cont_stmts)
-        stmt_list << build_print_stmt(etag_info, nil, nil)
-        stmt_list << NativeStatement.new("end", :if)
-
-      when :elsif, :else
-        unless !stmt_list.empty? && (st=stmt_list[-1]).is_a?(NativeStatement) && (st.kind == :if || st.kind == :elseif)
-          raise convert_error("'#{d_str}': previous statement should be 'if' or 'elsif'.", stag_info.linenum)
-        end
-        stmt_list.pop    # delete 'end'
-        if d_name == :else
-          kind = :else
-          stmt_list << NativeStatement.new("else", :else)
-        else
-          kind = :elseif
-          stmt_list << NativeStatement.new("elsif #{d_arg} then", :elseif)
-        end
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
-        stmt_list.concat(cont_stmts)
-        stmt_list << build_print_stmt(etag_info, nil, nil)
-        stmt_list << NativeStatement.new("end", kind)
-
-      when :default, :Default, :DEFAULT
-        error_if_empty_tag(stag_info, etag_info, d_name, d_arg)
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
-        stmt_list << NativeStatement.new_without_newline("if (#{d_arg}) && !(#{d_arg}).to_s.empty? then", :if)
-        flag_escape = d_name == :default ? nil : (d_name == :Default)
-        stmt_list << PrintStatement.new([ NativeExpression.new(d_arg, flag_escape) ])
-        stmt_list << NativeStatement.new_without_newline("else", :else)
-        stmt_list.concat(cont_stmts)
-        stmt_list << NativeStatement.new_without_newline("end", :else)
-        stmt_list << build_print_stmt(etag_info, nil, nil)
-
-      else
-        return false
-
-      end #case
-      return true
-
-    end #def
-
-
-  end #class
+  class ErubyHandler < RubyHandler
+  end
   Handler.register_class('eruby', ErubyHandler)
 
 

data/lib/kwartz/binding/jstl.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 116 $
-### $Release: 3.0.0 $
+### $Rev: 123 $
+### $Release: 3.1.0 $
 ### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
 ###
 
@@ -22,7 +22,7 @@ module Kwartz
 
     def initialize(elem_rulesets=[], properties={})
       super
-      @jstl_ver = properties[:jstl] || 1.2
+      @jstl_ver = properties[:jstl] || Config::PROPERTY_JSTL
     end
 
 
@@ -47,128 +47,134 @@ module Kwartz
     end
 
 
-    def handle(directive_name, directive_arg, directive_str, stag_info, etag_info, cont_stmts, attr_info, append_exprs, stmt_list)
+    def handle(stmt_list, handler_arg)
       ret = super
       return ret if ret
 
-      d_name = directive_name
-      d_arg  = directive_arg
-      d_str  = directive_str
+      arg = handler_arg
+      d_name = arg.directive_name
+      d_arg  = arg.directive_arg
+      d_str  = arg.directive_str
 
-      case directive_name
+      case d_name
 
       when :for, :For, :FOR, :list, :List, :LIST
         is_foreach = d_name == :for || d_name == :For || d_name == :FOR
+        error_if_empty_tag(arg) unless is_foreach
         unless d_arg =~ /\A(\w+)\s*:\s*(.*)\z/
-          raise convert_error("'#{d_str}': invalid argument.", stag_info.linenum)
+          raise convert_error("'#{d_str}': invalid argument.", arg.stag_info.linenum)
         end
         loopvar = $1 ; looplist = $2
         counter = d_name == :for || d_name == :list ? nil : "#{loopvar}_ctr"
         toggle  = d_name != :FOR && d_name != :LIST ? nil : "#{loopvar}_tgl"
         status  = d_name == :for || d_name == :list ? nil : "#{loopvar}_status"
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)   if !is_foreach
-        sb = "<c:forEach var=\"#{loopvar}\" items=\"${#{looplist}}\""
-        sb << " varStatus=\"#{status}\"" if status
-        sb << ">"
-        stmt_list << NativeStatement.new(sb, :foreach)
-        if counter
-          stmt_list << NativeStatement.new("<c:set var=\"#{counter}\" value=\"${#{status}.count}\" />")
-        end
+        foreach_code = "<c:forEach var=\"#{loopvar}\" items=\"${#{looplist}}\""
+        foreach_code << " varStatus=\"#{status}\"" if status
+        foreach_code << ">"
+        code = []
+        code << foreach_code
+        code << "<c:set var=\"#{counter}\" value=\"${#{status}.count}\"/>" if counter
         if toggle
           if @jstl_ver < 1.2
-            stmt_list << NativeStatement.new("<c:choose><c:when test=\"${#{status}.count%2==0}\">")
-            stmt_list << NativeStatement.new("<c:set var=\"#{toggle}\" value=\"${self.even}\"/>")
-            stmt_list << NativeStatement.new("</c:when><c:otherwise>")
-            stmt_list << NativeStatement.new("<c:set var=\"#{toggle}\" value=\"${self.odd}\"/>")
-            stmt_list << NativeStatement.new("</c:otherwise></c:choose>")
+            code << "<c:choose><c:when test=\"${#{status}.count%2==0}\">"
+            code << "<c:set var=\"#{toggle}\" value=\"${self.even}\"/>"
+            code << "</c:when><c:otherwise>"
+            code << "<c:set var=\"#{toggle}\" value=\"${self.odd}\"/>"
+            code << "</c:otherwise></c:choose>"
           else
-            sb = "<c:set var=\"#{toggle}\" value=\"${#{status}.count%2==0 ? #{self.even} : #{self.odd}}\" />"
-            stmt_list << NativeStatement.new(sb)
+            code << "<c:set var=\"#{toggle}\" value=\"${#{status}.count%2==0 ? #{self.even} : #{self.odd}}\"/>"
           end
         end
-        stmt_list  <<  build_print_stmt(stag_info, attr_info, append_exprs)   if is_foreach
-        stmt_list.concat(cont_stmts)
-        stmt_list  <<  build_print_stmt(etag_info, nil, nil)                  if is_foreach
-        stmt_list  <<  NativeStatement.new("</c:forEach>", :foreach)
-        stmt_list  <<  build_print_stmt(etag_info, nil, nil)                  if !is_foreach
+        end_code = "</c:forEach>"
+        if is_foreach
+          wrap_element_with_native_stmt(stmt_list, arg, code, end_code, :set)
+        else
+          wrap_content_with_native_stmt(stmt_list, arg, code, end_code, :set)
+        end
 
       when :while, :loop
-        raise convert_error("'#{d_str}': jstl doesn't support '#{d_arg}' directive.", stag_info.linenum)
+        msg = "'#{d_str}': jstl doesn't support '#{d_arg}' directive."
+        raise convert_error(msg, arg.stag_info.linenum)
 
       when :set
         unless d_arg =~ /\A(\S+)\s*=\s*(.*)\z/
-          raise convert_error("'#{d_str}': invalid argument.", stag_info.linenum)
+          raise convert_error("'#{d_str}': invalid argument.", arg.stag_info.linenum)
         end
         lhs = $1;  rhs = $2
-        sb = "<c:set var=\"#{lhs}\" value=\"${#{rhs}}\" />"
-        stmt_list << NativeStatement.new(sb, :set)
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
-        stmt_list.concat(cont_stmts)
-        stmt_list << build_print_stmt(etag_info, nil, nil)
+        code = "<c:set var=\"#{lhs}\" value=\"${#{rhs}}\"/>"
+        wrap_element_with_native_stmt(stmt_list, arg, code, nil, :set)
+        #code = "<c:set var=\"#{lhs}\" value=\"${#{rhs}}\"/>"
+        #stmt_list << NativeStatement.new(code, :set)
+        #stmt_list << stag_stmt(arg)
+        #stmt_list.concat(cont_stmts)
+        #stmt_list << etag_stmt(arg)
 
       when :if
-        sb = "<c:choose><c:when test=\"${#{d_arg}}\">"
-        stmt_list << NativeStatement.new(sb, :if)
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
-        stmt_list.concat(cont_stmts)
-        stmt_list << build_print_stmt(etag_info, nil, nil)
-        stmt_list << NativeStatement.new("</c:when></c:choose>", :if)
+        start_code = "<c:choose><c:when test=\"${#{d_arg}}\">"
+        end_code   = "</c:when></c:choose>"
+        wrap_element_with_native_stmt(stmt_list, arg, start_code, end_code, :if)
+        #stmt_list << NativeStatement.new(start_code, :if)
+        #stmt_list << stag_stmt(arg)
+        #stmt_list.concat(cont_stmts)
+        #stmt_list << etag_stmt(arg)
+        #stmt_list << NativeStatement.new(end, :if)
 
       when :elseif, :else
-        unless !stmt_list.empty? && (st=stmt_list[-1]).is_a?(NativeStatement) && (st.kind == :if || st.kind == :elseif)
-          raise convert_error("'#{d_str}': previous statement should be 'if' or 'elseif'.", stag_info.linenum)
-        end
+        error_when_last_stmt_is_not_if(stmt_list, arg)
         stmt_list.pop    # delete '</c:when></c:choose>'
         if d_name == :else
           kind = :else
-          sb = "</c:when><c:otherwise>"
-          stmt_list << NativeStatement.new(sb, :else)
-          sb = "</c:otherwise></c:choose>"
+          start_code = "</c:when><c:otherwise>"
+          end_code   = "</c:otherwise></c:choose>"
         else
           kind = :elseif
-          sb = "</c:when><c:when test=\"${#{d_arg}}\">"
-          stmt_list << NativeStatement.new(sb, :elseif)
-          sb = "</c:when></c:choose>"
+          start_code = "</c:when><c:when test=\"${#{d_arg}}\">"
+          end_code   = "</c:when></c:choose>"
         end
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
-        stmt_list.concat(cont_stmts)
-        stmt_list << build_print_stmt(etag_info, nil, nil)
-        stmt_list << NativeStatement.new(sb, kind)
+        wrap_element_with_native_stmt(stmt_list, arg, start_code, end_code, kind)
+        #stmt_list << NativeStatement.new(start_code, kind)
+        #stmt_list << stag_stmt
+        #stmt_list.concat(cont_stmts)
+        #stmt_list << etag_stmt
+        #stmt_list << NativeStatement.new(end_code, kind)
 
       when :default, :Default, :DEFAULT
-        error_if_empty_tag(stag_info, etag_info, d_name, d_arg)
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
+        error_if_empty_tag(arg)
+        stmt_list << stag_stmt(arg)
         flag_escape = d_name == :default ? nil : (d_name == :Default)
-        argstr = cont_stmts[0].args[0]
-        sb =  "<c:out value=\"${#{d_arg}}\""
-        sb << " escapeXml=\"#{flag_escape}\"" unless flag_escape == nil
-        sb << " default=#{argstr.dump} />"
-        stmt_list << NativeStatement.new_without_newline(sb)
-        stmt_list << build_print_stmt(etag_info, nil, nil)
+        argstr = arg.cont_stmts[0].args[0]
+        code =  "<c:out value=\"${#{d_arg}}\""
+        code << " escapeXml=\"#{flag_escape}\"" unless flag_escape == nil
+        code << " default=\"#{argstr}\"/>"
+        stmt_list << NativeStatement.new_without_newline(code)
+        stmt_list << etag_stmt(arg)
 
       when :catch
         if d_arg && !d_arg.empty? && d_arg !~ /\A\w+\z/
-          raise convert_error("'#{d_str}': invalid varname.", stag_info.linenum)
+          raise convert_error("'#{d_str}': invalid varname.", arg.stag_info.linenum)
         end
-        sb = "<c:catch"
-        sb << " var=\"#{d_arg}\"" if d_arg && !d_arg.empty?
-        sb << ">"
-        stmt_list << NativeStatement.new(sb)
-        stmt_list.concat(cont_stmts)
+        code = "<c:catch"
+        code << " var=\"#{d_arg}\"" if d_arg && !d_arg.empty?
+        code << ">"
+        stmt_list << NativeStatement.new(code)
+        stmt_list.concat(arg.cont_stmts)
         stmt_list << NativeStatement.new("</c:catch>")
 
       when :forEach, :forTokens
-        stag, etag = eval "handle_jstl_#{d_name}(#{d_arg})"
-        stmt_list << NativeStatement.new(stag)
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
-        stmt_list.concat(cont_stmts)
-        stmt_list << build_print_stmt(etag_info, nil, nil)
-        stmt_list << NativeStatement.new(etag)
+        options = eval "{ #{d_arg} }"
+        stag, etag = self.__send__ "handle_jstl_#{d_name}", options
+        wrap_element_with_native_stmt(stmt_list, arg, stag, etag, nil)
+        #stmt_list << NativeStatement.new(stag)
+        #stmt_list << stag_stmt
+        #stmt_list.concat(cont_stmts)
+        #stmt_list << etag_stmt
+        #stmt_list << NativeStatement.new(etag)
 
       when :redirect, :import, :url, :remove
-        lines = eval "handle_jstl_#{d_name}(#{d_arg})"
+        options = eval "{ #{d_arg} }"
+        lines = self.__send__ "handle_jstl_#{d_name}", options
         lines.each do |line|
-          stmt_list << NativeStatement.new(line)
+          stmt_list << NativeStatement.new(line.chomp)
         end
 
       else
@@ -216,39 +222,48 @@ module Kwartz
 
 
     def _handle_jstl_params(tagname, param_list, options)
-      stag, etag = _handle_jstl_tag(tagname, param_list, options)
-      lines = [stag]
+      stag, etag = _handle_jstl_tag(tagname, param_list, options, true)
       i = 0
-      options.each do |name, value|
-        i += 1
-        if value.is_a?(Symbol)
-          lines << " <c:param name=\"#{name}\" value=\"${#{value}}\"/>"
-        else
-          #lines << " <c:param name=\"#{name}\" value=\"#{value}\"/>"
-        end
-      end
-      if i == 0
-        stag.sub!(/>\z/, '/>')
+      unknown_param_names = options.keys - param_list
+      lines = []
+      if unknown_param_names.empty?
+        lines << stag.sub(/>\z/, '/>')
       else
+        lines << stag
+        unknown_param_names.each do |name|
+          value = options[name]
+          if value.is_a?(Symbol)
+            lines << " <c:param name=\"#{name}\" value=\"${#{value}}\"/>"
+          else
+            lines << " <c:param name=\"#{name}\" value=\"#{value}\"/>"
+          end
+        end
         lines << etag
       end
-      return lines
+      return lines.join("\n")
     end
 
 
-    def _handle_jstl_tag(tagname, param_list, options)
-      sb = "<c:#{tagname}"
-      param_list.each do |param|
-        key = nil
-        if options.key?(param.intern) ; key = param.intern
-        elsif options.key?(param)     ; key = param
+    def _handle_jstl_tag(tagname, param_list, options, ignore_unknown_option=false)
+      options.each do |name, value|
+        next if name.is_a?(String)
+        options[name.to_s] = options.delete(name)
+      end
+      option_names = options.keys
+      unless ignore_unknown_option
+        unkown_option_names = option_names - param_list
+        unless unkown_option_names.empty?
+          msg = "'#{unkown_option_names[0]}': unknown option for '#{tagname}' directive."
+          raise convert_error(msg, nil)   # TODO
         end
-        next if key == nil
-        value = options.delete(key)
+      end
+      sb = "<c:#{tagname}"
+      (param_list & option_names).each do |name|
+        value = options[name]
         if value.is_a?(Symbol)
-          sb << " #{param}=\"${#{value}}\""
+          sb << " #{name}=\"${#{value}}\""
         else
-          sb << " #{param}=\"#{value}\""
+          sb << " #{name}=\"#{value}\""
         end
       end
       sb << ">"
@@ -289,7 +304,7 @@ module Kwartz
 
 
     def initialize(properties={})
-      jstl_ver = properties[:jstl] || 1.2
+      jstl_ver = properties[:jstl] || Config::PROPERTY_JSTL
       super(jstl_ver < 1.2 ? JSTL11_EMBED_PATTERNS : JSTL12_EMBED_PATTERNS, properties)
       @jstl_ver = jstl_ver
       unless self.header

data/lib/kwartz/binding/php.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 116 $
-### $Release: 3.0.0 $
+### $Rev: 123 $
+### $Release: 3.1.0 $
 ### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
 ###
 
@@ -41,85 +41,104 @@ module Kwartz
     end
 
 
-    def handle(directive_name, directive_arg, directive_str, stag_info, etag_info, cont_stmts, attr_info, append_exprs, stmt_list)
+    def handle(stmt_list, handler_arg)
       ret = super
       return ret if ret
 
-      d_name = directive_name
-      d_arg  = directive_arg
-      d_str  = directive_str
+      arg = handler_arg
+      d_name = arg.directive_name
+      d_arg  = arg.directive_arg
+      d_str  = arg.directive_str
 
-      case directive_name
+      case d_name
 
       when :foreach, :Foreach, :FOREACH, :list, :List, :LIST
         is_foreach = d_name == :foreach || d_name == :Foreach || d_name == :FOREACH
         unless d_arg =~ /\A.*\s+as\s+(\$\w+)(?:\s*=>\s*\$\w+)?\z/
-          raise convert_error("'#{d_str}': invalid argument.", stag_info.linenum)
+          raise convert_error("'#{d_str}': invalid argument.", arg.stag_info.linenum)
         end
         loopvar = $1
         counter = d_name == :foreach || d_name == :list ? nil : "#{loopvar}_ctr"
         toggle  = d_name != :FOREACH && d_name != :LIST ? nil : "#{loopvar}_tgl"
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)   if !is_foreach
-        stmt_list << NativeStatement.new("#{counter} = 0;") if counter
-        stmt_list << NativeStatement.new("foreach (#{d_arg}) {", :foreach)
-        stmt_list << NativeStatement.new("  #{counter}++;") if counter
-        stmt_list << NativeStatement.new("  #{toggle} = #{counter}%2==0 ? #{self.even} : #{self.odd};") if toggle
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)   if is_foreach
-        stmt_list.concat(cont_stmts)
-        stmt_list << build_print_stmt(etag_info, nil, nil)                  if is_foreach
-        stmt_list << NativeStatement.new("}", :foreach)
-        stmt_list << build_print_stmt(etag_info, nil, nil)                  if !is_foreach
-
-      when :while, :loop
-        is_while = d_name == :while
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)   if !is_while
-        stmt_list << NativeStatement.new("while (#{d_arg}) {", :while)
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)   if is_while
-        stmt_list.concat(cont_stmts)
-        stmt_list << build_print_stmt(etag_info, nil, nil)                  if is_while
-        stmt_list << NativeStatement.new("}", :while)
-        stmt_list << build_print_stmt(etag_info, nil, nil)                  if !is_while
+        code = []
+        code << "#{counter} = 0;"            if counter
+        code << "foreach (#{d_arg}) {"
+        code << "  #{counter}++;"            if counter
+        code << "  #{toggle} = #{counter}%2==0 ? #{@even} : #{@odd};" if toggle
+        if is_foreach
+          wrap_element_with_native_stmt(stmt_list, arg, code, "}", :foeach)
+        else
+          wrap_content_with_native_stmt(stmt_list, arg, code, "}", :foeach)
+        end
+        #stmt_list << stag_stmt(arg)   if !is_foreach
+        #stmt_list << NativeStatement.new("#{counter} = 0;") if counter
+        #stmt_list << NativeStatement.new("foreach (#{d_arg}) {", :foreach)
+        #stmt_list << NativeStatement.new("  #{counter}++;") if counter
+        #stmt_list << NativeStatement.new("  #{toggle} = #{counter}%2==0 ? #{self.even} : #{self.odd};") if toggle
+        #stmt_list << stag_stmt(arg)   if is_foreach
+        #stmt_list.concat(arg.cont_stmts)
+        #stmt_list << etag_stmt(arg)   if is_foreach
+        #stmt_list << NativeStatement.new("}", :foreach)
+        #stmt_list << etag_stmt(arg)   if !is_foreach
+
+      when :while
+        wrap_element_with_native_stmt(stmt_list, arg, "while (#{d_arg}) {", "}", :while)
+        #stmt_list << NativeStatement.new("while (#{d_arg}) {", :while)
+        #stmt_list << stag_stmt
+        #stmt_list.concat(cont_stmts)
+        #stmt_list << etag_stmt
+        #stmt_list << NativeStatement.new("}", :while)
+
+      when :loop
+        error_if_empty_tag(arg)
+        wrap_content_with_native_stmt(stmt_list, arg, "while (#{d_arg}) {", "}", :while)
+        #stmt_list << stag_stmt
+        #stmt_list << NativeStatement.new("while (#{d_arg}) {", :while)
+        #stmt_list.concat(cont_stmts)
+        #stmt_list << NativeStatement.new("}", :while)
+        #stmt_list << etag_stmt
 
       when :set
-        stmt_list << NativeStatement.new("#{d_arg};", :set)
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
-        stmt_list.concat(cont_stmts)
-        stmt_list << build_print_stmt(etag_info, nil, nil)
+        wrap_element_with_native_stmt(stmt_list, arg, "#{d_arg};", nil, :set)
+        #stmt_list << NativeStatement.new("#{d_arg};", :set)
+        #stmt_list << stag_stmt
+        #stmt_list.concat(cont_stmts)
+        #stmt_list << etag_stmt
 
       when :if
-        stmt_list << NativeStatement.new("if (#{d_arg}) {", :if)
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
-        stmt_list.concat(cont_stmts)
-        stmt_list << build_print_stmt(etag_info, nil, nil)
-        stmt_list << NativeStatement.new("}", :if)
+        wrap_element_with_native_stmt(stmt_list, arg, "if (#{d_arg}) {", "}", :if)
+        #stmt_list << NativeStatement.new("if (#{d_arg}) {", :if)
+        #stmt_list << stag_stmt
+        #stmt_list.concat(cont_stmts)
+        #stmt_list << etag_stmt
+        #stmt_list << NativeStatement.new("}", :if)
 
       when :elseif, :else
-        unless !stmt_list.empty? && (st=stmt_list[-1]).is_a?(NativeStatement) && (st.kind == :if || st.kind == :elseif)
-          raise convert_error("'#{d_str}': previous statement should be 'if' or 'elsif'.", stag_info.linenum)
-        end
-        stmt_list.pop    # delete 'end'
-        if d_name == :else
-          kind = :else
-          stmt_list << NativeStatement.new("} else {", :else)
-        else
-          kind = :elseif
-          stmt_list << NativeStatement.new("} elseif (#{d_arg}) {", :elseif)
-        end
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
-        stmt_list.concat(cont_stmts)
-        stmt_list << build_print_stmt(etag_info, nil, nil)
-        stmt_list << NativeStatement.new("}", kind)
+        error_when_last_stmt_is_not_if(stmt_list, arg)
+        stmt_list.pop    # delete '}'
+        kind = d_name == :else ? :else : :elseif
+        code = d_name == :else ? "} else {" : "} elseif (#{d_arg}) {"
+        wrap_element_with_native_stmt(stmt_list, arg, code, "}", kind)
+        #stmt_list << NativeStatement.new(code, kind)
+        #stmt_list << stag_stmt
+        #stmt_list.concat(cont_stmts)
+        #stmt_list << etag_stmt
+        #stmt_list << NativeStatement.new("}", kind)
 
       when :default, :Default, :DEFAULT
-        error_if_empty_tag(stag_info, etag_info, d_name, d_arg)
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
-        stmt_list << NativeStatement.new_without_newline("if (#{d_arg}) {", :if)
+        error_if_empty_tag(arg)
+        expr_code = d_arg
         flag_escape = d_name == :default ? nil : (d_name == :Default)
-        stmt_list << PrintStatement.new([ NativeExpression.new(d_arg, flag_escape) ])
-        stmt_list << NativeStatement.new_without_newline("} else {", :else)
-        stmt_list.concat(cont_stmts)
-        stmt_list << NativeStatement.new_without_newline("}", :else)
-        stmt_list << build_print_stmt(etag_info, nil, nil)
+        add_native_expr_with_default(stmt_list, arg, expr_code, flag_escape,
+                                     "if (#{d_arg}) {", "} else {", "}")
+        #stmt_list << stag_stmt(arg)
+        #stmt_list << NativeStatement.new_without_newline("if (#{d_arg}) {", :if)
+        #flag_escape = d_name == :default ? nil : (d_name == :Default)
+        #stmt_list << PrintStatement.new([ NativeExpression.new(d_arg, flag_escape) ])
+        #stmt_list << NativeStatement.new_without_newline("} else {", :else)
+        #stmt_list.concat(arg.cont_stmts)
+        #stmt_list << NativeStatement.new_without_newline("}", :else)
+        #stmt_list << etag_stmt(arg)
 
       else
         return false