# File lib/kwartz/converter.rb, line 772
    def handle(directive, elem_info, stmt_list)
      d_name = directive.name
      d_arg  = directive.arg
      d_str  = directive.str
      d_attr = directive.dattr
      e = elem_info
      linenum = e.stag_info.linenum

      case d_name

      when nil
        assert false

      when :dummy
        # nothing

      when :id, :mark
        unless d_arg =~ /\A([-\w]+)\z/ || d_arg =~ /\A'([-\w]+)'\z/
          raise convert_error("'#{d_str}': invalid marking name.", linenum)
        end
        name = $1
        if get_element_info(name)
          unless Config::ALLOW_DUPLICATE_ID
            previous_linenum = get_element_info(name).stag_info.linenum
            msg = "'#{d_str}': id '#{name}' is already used at line #{previous_linenum}."
            raise convert_error(msg, linenum)
          end
        end
        ruleset = get_ruleset('#' + name)
        elem_info.apply(ruleset) if ruleset
        register_element_info(name, elem_info)
        #stmt_list << ExpandStatement.new(:element, name)     # lazy expantion
        expand_element_info(elem_info, stmt_list)

      when :stag, :Stag, :STAG
        error_if_empty_tag(elem_info, d_str)
        flag_escape = d_name == :stag ? nil : (d_name == :Stag)
        expr_str = d_attr == 'id' ? parse_expr_str(d_arg, linenum) : d_arg
        expr = NativeExpression.new(expr_str, flag_escape)
        stmt_list << build_print_expr_stmt(expr, e.stag_info, nil)
        stmt_list.concat(e.cont_stmts)
        stmt_list << etag_stmt(elem_info)

      when :etag, :Etag, :ETAG
        error_if_empty_tag(elem_info, d_str)
        flag_escape = d_name == :etag ? nil : (d_name == :Etag)
        expr_str = d_attr == 'id' ? parse_expr_str(d_arg, linenum) : d_arg
        expr = NativeExpression.new(expr_str, flag_escape)
        stmt_list << stag_stmt(elem_info)
        stmt_list.concat(e.cont_stmts)
        stmt_list << build_print_expr_stmt(expr, nil, e.etag_info)

      when :elem, :Elem, :ELEM
        flag_escape = d_name == :elem ? nil : (d_name == :Elem)
        expr_str = d_attr == 'id' ? parse_expr_str(d_arg, linenum) : d_arg
        expr = NativeExpression.new(expr_str, flag_escape)
        stmt_list << build_print_expr_stmt(expr, e.stag_info, e.etag_info)

      when :cont, :Cont, :CONT, :value, :Value, :VALUE
        error_if_empty_tag(elem_info, directive.str)
        e.stag_info.tail_space = e.etag_info.head_space = nil    # delete spaces
        pargs = build_print_args(e.stag_info, e.attr_info, e.append_exprs)
        flag_escape = (d_name == :cont || d_name == :value) ? nil : (d_name == :Cont || d_name == :Value)
        expr_str = d_attr == 'id' ? parse_expr_str(d_arg, linenum) : d_arg
        pargs << NativeExpression.new(expr_str, flag_escape)
        pargs << e.etag_info.tag_text if e.etag_info.tagname
        stmt_list << PrintStatement.new(pargs)

      when :attr, :Attr, :ATTR
        unless d_arg =~ self.mapping_pattern()     # ex. /\A'([-:\w]+)'\s+(.*)\z/
          raise convert_error("'#{d_str}': invalid attr pattern.", linenum)
        end
        aname = $1;  avalue = $2
        flag_escape = d_name == :attr ? nil : (d_name == :Attr)
        expr_str = d_attr == 'id' ? parse_expr_str(avalue, linenum) : avalue
        e.attr_info[aname] = NativeExpression.new(expr_str, flag_escape)

      when :append, :Append, :APPEND
        flag_escape = d_name == :append ? nil : (d_name == :Append)
        expr_str = d_attr == 'id' ? parse_expr_str(d_arg, linenum) : d_arg
        e.append_exprs << NativeExpression.new(expr_str, flag_escape)

      when :replace_element_with_element, :replace_element_with_content,
           :replace_content_with_element, :replace_content_with_content
        arr = d_name.to_s.split(/_/)
        replace_cont = arr[1] == 'content'
        with_content = arr[3] == 'content'
        name = d_arg
        #
        error_if_empty_tag(elem_info, d_str)   if replace_cont
        stmt_list << stag_stmt(elem_info) if replace_cont
        #stmt_list << ExpandStatement.new(:element, name)
        elem_info2 = @elem_info_table[name]
        unless elem_info
          raise convert_error("'#{d_str}': element '#{name}' not found.", linenum)
        end
        expand_element_info(elem_info2, stmt_list, with_content)
        stmt_list << etag_stmt(elem_info) if replace_cont

      when :replace_element_with, :replace_content_with, :replace, :placeholder
        unless d_arg =~ /\A_?(element|content)\(["']?(\w+)["']?\)\z/
          raise convert_error("'#{d_str}': invalid #{d_name} format.", linenum)
        end
        kind = $1
        name = $2
        replace_cont = d_name == :replace_content_with || d_name == :placeholder
        with_content = kind == 'content'
        #
        error_if_empty_tag(elem_info, d_str) if replace_cont
        stmt_list << stag_stmt(elem_info) if replace_cont
        #stmt_list << ExpandStatement.new(:element, name)
        elem_info2 = @elem_info_table[name]
        unless elem_info2
          msg = "'#{d_str}': element '#{name}' not found."
          raise convert_error(msg, linenum)
        end
        expand_element_info(elem_info2, stmt_list, with_content)
        stmt_list << etag_stmt(elem_info) if replace_cont

      else
        return false
      end #case

      return true

    end