emacs-orgmode
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Orgmode] Re: RFI -- Which completion system?


From: Tassilo Horn
Subject: [Orgmode] Re: RFI -- Which completion system?
Date: Fri, 22 Oct 2010 09:48:42 +0200
User-agent: Gnus/5.110011 (No Gnus v0.11) Emacs/24.0.50 (gnu/linux)

Sébastien Vauban <address@hidden>
writes:

Hi Seb,

> Before spending a lot of time trying to choose for the "best"
> completion mechanism inside Emacs (and sticking to it), setting it up
> all the way through, I wanted to know if you had had:
>
> - particularly good or bad experiences with one of the "standard" ones?
>
> - things to notice regarding the integration with Org?
>
> From the many that do exist -- and which conflict in my =.emacs= file! --,
> I've spotted the following ones of being of real interest:
>
> - dabbrev
> - hippie-expand

I use the former through the latter and bound M-/ to `hippie-expand'
instead of the normal `dabbrev-expand'.  In addition to the dabbrev
expand facility, I've teached my hippie-expand to also complete elisp
symbols, buffers, file names, and solve mathematical formulas:

  3 + 5 * 7 = <M-/>
  3 + 5 * 7 = 38

Cool! ;-)

Here's my config (the math stuff is stolen from someone):

--8<---------------cut here---------------start------------->8---
(global-set-key (kbd "M-/") 'hippie-expand)

(defun my-try-complete-with-calc-result (arg)
  "complete `3 + 4 = <TAB>' to `3 + 4 = 7'.
Great stuff by Michele Bini.
http://www.emacswiki.org/cgi-bin/emacs-en/MicheleBini";
  (and
   (not arg) (eolp)
   (save-excursion
     (beginning-of-line)
     (when (and (boundp 'comment-start)
                comment-start)
       (when (looking-at
              (concat
               "[ \n\t]*"
               (regexp-quote comment-start)))
         (goto-char (match-end 0))
         (when (looking-at "[^\n\t ]+")
           (goto-char (match-end 0)))))
     (looking-at ".* \\(\\([;=]\\) +$\\)"))
   (save-match-data
     (require 'calc-ext nil t))
   ;;(require 'calc-aent)
   (let ((start (match-beginning 0))
         (op (match-string-no-properties 2)))
     (save-excursion
       (goto-char (match-beginning 1))
       (if (re-search-backward (concat "[\n" op "]") start t)
           (goto-char (match-end 0)) (goto-char start))
       (looking-at (concat " *\\(.*[^ ]\\) +" op "\\( +\\)$"))
       (goto-char (match-end 2))
       (let* ((b (match-beginning 2))
              (e (match-end 2))
              (a (match-string-no-properties 1))
              (r (calc-do-calc-eval a nil nil)))
         (when (string-equal a r)
           (let ((b (save-excursion
                      (and (search-backward "\n\n" nil t)
                           (match-end 0))))
                 (p (current-buffer))
                 (pos start)
                 (s nil))
             (setq r
                   (calc-do-calc-eval
                    (with-temp-buffer
                      (insert a)
                      (goto-char (point-min))
                      (while (re-search-forward
                              "[^0-9():!^ \t-][^():!^ \t]*" nil t)
                        (setq s (match-string-no-properties 0))
                        (let ((r
                               (save-match-data
                                 (save-excursion
                                   (set-buffer p)
                                   (goto-char pos)
                                   (and
                                    ;; TODO: support for line indentation
                                    (re-search-backward
                                     (concat "^" (regexp-quote s)
                                             " =")
                                     b t)
                                    (progn
                                      (end-of-line)
                                      (search-backward "=" nil t)
                                      (and (looking-at "=\\(.*\\)$")
                                           (match-string-no-properties 1))))))))
                          (if r (replace-match (concat "(" r ")") t t))))
                      (buffer-substring (point-min) (point-max)))
                    nil nil))))
         (and
          r
          (progn
            (he-init-string b e)
            (he-substitute-string (concat " " r))
            t)))))))

(setq hippie-expand-try-functions-list '(try-complete-file-name
                                         my-try-complete-with-calc-result
                                         try-expand-dabbrev
                                         try-complete-lisp-symbol
                                         try-expand-dabbrev-all-buffers))
--8<---------------cut here---------------end--------------->8---

> - pabbrev
> - company

I've not tried those, but I also have auto-complete enabled globally,
which shows nice, unobstrusive overlay completion popups.  Basically
it's great and I've also written an intelligent completion function for
a language we're developing here at my University which was pretty easy
to do.  But auto-complete has some bugs and glitches which I've reported
at its bugtracker.  Sadly, it seems to me that its author has no time to
fix those, at least he didn't respond to my reports since 5 months...

Bye,
Tassilo




reply via email to

[Prev in Thread] Current Thread [Next in Thread]