debug modification of a variable

[elbb.git] / code / elbb.el

* debug modification of a variable

From: Tassilo Horn <tassilo@member.fsf.org>
To: emacs-devel@gnu.org
Date: Tue, 26 Jan 2010 21:26:49 +0100
Subject: Re: How to debug modification to a variable value?

"alin.s" <alinsoar@voila.fr> writes:

> I suggest you to use the WATCH in gdb for modifications of the
> variable, AWATCH for reading of the variable, etc.
>
> To detect the location of the variable is easy: install a breakpoint
> in make-variable-buffer-local that stops when exactly the variable you
> are interested about is set, then see there the location of
> tg-schema-alist.  Afterward you can use the x* functions from .gdbinit
> of emacs to debug your problem...

Thanks for that explanation.  I'll try that out as soon as I find some
time.  And also thanks for volunteering on implementing a debug facility
for cases like that.

Bye,
Tassilo

* strip mail head to fit for elbb

(defun mail2elbb (&optional beg end)
  " "
  (interactive "*")
  (let ((beg (cond (beg beg)
                   ((region-active-p)
                    (region-beginning))
                   (t (point-min))))
        (end (cond (end end)
                   ((region-active-p)
                    (copy-marker (region-end)))
                   (t (point-max)))))
    (save-restriction
      (narrow-to-region beg end)
      (goto-char beg)
      (mail2elbb-intern beg end)
      (widen))))

