langhelp 0.9.8

data/lib/el4r/emacsruby/autoload/50langhelp.rb

@@ -0,0 +1,2 @@
+el4r_load "langhelp.rb"
+LangHelp::LangHelp.run

data/lib/el4r/emacsruby/langhelp.rb

@@ -0,0 +1,864 @@
+# -*- el4r -*-
+#  langhelp.rb - The EmacsRuby part of langhelp
+#  
+#  Copyright (C) 2005,2006 rubikitch <rubikitch@ruby-lang.org>
+#  Version: $Id: langhelp.rb 1363 2006-09-04 01:31:05Z rubikitch $
+
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; either version 2 of the License, or
+#  (at your option) any later version.
+#    This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#    You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require 'langhelp/langhelp-sub'
+
+module LangHelp
+  
+  module DisplayResult
+    def search_line(line)
+      search_forward "\n#{line}\n", nil, true and previous_line 1
+    end
+    
+    def search_anchor(anchor)
+      goto_char 1
+      search_forward(format(elvar.ee_anchor_format,anchor), nil, true) and forward_line 0
+    end
+    
+    def flash_line
+      if fboundp :make_overlay
+        ovl = make_overlay point_at_bol, point_at_eol
+        duration = 1
+        overlay_put ovl, :face, :highlight
+        run_at_time duration, nil, :delete_overlay, ovl
+      end
+    end
+
+    def display_result_buffer(buf, pt, x)
+      #    display_buffer buf
+      one_window_p and split_window
+      let(:pop_up_windows, true) { pop_to_buffer buf }
+      goto_char pt
+      
+      recenter((elvar.langhelp_centering || x[:centering]) ? [1] : 0)
+      if x[:flash] || elvar.langhelp_flash
+        flash_line
+      end
+
+      sit_for 0
+      other_window 1 unless elvar.langhelp_edit
+    end
+    
+    # keyword of x: :line / :anchor
+    def display_result(x={})
+      buf = nil
+      pt = nil
+      with(:save_window_excursion) do
+        yield
+        buf = current_buffer
+        if x[:line]
+          goto_char 1
+          # TODO: write test for lineno
+          if Fixnum === x[:line]
+            forward_line x[:line]-1
+          else
+            search_line x[:line]
+          end
+        elsif x[:anchor]
+          search_anchor x[:anchor]
+        elsif x[:preserve]
+          #
+        elsif !x[:w3m]
+          goto_char 1
+        end
+        pt = point
+      end
+      display_result_buffer buf, pt, x
+      buf
+    end
+    
+  end
+  
+  class FindXXX < ElApp
+    def initialize(x={})
+      name = x[:name]
+      cmd = x[:cmd]
+      
+      # lh_sh is defined at (view-fline buffer-file-name '(4988 "    defun(:lh_sh" "_view_functions\n"))
+      defun("lh-#{name}") do |arg|
+        lh_sh "#{cmd} #{arg.dump}", arg
+      end
+      
+      meth = "override_#{name}"
+      respond_to? meth and __send__ meth
+    end
+    
+    include DisplayResult
+    
+    def override_ri
+      if locate_library "ri-ruby"
+        el_load "ri-ruby"
+        defun("lh-ri") do |x|
+          display_result {
+            ri x
+            unless fboundp :with_displaying_help_buffer # for FSF Emacs
+              other_window 1
+            end
+          }
+        end
+      end
+    end
+    
+    def override_test0
+      # Mock-up for unit-test
+      defun("lh-test0") do |x|
+        newbuf(:name=>"test0", :contents=>"0\n", :display=>:pop)
+      end
+    end
+  end
+  
+  class LangHelpInternal < ElApp
+    def initialize(x)
+      @mmode = x[:major_mode]
+      @dir = x[:datadir]
+      @efile = "#{@dir}/#{@mmode}.e"
+      @header = "#{@dir}/#{@mmode}-header.e"
+      @encoding = x[:encoding] || :euc_jp
+      @buffer_ctime = 0
+      @use_frame = x[:use_frame]
+    end
+    attr_reader :mmode, :dir, :efile, :header, :buf
+    
+    def create_buffer
+      @buffer_ctime = Time.now
+      @buf = newbuf(:name => "*langhelp:#{mmode}*") do
+        let(:coding_system_for_read, @encoding) do 
+          if File.exist?(header)
+            insert_file_contents header
+            goto_char point_max
+            insert "\n\n"
+          end
+          insert_file_contents efile
+          goto_char 1
+        end
+ 
+        cd dir
+        langhelp_menu_mode
+
+        # I do not know why `hack_local_variables' in langhelp_menu_mode does not work well.
+        hack_local_variables
+        with(:save_excursion) { lh_imenu_create_index }
+      end
+      @buf
+    
+    end
+    
+    def header_is_newer_than_buffer(file=@header)
+      File.mtime(file) > @buffer_ctime
+    end
+
+    def selbuf(buf)
+      if @use_frame
+        switch_to_buffer(buf)
+        bury_buffer(buf)
+      else
+        pop_to_buffer(buf)
+      end
+    end
+    
+    def setup_buffer
+      if File.exist?(efile)
+        if @use_frame
+          langhelp_select_frame
+        else
+          winconf_push
+        end
+        if buffer_live_p(@buf) and not header_is_newer_than_buffer
+          selbuf @buf
+        else
+          selbuf create_buffer
+        end
+        yield(@buf)
+      end
+    end
+  end                           # /LangHelpInternal
+  
+  class LangHelp < ElApp
+    def key_binding_default
+      {
+##### [key_binding]
+        'n' => :next_line,
+        'p' => :previous_line,
+
+        ## vi-like cursor movement
+        'j' => :next_line,
+        'k' => :previous_line,
+
+        ## follow the link
+        # [EVAL IT] (describe-function 'lh-goto-link)
+        # [EVAL IT] (describe-function 'lh-goto-link-centering)
+        # [EVAL IT] (describe-function 'lh-goto-link-edit)
+        'l' => :lh_goto_link,   
+        '\C-m' => :lh_goto_link,
+        ';' => :lh_goto_link_centering, 
+        'C' => :lh_goto_link_centering,
+        'L' => :lh_goto_link_centering,
+        'o' => :lh_goto_link_edit, 
+        ## Kill help buffer
+        # [EVAL IT] (describe-function 'lh-kill-link)
+        'D' => :lh_kill_link,   
+        'K' => :lh_kill_link,
+
+
+        ## Restore window configuration before langhelp-call.
+        '\C-c\C-c' => :winconf_pop,
+        'h' => :winconf_pop,
+
+        ## scroll the langhelp buffer
+        ' ' => :scroll_up,
+        'b' => :scroll_down,
+
+        '/' => :isearch_forward,
+        's' => :isearch_forward,
+        'g' => :beginning_of_buffer,
+
+        ## scroll help buffer (under the langhelp buffer) 
+        # [EVAL IT] (describe-function 'scroll-other-window)
+        # [EVAL IT] (describe-function 'scroll-other-window-down)
+        'v' => :scroll_other_window, 
+        'c' => :scroll_other_window_down, 
+
+        ## Update langhelp buffer
+        # [EVAL IT] (describe-function 'langhelp-revert-buffer)
+        'R' => :langhelp_revert_buffer, 
+
+        ## bm.el : buffer bookmark.
+        # [EVAL IT] (describe-function 'bm-toggle)
+        # [EVAL IT] (describe-function 'bm-previous)
+        # [EVAL IT] (describe-function 'bm-next)
+        'm' => :bm_toggle,  
+        'u' => :bm_toggle,
+        'P' => :bm_previous, 
+        'N' => :bm_next,        
+
+        ## show full index
+        # [EVAL IT] (describe-function 'langhelp-switch-to-index-buffer)
+        'd' => :langhelp_switch_to_index_buffer, 
+
+        ## narrowing
+        # [EVAL IT] (describe-function 'langhelp-toggle-narrowing)
+        '\C-c\C-n' => :langhelp_toggle_narrowing, 
+
+        ## exclude
+        # [EVAL IT] (describe-function 'flush-lines)
+        'V' => :flush_lines_whole_buffer,
+        'G' => :keep_lines_whole_buffer,
+
+##### [/key_binding]
+      }
+    end
+    
+    attr :conf
+    
+    def initialize(x={})
+      el_require :info
+      el_require :cl
+      funcall :put, :ee_anchor_format, :safe_local_variable, :stringp
+      define_faces
+      defun_langhelp_update x
+      langhelp_update
+      
+      defun_langhelp_menu_mode
+      defun_langhelp_setup_index_buffer
+      setup_man
+      setup_w3m
+      defun_langhelp_occur
+      langhelp_setup_index_buffer
+
+      defalias :lh, :progn
+   end
+
+    def define_faces
+      el4r_lisp_eval <<-EOL
+        (progn
+          (defface langhelp-sexp-face '((t (:foreground "SteelBlue" :underline t))) nil)
+          (defface langhelp-title-face '((t (:background "white" :foreground "black"))) nil)
+          (setq langhelp-sexp-face 'langhelp-sexp-face)
+
+          (setq langhelp-title-face 'langhelp-title-face)
+        )
+      EOL
+      
+    end
+
+    def setup_font_lock
+      el4r_lisp_eval <<-'EOL'
+        (progn
+          (setq langhelp-font-lock-keywords
+                (list
+                 '("^[^\n]+\\((lh[^\n]+)\\)$"
+                   1 langhelp-sexp-face)
+                 '("^[^\n]+<<.+>>[^\n]*$"
+                   0 langhelp-title-face)
+                 ))
+
+          (make-local-variable 'font-lock-defaults)
+          (setq font-lock-defaults '((langhelp-font-lock-keywords) t nil))
+          (make-local-variable 'font-lock-keywords)
+          (setq font-lock-keywords langhelp-font-lock-keywords)
+          (turn-on-font-lock)
+          )
+      EOL
+      # '
+    end
+
+    INDEX_BUFFER = "*langhelp index*"
+    def defun_langhelp_update(x)
+      defun(:langhelp_update, :interactive=>true) do
+        langhelprc = x[:langhelprc] || File.expand_path("~/.langhelp/config")
+        @conf = ConfigScript.new langhelprc
+        @use_frame = elvar.window_system && !@conf[:NO_FRAME]
+        
+        conf.lang.each do |name, params|
+          Array[params].flatten.each do |x|
+            case x
+            when Hash
+              if x[:Info]
+                info_file = x[:Info]
+                dir = File.dirname(File.expand_path(info_file))
+                add_to_list :Info_directory_list, dir
+              else
+                command_klass, t = x.find{|k,v| k.to_s =~ %r/^[A-Z]/ and v == true }
+                command_klass = command_klass.to_s
+                if command_klass
+                  cmd = command_klass.downcase
+                  FindXXX.run(:name=>cmd, :cmd=>(x[:cmd] || cmd))
+                end
+              end
+            end
+          end
+        end
+
+        @alias2base = Hash.new{|hash,k|k}
+        conf.aliases.each do |base, aliases|
+          aliases.each do |ali|
+            @alias2base[ali] = base
+          end
+        end
+      end
+    end
+    
+    def set_tab_width
+      tw = conf[:TAB_WIDTH]
+      if tw
+        elvar.tab_width = if tw <= 0
+                            frame_width + tw
+                          else
+                            tw
+                          end
+      end
+    end
+
+    
+    def set_which_func
+      if locate_library "which-func"
+        el_require :which_func
+        add_to_list :which_func_modes, :langhelp_menu_mode
+      end
+    end
+
+    def defun_langhelp_menu_mode
+      set_which_func
+      defvar(:ee_anchor_format, "<<%s>>")
+
+      defvar(:langhelp_revert_buffer_function, nil)
+      define_derived_mode(:langhelp_menu_mode, :fundamental_mode, "LH",
+                          "Major mode for selecting a langhelp link.") do
+        setup_font_lock
+        make_local_variable :langhelp_revert_buffer_function
+        elvar.truncate_lines = true
+        make_local_variable :outline_regexp
+        elvar.outline_regexp = '####\|# Node:'
+        make_local_variable :kill_whole_line
+        elvar.kill_whole_line = true
+        elvar.imenu_create_index_function = :lh_imenu_create_index
+        elvar.header_line_format = el4r_lisp_eval %('(which-func-mode ("" which-func-format))) # '
+        set_tab_width
+        which_func_mode 1 if fboundp :which_func_mode
+        hl_line_mode 1 if fboundp :hl_line_mode
+      end
+      
+      suppress_keymap elvar.langhelp_menu_mode_map
+      key_binding = key_binding_default.update(conf[:KEY_BINDING] || {})
+      key_binding.each do |key, cmd|
+        define_key(:langhelp_menu_mode_map, key, cmd)
+      end
+      define_key :isearch_mode_map, (conf.isearch_occur_key || '\C-o'), :langhelp_isearch_occur
+      define_key :global_map, conf.langhelp_key, :langhelp if conf.langhelp_key
+      
+    end
+    
+    defun(:lh_goto_link, :interactive=>true,
+          :docstring=>"Follow link in this line and put point on screen top.
+Internally eval sexp at the EOL.") do
+      b = current_buffer
+      end_of_line
+      backward_sexp
+      sexp = funcall :read, current_buffer
+      beginning_of_line
+      pt = point
+      funcall :eval, sexp
+    end
+    
+    defvar(:langhelp_centering, nil)
+    defvar(:langhelp_flash, nil)
+    defun(:lh_goto_link_centering, :interactive=>true,
+          :docstring=>"Follow link in this line and center point in window.") do
+      let(:langhelp_centering, true,
+          :langhelp_flash, true) do
+        lh_goto_link
+      end
+    end
+
+    defvar(:langhelp_edit, nil)
+    defun(:lh_goto_link_edit, :interactive=>true,
+          :docstring=>"Follow link in this line and select the help window to edit.") do
+      let(:langhelp_edit, true,
+          :langhelp_centering, true) do
+        lh_goto_link
+      end
+    end
+    
+    defun(:lh_kill_link, :interactive=>true,
+          :docstring=>"Kill the help window buffer.") do
+      with(:save_selected_window) do
+        other_window 1
+        kill_this_buffer
+      end
+    end
+
+    el4r_lisp_eval %q(
+                       (defun lh-imenu-create-index ()
+                         (goto-char 1)
+                         (let ((search-re (format ee-anchor-format "\\\\(.+\\\\)"))
+                               alist a p)
+                           (while (re-search-forward search-re nil t)
+                             (setq a (match-string 1)
+                                   p (match-beginning 0))
+                             (unless (string= a "%s")
+                               (setq alist (cons (cons a p) alist))))
+                           (setq imenu--index-alist alist))
+                         nil))
+
+    import_function :byte_compile
+    byte_compile :lh_imenu_create_index
+
+    defun(:langhelp_switch_to_index_buffer, :interactive=>true,
+          :docstring=>"Switch to *langhelp index* buffer.") do
+      unless get_buffer INDEX_BUFFER
+        langhelp_setup_index_buffer
+      end
+      switch_to_buffer INDEX_BUFFER
+      goto_char 1
+    end
+
+    # todo EGREP
+    defun(:flush_lines_whole_buffer,
+          :docstring=>"Delete lines containing matches for REGEXP.",
+          :interactive=>lambda{keep_lines_read_args("Flush lines (containing match for regexp): ")}) do |re|
+      with(:save_restriction) do
+        widen
+        flush_lines re, 1, point_max_marker
+      end
+    end
+
+    defun(:keep_lines_whole_buffer,
+          :docstring=>"Delete all lines except those containing matches for REGEXP.",
+          :interactive=>lambda{keep_lines_read_args("Keep lines (containing match for regexp): ")}) do |re|
+      with(:save_restriction) do
+        widen
+        keep_lines re, 1, point_max_marker
+      end
+    end
+
+
+
+    def real_mmode
+      @alias2base[symbol_name(getq(:major_mode)).sub(/-mode/, '')]
+    end
+
+    defun(:langhelp, :interactive=>"p",
+          :docstring=>"Open the langhelp buffer according to major-mode and prepare isearch.
+With prefix arg, open the *langhelp index* buffer instead of major-mode's langhelp buffer.") do |narg|
+      #      mmode = symbol_name(getq(:major_mode)).sub(/-mode/, '').gsub(/-/,'_')
+      mmode = real_mmode 
+      if narg == 16
+        langhelp_at_point
+      elsif [1,nil].include?(narg) and conf.lang[mmode]
+        i = LangHelpInternal.new(:major_mode=>mmode, :datadir=>conf[:LANGHELP_HOME], :encoding=>conf[:ENCODING], :use_frame=>@use_frame)
+        i.setup_buffer do
+          isearch_forward
+        end
+      else
+        if @use_frame
+          langhelp_select_frame
+        else
+          winconf_push
+        end
+        langhelp_switch_to_index_buffer
+        let(:migemo_isearch_enable_p, nil) { isearch_forward }
+      end
+    end
+
+    defun(:langhelp_at_point, :interactive=>true,
+          :docstring=>"Open the langhelp buffer according to major-mode and point.") do
+      word = sexp_at_point.to_s.gsub(/_/, '[_-]')
+      mmode = real_mmode
+      i = LangHelpInternal.new(:major_mode=>mmode, :datadir=>conf[:LANGHELP_HOME], :encoding=>conf[:ENCODING], :use_frame=>@use_frame)
+      i.setup_buffer do
+        re = '\b' + word #  + '\b'
+        langhelp_occur re
+      end
+    end
+
+    defun(:langhelp_revert_buffer_default, :interactive=>true,
+          :docstring=>"Reread info of this langhelp buffer.") do 
+      # TODO: do not use buffer_name
+      mmode = buffer_name.scan(/\*langhelp:(.+)\*/).to_s
+      p = point
+      i = LangHelpInternal.new(:major_mode=>mmode, :datadir=>conf[:LANGHELP_HOME], :encoding=>conf[:ENCODING])
+      i.create_buffer
+      goto_char p
+    end
+
+    defun(:langhelp_revert_buffer, :interactive=>true,
+          :docstring=>"Reread and update this langhelp buffer.
+If `langhelp-revert-buffer-function' is specified, use it.
+Otherwise `langhelp-revert-buffer-default' is used.") do
+      if elvar.langhelp_revert_buffer_function
+        el4r_lisp_eval %q((funcall langhelp-revert-buffer-function))
+      else
+        langhelp_revert_buffer_default
+      end
+    end
+
+    def defun_langhelp_setup_index_buffer
+      defun(:langhelp_setup_index_buffer) do
+        index_content = conf.lang.sort.map {|lang, params|
+          %Q!# (lh-language-index "#{lang}")\n!
+        }.join
+        newbuf(:name=>INDEX_BUFFER, :contents=>index_content, :point=>1) {
+          langhelp_menu_mode
+          elvar.imenu_create_index_function = nil
+        }
+      end
+    end
+
+    defun(:lh_language_index,
+          :docstring=>"Open the LANG's langhelp index.") do |lang|
+      # TODO: do not use buffer_name
+      unless get_buffer "*langhelp:#{lang}*"
+        i = LangHelpInternal.new(:major_mode=>lang, :datadir=>conf[:LANGHELP_HOME], :encoding=>conf[:ENCODING])
+        i.create_buffer
+      end
+      switch_to_buffer "*langhelp:#{lang}*"
+    end
+
+    el4r_lisp_eval <<'EOL'
+(defun langhelp-select-frame ()
+  (let ((get (lambda ()
+               (find-if (lambda (frame)
+                          (equal (cdr (assq 'title (frame-parameters frame)))
+                                 "langhelp"))
+                        (frame-list))))
+        (make (lambda ()
+                (if (boundp 'langhelp-frame-alist)
+                    (make-frame `((title . "langhelp") ,@langhelp-frame-alist))
+                  (make-frame '((title . "langhelp"))))))
+        (select (lambda (frm)
+                  (select-frame frm)
+                  (raise-frame frm)
+                  (delete-other-windows))))
+    (funcall select (or (funcall get) (funcall make)))))
+EOL
+    #  `
+   
+    include DisplayResult
+    
+    defvar(:in_langhelp, nil)
+    defun(:__lh_ow) do |sexp|
+      let(:in_langhelp, true) do 
+        display_result(:preserve=>true) do
+          funcall(:eval,sexp)
+        end
+      end
+    end
+
+    el4r_lisp_eval %(
+        (defmacro lh-ow (sexp)
+          "Eval SEXP and display result in other window."
+          `(--lh-ow ',sexp))) # '`
+    
+    defun(:lh_sh,
+          :docstring=>"Hyperlink to the output of shell commands") do |command, line|
+      display_result(:line=>line) do
+        if get_buffer command
+          switch_to_buffer command
+        else
+          switch_to_buffer command
+          let(:coding_system_for_read, conf[:ENCODING],
+              :max_mini_window_height, 1) do
+            shell_command command, command
+            set_buffer command
+            #insert shell_command_to_string(command)
+          end
+          view_mode 1
+        end
+      end
+    end
+
+
+    defun(:lh_view, :interactive=>true,
+          :docstring=>"Hyperlink to text files. (view-mode)") do |line, filename|
+      display_result(:line=>line) do
+        view_file filename
+      end
+    end
+    
+    defun(:lh_file, :interactive=>true,
+          :docstring=>"Hyperlink to text files.") do |line, filename|
+      display_result(:line=>line) do
+        find_file filename
+      end
+    end
+    
+    defun(:lh_anchor, :interactive=>true,
+          :docstring=>"Hyperlink to anchors.") do |anchor, filename|
+      display_result(:anchor=>anchor) do
+        view_file filename
+      end
+    end
+
+
+    def setup_man
+      defalias :lh_man, :man
+
+      defvar :lh_man_line
+      defadvice(:Man_notify_when_ready, :around, :lh_man, :activate) do
+        if elvar.lh_man_line
+          display_result(:line=>elvar.lh_man_line) do 
+            switch_to_buffer elvar.man_buffer
+          end
+          elvar.lh_man_line = nil
+        else
+          ad_do_it
+        end
+      end
+
+    end
+
+    defun("lh-man*", :docstring=>"Hyperlink to manpage.") do |line, manpage|
+      elvar.lh_man_line = line
+      man manpage
+    end
+
+    defun(:lh_info,
+          :docstring=>"Hyperlink to Info.") do |line, book|
+      let(:same_window_buffer_names,nil,
+          :same_window_regexps,     nil) do 
+        bufname = "*info*<langhelp>"
+        display_result(:line=>line) do 
+          set_buffer(get_buffer_create(bufname))
+          Info_mode() unless elvar.major_mode.to_s == "Info-mode"
+          Info_goto_node(book)
+        end
+      end
+    end
+
+
+
+    defun(:lh_to, :interactive=>"sAnchor: ",
+          :docstring=>"Go to the anchor.") do |anchor|
+      winconf_push
+      search_anchor anchor
+    end
+
+
+
+    def abbreviate_url
+      abbreviate_file_name((elvar.w3m_current_url || '').sub(%r!^file://!,''))
+    end
+
+    def setup_w3m
+      ## for speed
+      el4r_lisp_eval %q(
+        (defun w3m-list-buffer-names ()
+          (mapcar (lambda (b) (buffer-name b)) (w3m-list-buffers)))
+      )
+      byte_compile :w3m_list_buffer_names
+
+      @w3m_buffers_cache = {}
+      defun(:langhelp_w3m_fontify_after_hook0) do
+        b = buffer_name
+        url = abbreviate_url
+        @w3m_buffers_cache[b] = [url,b]
+      end
+      add_hook :w3m_fontify_after_hook, :langhelp_w3m_fontify_after_hook0
+
+    end
+
+    defun(:lh_w3m, :interactive=>true,
+          :docstring=>"Hyperlink to files in HTML.") do |line, filename|
+      display_result(:line=>line, :w3m=>true) do
+        el_require :w3m
+        filename.sub!(%r!file://!, '')
+        filename = abbreviate_file_name filename
+        filename, name_anchor = filename.split(/#/,2)
+        urlfile = w3m_expand_file_name_as_url filename
+        url, buf = w3m_list_buffer_names.to_a.map{|b|
+          unless @w3m_buffers_cache[b]
+            with(:with_current_buffer,b){
+              @w3m_buffers_cache[b] = [abbreviate_url, b]
+            }
+          end
+          @w3m_buffers_cache[b]
+        }.find {|url, buf|
+          url == filename
+        }
+        if buf
+          funcall :message, "reuse #{buf} buffer"
+          switch_to_buffer buf
+        else
+          w3m(urlfile, true)
+        end
+        if name_anchor
+          w3m_search_name_anchor name_anchor
+        else
+          goto_char 1
+        end
+      end
+    end
+
+    defun(:langhelp_isearch_occur, :interactive=>true,
+          :docstring=>"Invoke `langhelp-occur' from within isearch.") do
+      let(:case_fold_search, elvar.isearch_case_fold_search) do
+        
+        re = if elvar.isearch_regexp
+               elvar.isearch_string
+             else
+               regexp_quote(elvar.isearch_string)
+             end
+        
+        if elvar.major_mode.to_s == "langhelp-menu-mode"
+          isearch_exit
+          langhelp_occur re
+        else
+          occur re
+        end
+      end
+    end
+    
+    def defun_langhelp_occur
+      if conf.occur_by_grep
+        defun(:langhelp_occur, :interactive=>true,
+              :docstring=>"Show all lines in the current buffer containing a match for isearch.") do |re|
+          occur_buf = generate_new_buffer "*langhelp occur /#{re}/*"
+          re = re + "|<<<.+>>>"
+          
+          let(:display_buffer_function, :switch_to_buffer) do 
+            shell_command_on_region(point_min, point_max, "grep -E -i -- #{re.dump}", occur_buf)
+            switch_to_buffer occur_buf
+            langhelp_menu_mode
+          end
+        end
+      else
+        defun(:langhelp_occur, :interactive=>true,
+              :docstring=>"Show all lines in the current buffer containing a match for isearch.") do |re|
+          occur_buf = generate_new_buffer "*langhelp occur [#{re}]*"
+          re = re + "\\|<<<.+>>>"
+          empty = true
+          with(:save_excursion) do 
+            while re_search_forward(re, nil, true)
+              empty = false
+              line = thing_at_point :line
+              with(:with_current_buffer, occur_buf) do
+                insert line
+              end
+            end
+          end
+          unless empty
+            switch_to_buffer occur_buf
+            goto_char point_min
+            langhelp_menu_mode
+          end
+        end
+      end
+    end
+
+    def narrowing?
+      buffer_size != point_max-1 or point_min != 1
+    end
+
+    defun(:langhelp_narrow_to_section, :interactive=>true,
+          :docstring=>"Restrict showing in this buffer to the current section.") do 
+      anchor_re = format(elvar.ee_anchor_format, '\(.+\)')
+      s, e = nil
+      with(:save_excursion) do
+        end_of_line
+        re_search_backward(anchor_re, nil, true)
+        s = point
+        end_of_line
+        if re_search_forward(anchor_re, nil, true)
+          beginning_of_line
+        else
+          goto_char point_max
+        end
+        e = point
+      end
+
+      narrow_to_region s, e
+    end
+
+    defun(:langhelp_toggle_narrowing, :interactive=>true,
+          :docstring=>"Toggle narrowing to the current section.") do 
+      if narrowing?
+        widen
+      else
+        langhelp_narrow_to_section
+      end
+    end
+
+    el4r_lisp_eval %q(
+        (defmacro lh-center (&rest body)
+          `(progn
+             ,@body
+             (save-selected-window
+               (other-window 1)
+               (recenter '(1)))))) #'`
+
+    defun(:langhelp_test_definition, :interactive=>"sLanghelp doc definition: ",
+          :docstring=>"Issue `mklanghelp --eval' for input") do |docdef|
+      docdef = docdef.sub(/,\s*$/,'')
+      shell_command "mklanghelp --eval='#{docdef}'"
+    end
+
+    defun(:langhelp_test_definition_this_line, :interactive=>true,
+          :docstring=>"Issue `mklanghelp --eval' for this line") do
+      langhelp_test_definition(buffer_substring(point_at_bol, point_at_eol))
+    end
+
+  end #/LangHelp::LangHelp
+
+  # (lh-sh "(echo a;echo b)" "b")
+  # (el4r-ruby-eval "LangHelp.run")
+  
+end #/LangHelp
+
+# Local Variables:
+# modes: (el4r-mode emacs-lisp-mode)
+# End: