# File lib/kwartz/binding/jstl.rb, line 85
    def handle(directive, elem_info, stmt_list)
      ret = super
      return ret if ret

      d_name = directive.name
      d_arg  = directive.arg
      d_str  = directive.str
      e = elem_info

      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(elem_info, d_str) unless is_foreach
        unless d_arg =~ /\A(\w+)\s*:\s*(.*)\z/
          raise convert_error("'#{d_str}': invalid argument.", elem_info.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"
        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
            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
            code << "<c:set var=\"#{toggle}\" value=\"${#{status}.count%2==0 ? #{self.even} : #{self.odd}}\"/>"
          end
        end
        end_code = "</c:forEach>"
        if is_foreach
          wrap_element_with_native_stmt(elem_info, stmt_list, code, end_code, :set)
        else
          wrap_content_with_native_stmt(elem_info, stmt_list, code, end_code, :set)
        end

      when :while, :loop
        msg = "'#{d_str}': jstl doesn't support '#{d_arg}' directive."
        raise convert_error(msg, elem_info.stag_info.linenum)

      when :set
        unless d_arg =~ /\A(\S+)\s*=\s*(.*)\z/
          raise convert_error("'#{d_str}': invalid argument.", elem_info.stag_info.linenum)
        end
        lhs = $1;  rhs = $2
        code = "<c:set var=\"#{lhs}\" value=\"${#{rhs}}\"/>"
        wrap_element_with_native_stmt(elem_info, stmt_list, code, nil, :set)
        #code = "<c:set var=\"#{lhs}\" value=\"${#{rhs}}\"/>"
        #stmt_list << NativeStatement.new(code, :set)
        #stmt_list << stag_stmt(elem_info)
        #stmt_list.concat(cont_stmts)
        #stmt_list << etag_stmt(elem_info)

      when :if
        start_code = "<c:choose><c:when test=\"${#{d_arg}}\">"
        end_code   = "</c:when></c:choose>"
        wrap_element_with_native_stmt(elem_info, stmt_list, start_code, end_code, :if)
        #stmt_list << NativeStatement.new(start_code, :if)
        #stmt_list << stag_stmt(elem_info)
        #stmt_list.concat(cont_stmts)
        #stmt_list << etag_stmt(elem_info)
        #stmt_list << NativeStatement.new(end, :if)

      when :elseif, :else
        error_when_last_stmt_is_not_if(elem_info, d_str, stmt_list)
        stmt_list.pop    # delete '</c:when></c:choose>'
        if d_name == :else
          kind = :else
          start_code = "</c:when><c:otherwise>"
          end_code   = "</c:otherwise></c:choose>"
        else
          kind = :elseif
          start_code = "</c:when><c:when test=\"${#{d_arg}}\">"
          end_code   = "</c:when></c:choose>"
        end
        wrap_element_with_native_stmt(elem_info, stmt_list, 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(elem_info, d_str)
        stmt_list << stag_stmt(elem_info)
        flag_escape = d_name == :default ? nil : (d_name == :Default)
        argstr = elem_info.cont_stmts[0].args[0]
        expr_str = directive.dattr == 'id' ? parse_expr_str(d_arg, e.stag_info.linenum) : d_arg
        code =  "<c:out value=\"${#{expr_str}}\""
        code << " escapeXml=\"#{flag_escape}\"" unless flag_escape == nil
        code << " default=\"#{argstr}\"/>"
        stmt_list << NativeStatement.new_without_newline(code)
        stmt_list << etag_stmt(elem_info)

      when :catch
        if d_arg && !d_arg.empty? && d_arg !~ /\A\w+\z/
          raise convert_error("'#{d_str}': invalid varname.", elem_info.stag_info.linenum)
        end
        code = "<c:catch"
        code << " var=\"#{d_arg}\"" if d_arg && !d_arg.empty?
        code << ">"
        stmt_list << NativeStatement.new(code)
        stmt_list.concat(elem_info.cont_stmts)
        stmt_list << NativeStatement.new("</c:catch>")

      when :forEach, :forTokens
        options = eval "{ #{d_arg} }"
        stag, etag = self.__send__ "handle_jstl_#{d_name}", options
        wrap_element_with_native_stmt(elem_info, stmt_list, 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
        options = eval "{ #{d_arg} }"
        lines = self.__send__ "handle_jstl_#{d_name}", options
        lines.each do |line|
          stmt_list << NativeStatement.new(line.chomp)
        end

      else
        return false

      end #case
      return true

    end