(defun mail2elbb-intern (beg end)
  (while (search-forward "=A0" nil t 1)
    (replace-match ""))
  (goto-char beg)
  (let ((end (progn (while
                 (re-search-forward "^[[:alpha:]-]+To:" nil t 1) 't) (copy-marker (line-end-position)))))
    (goto-char beg)
    (beginning-of-line)
    (while
        (< (point) end)
      (if (looking-at "Subject:\\|From:\\|Date:\\|To:")
          (forward-line 1)
        (delete-region (line-beginning-position) (1+ (line-end-position)))))))


* testing configuration

From: pjb@informatimago.com (Pascal J. Bourguignon)
Date: Sun, 27 Dec 2009 18:53:08 +0100
To: help-gnu-emacs@gnu.org
Subject: Re: testing configuration

andrea <andrea.crotti.0@gmail.com> writes:

> I was wondering if it would be possible to automatically check if my
> emacs configuration is correct.
> This can be then put in a post-commit hook to check that whenever I add
> some new features or change I don't mess up somethin else
>
> I would only need to:
> - load my whole configuration
> - exit and returns 0 if everything goes fine, returns another number
> otherwise.
>
> Any ideas?
>
> I can already launch a new emacs with certain conf, but how can I get a
> return value?

What about:

emacs -q --eval '(condition-case err (progn (load "~/.emacs") (kill-emacs 0)) (error (kill-emacs 1)))'

?

-- 
__Pascal Bourguignon__                     http://www.informatimago.com/


* self-typing

From: pjb@informatimago.com (Pascal J. Bourguignon)
Date: Sat, 26 Dec 2009 14:32:16 +0100
To: help-gnu-emacs@gnu.org
Subject: Re: what is `self-typing' ?

waterloo <waterloo2005@gmail.com> writes:

> I can not understand a para in Elisp manual :
>
>     Lisp is unlike many other languages in that its objects are
>     "self-typing": the primitive type of each object is implicit in the
>     object itself.  For example, if an object is a vector, nothing can
>     treat it as a number; Lisp knows it is a vector, not a number.
>
> What is `self-typing' ? thanks

As mentionned by Eli.  But this require some more explaination.

Some languages are defined so that variables can hold only objects of
a given type (you declare the type of the variable, or it is infered
automatically at compilation time).  For example, C or Haskell.  

Since all the types of the objects are known at compilation time from
the variables they're stored in, the compiler doesn't need to generate
code to store the type along with the object, or along with the
variable: the type is implicity.  In C, typeof(42) or int a=42; typeof(a)
is computed at compilation time.  

Some languages are defined so that variables can hold objects of
different types, at different times.  In that case, the type is not
attached to the variable, but must be attached to the objects
themselves.  For example, Lisp or Smalltalk.

Since it is rarely possible to know what type of object a variable
will hold (some type inference can still be applied to optimize out
some function, but there remains a lot of functions where type
inference doesn't restrict much the possible types, the more so when
global analysis is not practical or possible), then the type of each
object has to be kept with the object.  In Lisp, (type-of 42) or (let
((a 42)) (type-of 42)) is computed at run-time.  Notably, you can
write: (type-of (read)) and depending on what you enter at run-time,
will get back one type or another:

M-x ielm RET
*** Welcome to IELM ***  Type (describe-mode) for help.
ELISP> (type-of (read))
Lisp expression: 42
integer
ELISP> (type-of (read))
Lisp expression: "fourty-two"
string
ELISP> (type-of (read))
Lisp expression: fourty-two
symbol
ELISP> (type-of (read))
Lisp expression: (fourty two)
cons
ELISP> 

There are also languages where both things are more or less possible,
you can have variables with pre-defined types holding only one type of
object, and variables which can hold objects of various types, but of
a same root class.  For example, C++ or Java.

These languages usually provide so called "Plain Old Data" types which
correspond to the type of objects that can only be stored in variables
with predefined types.   These objects of these POD types usually
don't have the type attached to them, these objects can only be stored
in variables with pre-defined type.   When you want to store such an
object in a variable-type variable, you have to wrap it in another
object, a typed object, instance of a class.  In Java, you have a POD
type int and an object class Integer.  

-- 
__Pascal Bourguignon__                     http://www.informatimago.com/

* Emacs uptime

From: pjb@informatimago.com (Pascal J. Bourguignon)
Date: Wed, 23 Dec 2009 20:16:03 +0100
To: help-gnu-emacs@gnu.org
Subject: Re: Some functions I hope are useful for others to

[ ... ]

For example, here is my emacs-uptime:

(defvar com.informatimago.time/*emacs-start-time*   (current-time)
   "For (emacs-uptime)")

(defun com.informatimago.time/emacs-uptime ()
  "Gives Emacs' uptime, based on global var `com.informatimago.time/*emacs-start-time*'."
  (interactive)
  (let* ((st com.informatimago.time/*emacs-start-time*)
         (cur (current-time))
         (hi-diff (- (car cur) (car st)))
         (tot-sec (+ (ash hi-diff 16) (- (cadr cur) (cadr st))))
         (days (/ tot-sec (* 60 60 24)))
         (hrs  (/ (- tot-sec (* days 60 60 24)) (* 60 60)))
         (mins (/ (- tot-sec (* days 60 60 24) (* hrs 60 60)) 60))
         (secs (/ (- tot-sec (* days 60 60 24) (* hrs 60 60) (* mins 60)) 1)))
    (message "Up %dd %dh %dm %ds (%s), %d buffers, %d files"
             days hrs mins secs
             (format-time-string "%a %Y-%m-%d %T" st)
             (length (buffer-list))
             (count t (buffer-list)
                    :test-not
                    (lambda (ignore buf)
                      (null (cdr (assoc 'buffer-file-truename
                                        (buffer-local-variables buf)))))))))

(defalias 'emacs-uptime 'com.informatimago.time/emacs-uptime)

[ .... ]

* Using Emacs Lisp for script writing

To: help-gnu-emacs@gnu.org
From: David Engster <deng@randomsample.de>
Date: Sat, 19 Dec 2009 11:02:22 +0100
Subject: Re: Using Emacs Lisp for script writing

Andreas Politz <politza@fh-trier.de> writes:
> Cecil Westerhof <Cecil@decebal.nl> writes:
>
>> I already use 'emacs -batch' for scripting where no user input is used,
>> but I would like to use it also for interactive scripting. Until now I
>> did not find any usable information about this. Anybody using Emacs for
>> interactive scripts?
>
> No, but it should be noted, that this is not very difficult :
>
> $ emacs -Q -batch -eval '(yes-or-no-p "Want some cookies ?")'

You can also use the '--script' option in a shebang line:

----------------- test.sh -----------------
#!/usr/bin/emacs --script

(if (yes-or-no-p "Choose ")
    (message "You said yes")
  (message "You said no"))
-------------------------------------------

I use emacs regularly for writing scripts, since with its thousands of
packages you have a huge library readily available.

-David

* favourite directories implementation

Author: Florent Georges, source:
http://fgeorges.blogspot.com/2008/01/emacs-favourite-directories.html

Today, I have finally taken a look at one of the
simple features I always missed in Emacs: the
ability to define a set of "favourite directories."
That is, a set of named directories that one can use
in the minibuffer when prompted for instance to open
a file. Given a set of such dirs:

emacs-src -> /enter/your/path/to/emacs/sources
projects  -> /path/to/some/company/projects
now       -> @projects/the/project/I/am/working/on

one can use the following path in the minibuffer to open a file,
for instance using C-x C-f:

@emacs-src/lisp/files.el
@emacs-src/src/alloc.c
@projects/great/README
@now/src/some/stuff.txt

Doing so, completion is available for both directory names and
files under their target directories. For instance, to open the
third file above, you only have to type:

C-x C-f @ p <tab> g <tab> R <tab> <enter>

The implementation I have just written is really simple, but
useful yet. It implements all described above (including
                                               recursive defined directories, as the '@now' above.) Thanks to
Emacs, I am still suprised by the facility to implement such a
feature!

The code was written on GNU Emacs 22.1 on Windows, but should
work on any platform, and I think on Emacs 21 as well.

TODO: Make a custom variable.
(defvar drkm-fav:favourite-directories-alist
  '(("saxon-src"  . "y:/Saxon/saxon-resources9-0-0-1/source/net/sf/saxon")
    ("kernow-src" . "~/xslt/kernow/svn-2007-09-29/kernow/trunk/src/net/sf/kernow"))
  "See `drkm-fav:handler'.")

(defvar drkm-fav::fav-dirs-re
  ;; TODO: Is tehre really no other way (than mapcar) to get the list
  ;; of the keys of an alist?!?
  (concat
   "^@"
   (regexp-opt
    (mapcar 'car drkm-fav:favourite-directories-alist)
    t))
  "Internal variable that stores a regex computed from
`drkm-fav:favourite-directories-alist'.  WARNING: This is not
updated automatically if the later variable is changed.")

(defun drkm-fav:handler (primitive &rest args)
  "Magic handler for favourite directories.

With this handler installed into `file-name-handler-alist', it is
possible to use shortcuts for often used directories.  It uses
the mapping in the alist `drkm-fav:favourite-directories-alist'.

Once installed, say you have the following alist in the mapping
variable:

    ((\"dir-1\" . \"~/some/real/dir\")
     (\"dir-2\" . \"c:/other/dir/for/windows/users\"))

You can now use \"@dir-1\" while opening a file with C-x C-f for
instance, with completion for the abbreviation names themselves
as well as for files under the target directory."
  (cond
   ;; expand-file-name
   ((and (eq primitive 'expand-file-name)
         (string-match drkm-fav::fav-dirs-re (car args)))
    (replace-match
     (cdr (assoc (match-string 1 (car args))
                 drkm-fav:favourite-directories-alist))
     t t (car args)))
   ;; file-name-completion
   ((and (eq primitive 'file-name-completion)
         (string-match "^@\\([^/]*\\)$" (car args)))
    (let ((compl (try-completion
                  (match-string 1 (car args))
                  drkm-fav:favourite-directories-alist)))
      (cond ((eq t compl)
             (concat "@" (match-string 1 (car args)) "/"))
            ((not compl)
             nil)
            (t
             (concat "@" compl)))))
   ;; file-name-all-completions
   ((and (eq primitive 'file-name-all-completions)
         (string-match "^@\\([^/]*\\)$" (car args)))
    (all-completions
     (match-string 1 (car args))
     drkm-fav:favourite-directories-alist))
   ;; Handle any primitive we don't know about (from the info node
   ;; (info "(elisp)Magic File Names")).
   (t (let ((inhibit-file-name-handlers
             (cons 'drkm-fav:handler
                   (and (eq inhibit-file-name-operation primitive)
                        inhibit-file-name-handlers)))
            (inhibit-file-name-operation primitive))
        (apply primitive args)))))

;; Actually plug the feature into Emacs.
(push '("\\`@" . drkm-fav:handler) file-name-handler-alist)

* lisp interface to ispell

From: Teemu Likonen <tlikonen@iki.fi>
Date: Fri, 06 Nov 2009 22:05:53 +0200
To: help-gnu-emacs@gnu.org
Subject: Re: lisp interface to ispell ?

On 2009-11-06 20:39 (+0100), Andreas Politz wrote:

> Does someone have a hack, or know a different package, in order to allow
> elisp access to spelling functions ? E.g. like
>
> (spell word language)
>
> which at least returns t or nil.

Something like this?

(defun my-ispell-string (word lang)
  (with-temp-buffer
    (insert word)
    (call-process-region (point-min) (point-max)
                         "ispell" t t nil "-l" "-d" lang)
    (if (= (point-min) (point-max))
        t)))

* Python workflow

From: Simon <bbbscarter@gmail.com>
Date: Fri, 6 Nov 2009 03:42:44 -0800 (PST)
To: help-gnu-emacs@gnu.org
Subject: Python workflow

Hi, apologies in advance for a potentially numpty post.

I've been using Emacs for a little while now, but I've yet to settle
on a satisfactory python edit-run-debug cycle, and I was wondering
what wiser minds than mine have settled upon. So far I've tried:

- Edit code and run with emacs PDB. After fiddling the lisp code to
automatically pick up the current buffer as the default run candidate,
this is nearly okay. The main issue is that, after editing code,
there's no easy way to rerun the code, so I end up killing the gud
buffer every time. As such, entering and leaving the debugger is quite
a few key presses and accidentally leaving it running is also easy.

- Tried Pydb to similar effect.

- Run everything in a seperate shell. And debug by hand. This is a
little too low-fi, even for me.

- Use the 'import/reload file' and 'eval def/class' functions, and run
everything from the emacs python shell, using pdbtrack to help with
debugging. Problems so far:
- It's very easy to forget which modules you've modified and fail to
reload them; because the state is carried over I continually find
myself running the old versions of code I've just edited, especially
if it's across several files.
- More than that, sometimes the stuff I expect to reload simply
doesn't, and I have no indication as to why. For example, if pdb has
module open and you stick a deliberate error in the code and reload
it, the minibuffer tells you the module has been loaded, even though
it clearly can't have been.
- I have to run pdb.pm() to debug the exception. If I run *anything*
else by accident, I lose the exception context. This can be annoying
if you're incompetent enough to keep making typos (I am).

Does anyone have any tips on their workflow?

Many thanks!

Simon

* strip out UTF-8 BOMs
From: "Edward O'Connor" <hober0@gmail.com>
Date: Thu, 5 Nov 2009 16:13:27 -0800
To: emacs-devel@gnu.org
Subject: find-file-literally-at-point

Hi,

I recently found myself in need of such a function (I was going through
                                                      a bunch of files to strip out their UTF-8 BOMs, if you're curious), and
it was quick enough to put together:

(autoload 'ffap-guesser "ffap")
(defun find-file-literally-at-point ()
  "Open the file at point (like `ffap') with `find-file-literally'."
  (interactive)
  (find-file-literally (ffap-guesser)))

* xml and n3

From: "Eric Schulte" <schulte.eric@gmail.com>
Subject: Re: [Orgmode] org-babel-tangle xml text
Date: Tue, 03 Nov 2009 09:18:34 -0700

"Martin G. Skjæveland" <martige@ifi.uio.no> writes:

> Is there a way I can add xml and n3 to the list of supported
> languages? These languages does not need interpretation, so I'm
> thinking it should be quite easy to add. I have fumblingly tried
>
>   (add-to-list 'org-babel-tangle-langs '("xml"))
>
> and
>
>   (add-to-list 'org-babel-tangle-langs '("css" "xml"))
>
> but it as no effect.
>

Hi Martin,

The attached org-mode file contains instructions for adding xml and n3
to org-babel and org-babel-tangle.  Note that there may be another step
if the major mode for n3 is not n3-mode.  Best -- Eric

introduce org-babel to =xml= and =n3=

#+begin_src emacs-lisp :results silent
  (org-babel-add-interpreter "xml")
  (org-babel-add-interpreter "n3")
#+end_src

if say =n3= should be edited using =xml-mode=, then evaluate the
following adding this pair to =org-src-lang-modes=

#+begin_src emacs-lisp :results silent
  (add-to-list 'org-src-lang-modes '("n3" . xml))
#+end_src

;; inform org-babel-tangle of their existence and file extensions
#+begin_src emacs-lisp :results silent
  (add-to-list 'org-babel-tangle-langs '("xml" "xml" nil t))
  (add-to-list 'org-babel-tangle-langs '("n3" "n3" nil t))
#+end_src

#+begin_src xml :tangle example
  <first>
  </first>
#+end_src

#+begin_src n3 :tangle example
  n3 stuff
#+end_src

* How to check regexp for syntax-errors?

From: Kevin Rodgers <kevin.d.rodgers@gmail.com>
Date: Tue, 20 Oct 2009 01:54:56 -0600
Subject: Re: How to check regexp for syntax-errors?  
David Combs wrote:
> Isn't there some .el that that will try to parse a regexp, and tell
> me where it got confused, and what to look for for errors?
                                                            
(defun valid-regexp-p (regexp)
   (interactive "sRegexp: ")
   (with-temp-buffer
     (condition-case error-data
        (progn
          (re-search-forward regexp nil t)
          t)
       (invalid-regexp
        (when (interactive-p) (message "Invalid regexp: %s" (cdr error-data)))
        nil))))

-- 
Kevin Rodgers
Denver, Colorado, USA

* prefer cond over case?

From: David Kastrup <dak@gnu.org>
Date: Mon, 12 Oct 2009 10:03:39 +0200
To: help-gnu-emacs@gnu.org
Subject: Re: Perferr cond over case?

pjb@informatimago.com (Pascal J. Bourguignon) writes:

> Nordlöw <per.nordlow@gmail.com> writes:
>
>> Does the use of the cl macro case() incurr some loss of performance
>> compare to using cond() instead?
>
> (macroexpand '(case (* 2 2 2 2 3)
                  >                 (10      'one)
                  >                 ((24 42) 'two)
                  >                 ((3 33)  'three)
                  >                 (otherwise 'unknown)))
> -->
> (let ((--cl-var-- (* 2 2 2 2 3)))
    >     (cond ((eql --cl-var-- (quote 10)) (quote one))
                >           ((member* --cl-var-- (quote (24 42))) (quote two))
                >           ((member* --cl-var-- (quote (3 33))) (quote three))
                >           (t (quote unknown))))
>
> What do you think?

Before or after byte compilation?

-- 
David Kastrup

* batch-mode

From: Decebal <cldwesterhof@gmail.com>
Newsgroups: gnu.emacs.help
Date: Sat, 10 Oct 2009 11:33:17 -0700 (PDT)
To: help-gnu-emacs@gnu.org
Envelope-To: andreas.roehler@easy-emacs.de

In a Bash script I changed:

local i
local length=${#1}

       for i in $(seq ${1}) ; do
         printf "       Regel %${length}d voor de test\n" ${i}
       done  >${2}
to:

emacs -batch -nw --eval='
        (let (
              (i)
              (nr-of-lines '${1}')
              (nr-of-lines-length)
              (output-file "'"${2}"'"))
          (setq nr-of-lines-length (length (number-to-string nr-of-lines)))
          (dotimes (i nr-of-lines t)
           (insert (format (format "       Regel %%%dd voor de test\n" nr-of-lines-length) (1+ i))))
          (write-file output-file))
       ' 2>/dev/null

The Bash version took 293 seconds and the Emacs Lisp version 59
seconds. So it is about 5 times as fast.
The Emacs batch gives output like:
Saving file /home/cecil/temp/inputEmacs...
Wrote /home/cecil/temp/inputEmacs
That is why I use the 2>/dev/null.
Is there a way to circumvent the generation of the above output?
Because when there is an error it is also thrown away and that is not
nice.

From: Vassil Nikolov <vnikolov@pobox.com>
Newsgroups: gnu.emacs.help
Date: Sat, 10 Oct 2009 16:55:31 -0400
To: help-gnu-emacs@gnu.org
Envelope-To: andreas.roehler@easy-emacs.de

On Sat, 10 Oct 2009 11:33:17 -0700 (PDT), Decebal <cldwesterhof@gmail.com> said:
> ...
>       local i
>       local length=${#1}
>       for i in $(seq ${1}) ; do
>         printf "       Regel %${length}d voor de test\n" ${i}
>       done  >${2}

translates to

emacs -Q -batch -eval '
(dotimes (i '"${1}"')
        (princ (format "       Regel %'"${#1}"'d voor de test\n" (1+ i))))
' > "${2}"

---Vassil.

From: Decebal <cldwesterhof@gmail.com>
Newsgroups: gnu.emacs.help
Date: Sat, 10 Oct 2009 13:57:07 -0700 (PDT)
To: help-gnu-emacs@gnu.org
Envelope-To: andreas.roehler@easy-emacs.de

On Oct 10, 10:06pm, Andreas R=F6hler <andreas.roeh...@easy-emacs.de>
wrote:
> > The Emacs batch gives output like:
> >   Saving file /home/cecil/temp/inputEmacs...
>
> it's in files.el, save-buffer, AFAIS
>
>   (if (and modp (buffer-file-name))
        >     (message "Saving file %s..." (buffer-file-name)))
>
> commenting out these lines should cancel the message

The problem with that is that it only works for me. But I found a way.
I replaced:

(write-file output-file))

with:

(set-visited-file-name output-file)
    (basic-save-buffer))

But maybe there should be more consideration for the possibility that
Emacs is used as a batch program.

> >   Wrote /home/cecil/temp/inputEmacs

I still have to find something for this.

That is not possible I am afraid. In the C-source there is a call to
message_with_string.

* vectors and lists

From: pjb@informatimago.com (Pascal J. Bourguignon)
Newsgroups: gnu.emacs.help
Date: Fri, 09 Oct 2009 19:19:49 +0200
To: help-gnu-emacs@gnu.org
Envelope-To: andreas.roehler@easy-emacs.de

Nordlöw <per.nordlow@gmail.com> writes:

> If I have an association list say,
>
> '(
>   ("key" sym1 val1 num1)
>   ("key2" sym2 val2 num2)
> )
>
> , where each entry is a fixed sequence of various objects. 

If this is an a-list, then you could write it as:

   (("key1" . (sym1 val1 num1))
    ("key2" . (sym2 val2 numb2)))

to show that it is a list of cons cells.  

(a . (b c d)) <=> (a b c d), but the first notation shows that you
consider it as a list of cons, and notably that you don't expect nil
ie. () to be in the toplevel of the a-list.

Also, if we write the a-list properly like this, we can better answer
the following question:

> I might
> aswell use a vector to represent an entry in this alist, right?

You cannot use a vector instead of the cons cells of the a-list, but
you can use a vector as a value of an a-list entry.  Values can be of
any type.  In the case of emacs lisp, you could also easily use
vectors (or any other type) as keys in an a-list, since it uses equal
to compare keys.  

   (("key1" . [sym1 val1 num1])
    ("key2" . [sym2 val2 num2])
    ([?k ?e ?y ?3] . [sym3 val3 num3]))

> In this case, what do I gain by using a vector instead of list?

In general, vectors take half the space of lists, and access to the
nth element is done in O(1) instead of O(n) with lists.  However,
adding or removing an element in a vector is O(n) while in the case of
lists, it may be O(1) (prepending an element or removing the first
                                  element or one of the few firsts elements) or O(n) (inserting,
                                                                                      appending an element or removing the nth element).

> What about performance?: aref() faster than nth() only for large
> vectors?

aref has to compute a multiplication and a sum, before doing one
memory load to get the element.  In the case of emacs lisp, the
multiplication is always by the same fixed factor AFAIK.

nth has to do n memory loads to get the element.

So indeed, aref will probably be faster than nth, even for indices as
small as 1 or 0.

> Is there vector-variant of assoc()? 

No.  Unless you count hash-tables as a vector variant.

> If not, why? 

Because there's no point. The advantage of using a list for a-list,
apart from the historical simplicity, is that you can easily prepend
the a-list with new associations, and therefore use the a-list in a
purely functional way.

   (defun f (bindings)
      (let ((val (cdr (assoc 'x bindings))))
         (if (zerop val)
             (list val)
             (cons val (f (cons (cons 'x (1- val)) bindings))))))

   (let ((bindings '((y . 0) (x . 1))))
      (list (f (cons (cons 'x 2) bindings))
            (cdr (assoc 'x bindings))))
   ;; --> ((2 1 0) 1)

Note: you could use (require 'cl)  (acons key value a-list) 
instead of (cons (cons key value) a-list).

> Has any one already written such a function?

Not AFAIK, but you can write it.  However, the semantics of assoc
require a sequential search of the keys in the list, so there would be
no gain.  On the contrary, we would now have O(n) complexity to
prepend a new entry to the a-vector.

-- 
__Pascal Bourguignon__