WikEmacs - User contributions [en]

Re-builder

2012-04-10T01:21:36Z

Gregben:

== Introduction ==

An interactive Emacs tool to build a '''regexp''' (regular expression).

RE-Builder allows you to interactively develop a '''regexp''' on the contents of the currently active buffer.
Immediately after you type each character, the subject buffer is updated to highlight all those strings that match the
'''regexp''' you've created thus far. Only the first 200 matches (if there are more than 200) are shown.

== Invocation ==

'''M-x re-builder'''

A new window is created just above the minibuffer with a single a pair of quotation marks ("").
This is the '''*RE-Builder*''' buffer.

You ''build'' your '''regexp''' between the quotation marks in this buffer.

== Examples ==

Re-builder

2012-04-10T01:19:44Z

Gregben: Created page with "== RE-Builder == An interactive Emacs tool to build a '''regexp''' (regular expression). == Invocation == '''M-x re-builder''' A new window is created just above the minib..."

== RE-Builder ==

An interactive Emacs tool to build a '''regexp''' (regular expression).

== Invocation ==

'''M-x re-builder'''

A new window is created just above the minibuffer with a single a pair of quotation marks ("").
This is the '''*RE-Builder*''' buffer.

You ''build'' your '''regexp''' between the quotation marks in this buffer.

== Introduction ==

RE-Builder allows you to interactively develop a '''regexp''' on the contents of the currently active buffer. Immediately after you type each character, the subject buffer is updated to highlight all those strings that match the
'''regexp''' you've created thus far. Only the first 200 matches (if there are more than 200) are shown.

== Examples ==

Regexp

2012-04-10T00:39:27Z

Gregben: /* Tips and Tricks */

== Origin ==

'''Regexp''' is a portmanteau of the words '''regular''' and '''expression'''. It is the Emacs abbreviation for "regular expression".
Many other computer languages and software use the abbreviation '''regex''' (no trailing p) instead.

Wikipedia article about [http://en.wikipedia.org/wiki/Regular_expression regular expressions]

== Syntax ==

The following characters are special : . * + ? ^ $ \ [

Between brackets [], the following are special : ] - ^

Many characters are special when they follow a backslash – see below.

. any character (but newline)
* previous character or group, repeated 0 or more time
+ previous character or group, repeated 1 or more time
? previous character or group, repeated 0 or 1 time
^ start of line
$ end of line
[...] any character between brackets
[^..] any character not in the brackets
[a-z] any character between a and z
\ prevents interpretation of following special char
\| or
\w word constituent
\b word boundary
\sc character with c syntax (e.g. \s- for whitespace char)
 start\end of group
\< \> start\end of word
\` \' start\end of buffer
\1 string matched by the first group
\n string matched by the nth group
\{3\} previous character or group, repeated 3 times
\{3,\} previous character or group, repeated 3 or more times
\{3,6\} previous character or group, repeated 3 to 6 times
.?, +?, and ?? are non-greedy versions of ., +, and ?
\W, \B, and \Sc match any character that does not match \w, \b, and \sc

=== Character category ===

\ca ascii character
\Ca non-ascii character (newline included)
\cl latin character
\cg greek character

=== POSIX character classes ===

[:digit:] a digit, same as [0-9]
[:upper:] a letter in uppercase
[:space:] a whitespace character, as defined by the syntax table
[:xdigit:] an hexadecimal digit
[:cntrl:] a control character
[:ascii:] an ascii character

=== Syntax classes ===

\s- whitespace character \s/ character quote character
\sw word constituent \s$ paired delimiter
\s_ symbol constituent \s' expression prefix
\s. punctuation character \s< comment starter
\s( open delimiter character \s> comment ender
\s) close delimiter character \s! generic comment delimiter
\s" string quote character \s| generic string delimiter
\s\ escape character

== Regexp Examples ==

[-+[:digit:]] digit or + or - sign
$\+\|-$?[0-9]+$\.[0-9]+$? decimal number (-2 or 1.5 but not .2 or 1.)
$\w+$ +\1\> two consecutive, identical words
\<[[:upper:]]\w* word starting with an uppercase letter
+$ trailing whitespaces (note the starting SPC)
\w\{20,\} word with 20 letters or more
\w+phony\> word ending by phony
$19\|20$[0-9]\{2\} year 1900-2099
^.\{6,\} at least 6 symbols
^[a-zA-Z0-9_]\{3,16\}$ decent string for a user name
<tag[^> C-q C-j ]*>$.*?$</tag> html tag

== Emacs Commands that Use Regular Expressions ==

C-M-s incremental forward search matching regexp
C-M-r incremental backward search matching regexp
replace-regexp replace string matching regexp
query-replace-regexp same, but query before each replacement
align-regexp align, using strings matching regexp as delimiters
highlight-regexp highlight strings matching regexp
occur show lines containing a match
multi-occur show lines in all buffers containing a match
how-many count the number of strings matching regexp
keep-lines delete all lines except those containing matches
flush-lines delete lines containing matches
grep call unix grep command and put result in a buffer
lgrep user-friendly interface to the grep command
rgrep recursive grep
dired-do-copy-regexp copy files with names matching regexp
dired-do-rename-regexp rename files matching regexp
find-grep-dired display files containing matches for regexp with Dired

== Tips and Tricks ==

To enter a '''newline''' character in a regexp, use the two keystroke sequence '''C-q C-j'''.
It will appear in the minibuffer as '''^J'''.

== See Also ==
[[Re-builder]] build regexp interactively in buffer

Regexp

2012-04-10T00:37:17Z

Gregben: Added Tips and Tricks section

== Origin ==

'''Regexp''' is a portmanteau of the words '''regular''' and '''expression'''. It is the Emacs abbreviation for "regular expression".
Many other computer languages and software use the abbreviation '''regex''' (no trailing p) instead.

Wikipedia article about [http://en.wikipedia.org/wiki/Regular_expression regular expressions]

== Syntax ==

The following characters are special : . * + ? ^ $ \ [

Between brackets [], the following are special : ] - ^

Many characters are special when they follow a backslash – see below.

. any character (but newline)
* previous character or group, repeated 0 or more time
+ previous character or group, repeated 1 or more time
? previous character or group, repeated 0 or 1 time
^ start of line
$ end of line
[...] any character between brackets
[^..] any character not in the brackets
[a-z] any character between a and z
\ prevents interpretation of following special char
\| or
\w word constituent
\b word boundary
\sc character with c syntax (e.g. \s- for whitespace char)
 start\end of group
\< \> start\end of word
\` \' start\end of buffer
\1 string matched by the first group
\n string matched by the nth group
\{3\} previous character or group, repeated 3 times
\{3,\} previous character or group, repeated 3 or more times
\{3,6\} previous character or group, repeated 3 to 6 times
.?, +?, and ?? are non-greedy versions of ., +, and ?
\W, \B, and \Sc match any character that does not match \w, \b, and \sc

=== Character category ===

\ca ascii character
\Ca non-ascii character (newline included)
\cl latin character
\cg greek character

=== POSIX character classes ===

[:digit:] a digit, same as [0-9]
[:upper:] a letter in uppercase
[:space:] a whitespace character, as defined by the syntax table
[:xdigit:] an hexadecimal digit
[:cntrl:] a control character
[:ascii:] an ascii character

=== Syntax classes ===

\s- whitespace character \s/ character quote character
\sw word constituent \s$ paired delimiter
\s_ symbol constituent \s' expression prefix
\s. punctuation character \s< comment starter
\s( open delimiter character \s> comment ender
\s) close delimiter character \s! generic comment delimiter
\s" string quote character \s| generic string delimiter
\s\ escape character

== Regexp Examples ==

[-+[:digit:]] digit or + or - sign
$\+\|-$?[0-9]+$\.[0-9]+$? decimal number (-2 or 1.5 but not .2 or 1.)
$\w+$ +\1\> two consecutive, identical words
\<[[:upper:]]\w* word starting with an uppercase letter
+$ trailing whitespaces (note the starting SPC)
\w\{20,\} word with 20 letters or more
\w+phony\> word ending by phony
$19\|20$[0-9]\{2\} year 1900-2099
^.\{6,\} at least 6 symbols
^[a-zA-Z0-9_]\{3,16\}$ decent string for a user name
<tag[^> C-q C-j ]*>$.*?$</tag> html tag

== Emacs Commands that Use Regular Expressions ==

C-M-s incremental forward search matching regexp
C-M-r incremental backward search matching regexp
replace-regexp replace string matching regexp
query-replace-regexp same, but query before each replacement
align-regexp align, using strings matching regexp as delimiters
highlight-regexp highlight strings matching regexp
occur show lines containing a match
multi-occur show lines in all buffers containing a match
how-many count the number of strings matching regexp
keep-lines delete all lines except those containing matches
flush-lines delete lines containing matches
grep call unix grep command and put result in a buffer
lgrep user-friendly interface to the grep command
rgrep recursive grep
dired-do-copy-regexp copy files with names matching regexp
dired-do-rename-regexp rename files matching regexp
find-grep-dired display files containing matches for regexp with Dired

== Tips and Tricks ==

To enter a '''newline''' character in a regexp, use the two keystroke sequence '''C-q C-j'''.

== See Also ==
[[Re-builder]] build regexp interactively in buffer

Regexp

2012-04-09T21:15:49Z

Gregben: Added small section introducing regular expressions

== Origin ==

'''Regexp''' is a portmanteau of the words '''regular''' and '''expression'''. It is the Emacs abbreviation for "regular expression".
Many other computer languages and software use the abbreviation '''regex''' (no trailing p) instead.

Wikipedia article about [http://en.wikipedia.org/wiki/Regular_expression regular expressions]

== Syntax ==

The following characters are special : . * + ? ^ $ \ [

Between brackets [], the following are special : ] - ^

Many characters are special when they follow a backslash – see below.

. any character (but newline)
* previous character or group, repeated 0 or more time
+ previous character or group, repeated 1 or more time
? previous character or group, repeated 0 or 1 time
^ start of line
$ end of line
[...] any character between brackets
[^..] any character not in the brackets
[a-z] any character between a and z
\ prevents interpretation of following special char
\| or
\w word constituent
\b word boundary
\sc character with c syntax (e.g. \s- for whitespace char)
 start\end of group
\< \> start\end of word
\` \' start\end of buffer
\1 string matched by the first group
\n string matched by the nth group
\{3\} previous character or group, repeated 3 times
\{3,\} previous character or group, repeated 3 or more times
\{3,6\} previous character or group, repeated 3 to 6 times
.?, +?, and ?? are non-greedy versions of ., +, and ?
\W, \B, and \Sc match any character that does not match \w, \b, and \sc

=== Character category ===

\ca ascii character
\Ca non-ascii character (newline included)
\cl latin character
\cg greek character

=== POSIX character classes ===

[:digit:] a digit, same as [0-9]
[:upper:] a letter in uppercase
[:space:] a whitespace character, as defined by the syntax table
[:xdigit:] an hexadecimal digit
[:cntrl:] a control character
[:ascii:] an ascii character

=== Syntax classes ===

\s- whitespace character \s/ character quote character
\sw word constituent \s$ paired delimiter
\s_ symbol constituent \s' expression prefix
\s. punctuation character \s< comment starter
\s( open delimiter character \s> comment ender
\s) close delimiter character \s! generic comment delimiter
\s" string quote character \s| generic string delimiter
\s\ escape character

== Regexp Examples ==

[-+[:digit:]] digit or + or - sign
$\+\|-$?[0-9]+$\.[0-9]+$? decimal number (-2 or 1.5 but not .2 or 1.)
$\w+$ +\1\> two consecutive, identical words
\<[[:upper:]]\w* word starting with an uppercase letter
+$ trailing whitespaces (note the starting SPC)
\w\{20,\} word with 20 letters or more
\w+phony\> word ending by phony
$19\|20$[0-9]\{2\} year 1900-2099
^.\{6,\} at least 6 symbols
^[a-zA-Z0-9_]\{3,16\}$ decent string for a user name
<tag[^> C-q C-j ]*>$.*?$</tag> html tag

== Emacs Commands that Use Regular Expressions ==

C-M-s incremental forward search matching regexp
C-M-r incremental backward search matching regexp
replace-regexp replace string matching regexp
query-replace-regexp same, but query before each replacement
align-regexp align, using strings matching regexp as delimiters
highlight-regexp highlight strings matching regexp
occur show lines containing a match
multi-occur show lines in all buffers containing a match
how-many count the number of strings matching regexp
keep-lines delete all lines except those containing matches
flush-lines delete lines containing matches
grep call unix grep command and put result in a buffer
lgrep user-friendly interface to the grep command
rgrep recursive grep
dired-do-copy-regexp copy files with names matching regexp
dired-do-rename-regexp rename files matching regexp
find-grep-dired display files containing matches for regexp with Dired

== See Also ==
[[Re-builder]] build regexp interactively in buffer

Emacs Lisp Cookbook

2012-04-09T20:52:57Z

Gregben: grammatical corrections

This page contains snippets of code that demonstrate basic [[Emacs Lisp]]
programming operations in the spirit of O'Reilly's Cookbook
series of books. For every task addressed, a worked-out solution
is presented as a short, focused, directly usable piece of code.

All this stuff can be found elsewhere, but it is scattered about in
libraries, manuals, etc. It would be helpful to have it here in one
spot.

These recipes should be pastable into the '''*scratch*''' buffer so that
users can hit '''C-j''' and evaluate them step by step.

== Strings ==

The empty string (zero-length string, null string, ...):

<syntaxhighlight lang="lisp">
(zerop (string-match "" "")) ;; O(n)
==> t

(string-equal "" "") ;; O(n)?
==> t

(equal "" "") ;; O(n)?
==> t

(zerop (length "")) ;; O(1)
==> t

(eq "" "") ;; O(1)
==> t
</syntaxhighlight>

As a space and performance optimization, Emacs keeps an intern-ed copy
of the empty string as a single object

<syntaxhighlight lang="lisp">
(eq "" (purecopy ""))
==> t

(eq "" (propertize "" 'face 'italic))
==> t
</syntaxhighlight>

=== Strings vs buffer content ===

While it is quite common in other programming languages to work on
strings contained in variables in Emacs it is even more idiomatic to
work on strings in buffers. That's why the following contains examples
of both.

=== Substrings ===

<syntaxhighlight lang="lisp">
(substring "abcdefg" 0 3)
==> "abc"
(substring "abcdefg" -3 -1)
==> "ef"
</syntaxhighlight>

The TO argument is optional:

<syntaxhighlight lang="lisp">
(substring "abcdefg" -3)
==> "efg"
</syntaxhighlight>

Buffers:

<syntaxhighlight lang="lisp">
(with-temp-buffer
(insert "abcdefg")
(buffer-substring 2 4))
==> "bc"
</syntaxhighlight>

=== Processing characters ===

Reversing a string:

<syntaxhighlight lang="lisp">
(string-to-list "foo")
==> (102 111 111)
(reverse (string-to-list "foo"))
==> (111 111 102)
(apply 'string (reverse (string-to-list "foo")))
==> "oof"
</syntaxhighlight>

See CharacterProcessing and StringModification. See [[tr]] for an example of you sometimes need to mix strings and characters.

Looking at characters in buffers:

<syntaxhighlight lang="lisp">
(with-temp-buffer
(insert "abcdefg")
(goto-char (point-min))
(while (not (= (char-after) ?b))
(forward-char))
(point))
==> 2
</syntaxhighlight>

=== Trim whitespace ===

Trim whitespace from the end of a string:

<syntaxhighlight lang="lisp">
(setq test-str "abcdefg ")
(when (string-match "[ \t]*$" test-str)
(message (concat "[" (replace-match "" nil nil test-str) "]")))
</syntaxhighlight>

Trim whitespace from a string with a Perl-like chomp function:

<syntaxhighlight lang="lisp">
(defun chomp (str)
"Chomp leading and tailing whitespace from STR."
(while (string-match "\\`\n+\\|^\\s-+\\|\\s-+$\\|\n+\\'"
str)
(setq str (replace-match "" t t str)))
str)
</syntaxhighlight>

=== Splitting strings ===

TODO

=== Joining strings ===

Use `mapconcat' to join a list into a string using a separator ("glue") between elements in the string.

Example:

<syntaxhighlight lang="lisp">
(mapconcat 'identity '("" "home" "alex " "elisp" "erc") "/")
==> "/home/alex /elisp/erc"
</syntaxhighlight>

=== Serialization ===

The basic idea is to convert forms to strings with `prin1-to-string' and convert it back from a string with `read'.

<syntaxhighlight lang="lisp">
(length (read (prin1-to-string (make-list 1000000 '(x)))))
==> 1000000

(read (prin1-to-string "Hello World!"))
==> "Hello World!"
</syntaxhighlight>

This only works in the simplest cases. Unfortunately, this doesn't work for all Emacs data types for programming or the editor.

<syntaxhighlight lang="lisp">
(read (prin1-to-string (make-hash-table))) ;; Error before Emacs 23.
==> #s(hash-table size 65 test eql rehash-size 1.5 [...] data ())

(read (prin1-to-string (current-buffer)))
==> Lisp error: (invalid-read-syntax "#")
</syntaxhighlight>

=== Formatting ===

== Killing text ==

As the Emacs Lisp Manual says, "Most of the kill commands are primarily for
interactive use [...] When you need to delete text for internal
purposes within a Lisp function, you should normally use deletion
functions, so as not to disturb the kill ring contents."

The following mimic the `kill-' commands but without disturbing the kill ring.

=== Delete region ===

The Lisp equivalent of `kill-region' (`C-w') but without kill ring side effects::

<syntaxhighlight lang="lisp">
(delete-region (region-beginning) (region-end))
</syntaxhighlight>

According to the ElispManual, "Few programs need to use the
`region-beginning' and `region-end' functions." This is because
Lisp code should not rely on nor "alter the mark unless altering
the mark is part of the user-level functionality of the
command. (And, in that case, this effect should be documented.)
To remember a location for internal use in the Lisp program,
store it in a Lisp variable. For example: [...]"

<syntaxhighlight lang="lisp">
(let ((beg (point)))
(forward-line 1)
(delete-region beg (point)))
</syntaxhighlight>

=== Delete line ===

The equivalent of `kill-line' (`C-k') but without kill ring side effects:

<syntaxhighlight lang="lisp">
(let ((beg (point)))
(forward-line 1)
(forward-char -1)
(delete-region beg (point)))
</syntaxhighlight>

Alternatively, replacing the `let' with `save-excursion'.

<syntaxhighlight lang="lisp">
(delete-region (point)
(save-excursion
(forward-line 1)
(forward-char -1)
(point)))
</syntaxhighlight>

Or simplest of all,

<syntaxhighlight lang="lisp">
(delete-region (point) (line-end-position))
</syntaxhighlight>

The examples with `forward-line' are shown because the paradigm is used later, see below.

=== Delete line backwards ===

The equivalent of killing the line backwards (`C-0 C-k') but without kill ring side effects:

<syntaxhighlight lang="lisp">
(let ((beg (point)))
(forward-line 0)
(delete-region (point) beg))
</syntaxhighlight>

Alternatively, replacing the `let' with `save-excursion'.

<syntaxhighlight lang="lisp">
(delete-region (save-excursion
(forward-line 0)
(point))
(point))
</syntaxhighlight>

Or simplest of all,

<syntaxhighlight lang="lisp">
(delete-region (line-beginning-position) (point))
</syntaxhighlight>

=== Delete line to next line ===

The equivalent of killing the line and the newline (`C-1 C-k') but without kill ring side effects:

<syntaxhighlight lang="lisp">
(let ((beg (point)))
(forward-line 1)
(delete-region beg (point)))
</syntaxhighlight>

Alternatively, replacing the `let' with `save-excursion'.

<syntaxhighlight lang="lisp">
(delete-region (point)
(save-excursion
(forward-line 1)
(point)))
</syntaxhighlight>

=== Delete whole line ===

The equivalent of `kill-whole-line' (`C-S-DEL') but without kill ring side effects:

<syntaxhighlight lang="lisp">
(let ((beg (progn (forward-line 0)
(point))))
(forward-line 1)
(delete-region beg (point)))
</syntaxhighlight>

Alternatively, replacing the `let' with `save-excursion'.

<syntaxhighlight lang="lisp">
(delete-region (save-excursion
(forward-line 0)
(point))
(save-excursion
(forward-line 1)
(point)))
</syntaxhighlight>

Or simplest of all,

<syntaxhighlight lang="lisp">
(delete-region (line-beginning-position) (line-end-position))
</syntaxhighlight>

=== Delete word ===

The equivalent of `kill-word' (`M-d') but without kill ring side effects:

<syntaxhighlight lang="lisp">
(let ((beg (point)))
(forward-word 1)
(delete-region beg (point)))
</syntaxhighlight>

Alternatively, replacing the `let' with `save-excursion'.

<syntaxhighlight lang="lisp">
(delete-region (point)
(save-excursion
(forward-word 1)
(point)))
</syntaxhighlight>

=== Delete sentence ===

The equivalent of `kill-sentence' (`M-k') but without kill ring side effects:

<syntaxhighlight lang="lisp">
(let ((beg (point)))
(forward-sentence 1)
(delete-region beg (point)))
</syntaxhighlight>

Alternatively, replacing the `let' with `save-excursion'.

<syntaxhighlight lang="lisp">
(delete-region (point)
(save-excursion
(forward-sentence 1)
(point)))
</syntaxhighlight>

== Numbers ==

=== String a number? ===

<syntaxhighlight lang="lisp">
(defun string-integer-p (string)
(if (string-match "\\`[-+]?[0-9]+\\'" string)
t
nil))

(string-integer-p "1234")
==> t

(string-integer-p "x1234")
==> nil

(string-integer-p "3.141592653589793")
==> nil

(defun string-float-p (string)
(if (string-match "\\`[-+]?[0-9]+\\.[0-9]*\\'" string)
t
nil))

(string-float-p "1234")
==> nil

(string-float-p "3.141592653589793")
==> t

(string-float-p ".1")
==> nil

(string-float-p "1.")
==> t
</syntaxhighlight>

=== String to number ===

<syntaxhighlight lang="lisp">
(defun decimal-number (string)
(let ((n (string-to-number string)))
(if (and (zerop n)
(not (string-match "\\`\\s-*0+\\.?0*\\s-*\\'" string)))
nil
n)))

(decimal-number "536870911")
==> 536870911

(decimal-number "536870912")
==> 536870912.0

(decimal-number "3.141592653589793")
==> 3.141592653589793

(decimal-number "042")
==> 42

(decimal-number " 0 ")
==> 0

(decimal-number "000")
==> 0

(decimal-number "0.0")
==> 0.0
</syntaxhighlight>

=== Random numbers ===

<syntaxhighlight lang="lisp">
(random 2) ;coin toss (0 or 1)
(+ (random 6) 1) ;dice
</syntaxhighlight>

=== Put commas in numbers ===

<syntaxhighlight lang="lisp">
(defun group-number (num &optional size char)
"Format NUM as string grouped to SIZE with CHAR."
;; Based on code for `math-group-float' in calc-ext.el
(let* ((size (or size 3))
(char (or char ","))
(str (if (stringp num)
num
(number-to-string num)))
(pt (or (string-match "[^0-9a-zA-Z]" str) (length str))))
(while (> pt size)
(setq str (concat (substring str 0 (- pt size))
char
(substring str (- pt size)))
pt (- pt size)))
str))

(group-number 299792458)
==> "299,792,458"
(group-number "149597870691" 4 " ")
==> "1495 9787 0691"
</syntaxhighlight>

=== Incrementing numbers ===

TODO

== Dates and times ==

=== Get today's date ===

TODO

=== Formatting dates ===

Use the function `format-time-string' which is a build in function in both Emacsen and works like `strftime':

<syntaxhighlight lang="lisp">
;; Year-Month-Day:
(insert (format-time-string "%Y-%m-%d"))
;; Hour:Minutes:Seconds
(insert (format-time-string "%H-%M-%S"))
</syntaxhighlight>

=== Conversions ===

Read a date from a string.

<syntaxhighlight lang="lisp">
(let ((time (date-to-time "Tue, 27-Sep-83 12:35:59 EST")))
(set-time-zone-rule t) ;; Use Universal time.
(prog1 (format-time-string "%Y-%m-%d %T UTC" time)
(set-time-zone-rule nil))) ;; Reset to default time zone.
==> "1983-09-27 17:35:59 UTC"
</syntaxhighlight>

Decode a time object.

<syntaxhighlight lang="lisp">
(decode-time (date-to-time "Tue, 27-Sep-83 12:35:59 EST"))
==> (59 35 13 27 9 1983 2 t -14400)
</syntaxhighlight>

Get the seconds from the unix epoch.

<syntaxhighlight lang="lisp">
(let ((time (date-to-time "13 Feb 2009 23:31:30 UTC")))
(float-time time))
==> 1234585890.0
</syntaxhighlight>

Find the date for seconds from the unix epoch.

<syntaxhighlight lang="lisp">
(format-time-string "%Y-%m-%d %T UTC" (seconds-to-time 1234585890))
==> "2009-02-13 23:31:30 UTC"
</syntaxhighlight>

Find the date 30 seconds in the future.

<syntaxhighlight lang="lisp">
(format-time-string "%Y-%m-%d %T UTC" (time-add (current-time)
(seconds-to-time 30)))
==> "2012-02-13 10:07:11 UTC"
</syntaxhighlight>

Formatting elapsed time in years, days, hours, minutes and seconds.

<syntaxhighlight lang="lisp">
(format-seconds "%Y %D %h:%m:%s" (1- (* 367 24 3600)))
==> "1 year 1 day 23:59:59"
</syntaxhighlight>

Find the days between two dates.

<syntaxhighlight lang="lisp">
(let ((days1 (time-to-days (date-to-time "Tue, 27-Sep-83 12:35:59 EST")))
(days2 (time-to-days (date-to-time "2009-02-13 23:31:30 UTC"))))
(- days2 days1))
==> 9271
</syntaxhighlight>

Getting the day in the year.

<syntaxhighlight lang="lisp">
(time-to-day-in-year (current-time))
==> 44
</syntaxhighlight>

Build a date based on the day of the year.

<syntaxhighlight lang="lisp">
(format-time-string "%j"
(encode-time 0 0 0 44 1 2012))
==> "044"
</syntaxhighlight>

=== Timers ===

TODO

== Pattern matching ==

"Patterns" refers to RegularExpression""s.

There's a set of functions that work in strings, and a set that work in buffers.

=== Finding ===

<syntaxhighlight lang="lisp">
(string-match "foo*" "Fight foo for food!")
==> 6
</syntaxhighlight>

Buffers:

<syntaxhighlight lang="lisp">
(with-temp-buffer
(insert "Fight foo for food!")
(goto-char (point-min))
(re-search-forward "foo*")
(point))
==> 10
</syntaxhighlight>

Alternative without regular expressions: `search-forward'.

Note that the functions working on buffers move point to the end of the occurrence found and return it.
That's why the result is 10 instead of 6!

=== Comments ===

Move to the beginning of the current comment:

<syntaxhighlight lang="lisp">
(require 'newcomment)
(comment-beginning)
</syntaxhighlight>

Move to the text after a comment:

<syntaxhighlight lang="lisp">
(comment-search-forward (line-end-position) t)
</syntaxhighlight>

See also EndOfLineNoComments.

=== Search and replace ===

<syntaxhighlight lang="lisp">
(replace-regexp-in-string "foo*" "fu" "Fight foo for food!")
==> "Fight fu fur fud!"
</syntaxhighlight>

Buffers:

<syntaxhighlight lang="lisp">
(with-temp-buffer
(insert "Fight foo for food!")
(goto-char (point-min))
(while (re-search-forward "foo*" nil t)
(replace-match "fu"))
(buffer-string))
==> "Fight fu fur fud!"
</syntaxhighlight>

Alternative without regular expressions: `search-forward'.

See also StringSearchAndReplace.

=== Verifying ===

Sometimes you just want to check whether you're at the right place:

<syntaxhighlight lang="lisp">
(with-temp-buffer
(insert "Fight foo for food!")
(goto-char (point-min))
(looking-at "fight"))
==> t
</syntaxhighlight>

== Sequences ==

Datatypes used to represent sequences of things:

_____________________________________________
| |
| Sequence |
| ______ ________________________________ |
| | | | | |
| | List | | Array | |
| | | | ________ ________ | |
| |______| | | | | | | |
| | | Vector | | String | | |
| | |________| |________| | |
| | ____________ _____________ | |
| | | | | | | |
| | | Char-table | | Bool-vector | | |
| | |____________| |_____________| | |
| |________________________________| |
|_____________________________________________|

=== Lists ===

List basics are explained on ListStructure.
Lists can shrink and grow, but access to elements towards the end of the list is slow if the list is long.

Use `cons' to append a new element to the front of a list.
Use `nth' to access an element of the list.

<syntaxhighlight lang="lisp">
(let ((words '("fight" "foo" "for" "food!")))
(when (string= "foo" (nth 1 words))
(setq words (cons "bar" words)))
words)
==> ("bar" "fight" "foo" "for" "food!")
</syntaxhighlight>

See ListModification for more ways of changing a list.

Iteration:

<syntaxhighlight lang="lisp">
(let ((result))
(dolist (word '("fight" "foo" "for" "food!"))
(when (string-match "o" word)
(setq result (cons word result))))
(nreverse result))
==> ("foo" "for" "food!")
</syntaxhighlight>

Note how `cons' adds an element to the front of the list,
so that usually the list has to be reversed after the loop.
`nreverse' is particularly efficient because it does this
destructively by swiveling pointers around. See
DestructiveOperations for more about this.

Copying:

Use `copy-sequence' to make a copy of a list that won't change the
elements of the original.

<syntaxhighlight lang="lisp">
(let* ((orig '((1 2) (3 4)))
(copy (copy-sequence orig)))
(setcdr copy '((5 6)))
(list orig copy))
==> (((1 2) (3 4)) ((1 2) (5 6)))
</syntaxhighlight>

However, the elements in the copy are still from the original.

<syntaxhighlight lang="lisp">
(let* ((orig '((1 2) (3 4)))
(copy (copy-sequence orig)))
(setcdr (cadr copy) '(0))
(list orig copy))
==> (((1 2) (3 0)) ((1 2) (3 0)))
</syntaxhighlight>

The function `copy-tree' is the recursive version of `copy-sequence'.

<syntaxhighlight lang="lisp">
(let* ((orig '((1 2) (3 4)))
(copy (copy-tree orig)))
(setcdr (cadr copy) '(0))
(list orig copy))
==> (((1 2) (3 4)) ((1 2) (3 0)))
</syntaxhighlight>

Filtering:

Emacs Lisp doesn't come with a `filter' function to keep elements that satisfy a conditional and excise the elements that do not satisfy it. One can use `mapcar' to iterate over a list with a conditional, and then use `delq' to remove the `nil' values.

<syntaxhighlight lang="lisp">
(defun my-filter (condp lst)
(delq nil
(mapcar (lambda (x) (and (funcall condp x) x)) lst)))
</syntaxhighlight>

Therefore,

<syntaxhighlight lang="lisp">
(my-filter 'identity my-list)
</syntaxhighlight>

is equivalent to

<syntaxhighlight lang="lisp">
(delq nil my-list)
</syntaxhighlight>

For example:

<syntaxhighlight lang="lisp">
(let ((num-list '(1 'a 2 "nil" 3 nil 4)))
(my-filter 'numberp num-list))
==> (1 2 3 4)
</syntaxhighlight>

Actually the package cl-seq contains the functions `remove-if' and `remove-if-not'. The latter can be used instead of `my-filter'.

<syntaxhighlight lang="lisp">
(let ((num-list '(1 'a 2 "nil" 3 nil 4)))
(remove-if-not 'numberp num-list))
==> (1 2 3 4)

(let ((num-list '(1 'a 2 "nil" 3 nil 4)))
(remove-if 'numberp num-list))
==> ((quote a) "nil" nil)
</syntaxhighlight>

As an example here is the quick sort algorithm:

<syntaxhighlight lang="lisp">
(defun quicksort (lst)
"Implement the quicksort algorithm."
(if (null lst) nil
(let* ((spl (car lst))
(rst (cdr lst))
(smalp (lambda (x)
(< x spl))))
(append (quicksort (remove-if-not smalp rst))
(list spl)
(quicksort (remove-if smalp rst))))))

(quicksort '(5 7 1 3 -9 8 7 -4 0))
==> (-9 -4 0 1 3 5 7 7 8)
</syntaxhighlight>

Tranposing:

Convert multiple lists into a list

<syntaxhighlight lang="lisp">
((lambda (&rest args)
(mapcar (lambda (n)
(delq nil (mapcar (lambda (arg) (nth n arg)) args)))
(number-sequence 0 (1- (apply 'max (mapcar 'length args))))))
'(1 2 3) '(a b c) '(A B C))
==> ((1 a A) (2 b B) (3 c C))
</syntaxhighlight>

A more concise version is possible with the the higher-arity version of mapcar available with the `cl' library.

<syntaxhighlight lang="lisp">
((lambda (&rest args)
(apply (function mapcar*) (function list) args))
'(1 2 3) '(a b c) '(A B C))
==> ((1 a A) (2 b B) (3 c C))
</syntaxhighlight>

Searching:

Simply checking for existence of a value in a list can be done with
`member' or `memq'.

<syntaxhighlight lang="lisp">
(let ((words '("fight" "foo" "for" "food!")))
(car (member "for" words)))
==> "for"

(let ((re "\\wo\\b")
(words '("fight" "foo" "for" "food!")))
(consp (memq t
(mapcar (lambda (s) (numberp (string-match re s))) words))))
==> t
</syntaxhighlight>

In the latter, a more efficient algorithm would use a loop (a non-local exit).

=== Association lists ===

The ElispManual has examples of finding and deleting values in an
association list. Here are cases when the car values are strings.

<syntaxhighlight lang="lisp">
(assoc "2" '(("2" . 2) ("1" . 1) ("2") ("3" . 3)))
==> ("2" . 2)
</syntaxhighlight>

Deleting:

<syntaxhighlight lang="lisp">
(let ((alist '(("a" . 1) ("b" . 2))))
(delq (assoc "a" alist) alist))
==> (("b" . 2))
</syntaxhighlight>

Matches with a test function other than `equal':

<syntaxhighlight lang="lisp">
(let ((alist '(("ab" . 1) ("bc" . 2) ("cd" . 3))))
(assoc-default "c" alist (lambda (x y) (string-match y x))))
==> 2
</syntaxhighlight>

=== Vectors ===

Vectors are fixed in size but elements can be accessed in constant time.

<syntaxhighlight lang="lisp">
(let ((words ["fight" "foo" "for" "food!"]))
(when (string= "foo" (aref words 1))
(aset words 1 "bar"))
words)
==> ["fight" "bar" "for" "food!"]
</syntaxhighlight>

== Hashes ==

Hashes map keys to values. In a way they are similar to alists, except
they are more efficient for a large number of keys.

More info is available on the HashMap page.

=== Storing and retrieving keys and values ===

By default, hash tables use `eql' to compare keys. This is not appropriate
for strings: ##(eql "alex" "alex")## ==> nil. Thus, use `equal' in these cases:

<syntaxhighlight lang="lisp">
(let ((nick-table (make-hash-table :test 'equal)))
(puthash "kensanata" "Alex Schroeder" nick-table)
(gethash "kensanata" nick-table))
==> "Alex Schroeder"
</syntaxhighlight>

Iterate:

<syntaxhighlight lang="lisp">
(let ((nick-table (make-hash-table :test 'equal))
nicks)
(puthash "kensanata" "Alex Schroeder" nick-table)
(puthash "e1f" "Luis Fernandes" nick-table)
(puthash "pjb" "Pascal J. Bourguignon" nick-table)
(maphash (lambda (nick real-name)
(setq nicks (cons nick nicks)))
nick-table)
nicks)
==> ("pjb" "e1f" "kensanata")
</syntaxhighlight>

=== Sorting keys ===

Use `maphash' to build up a list of keys, sort it, and then loop through
the list:

<syntaxhighlight lang="lisp">
(let ((nick-table (make-hash-table :test 'equal))
nicks)
(puthash "kensanata" "Alex Schroeder" nick-table)
(puthash "e1f" "Luis Fernandes" nick-table)
(puthash "pjb" "Pascal J. Bourguignon" nick-table)
(maphash (lambda (nick real-name)
(setq nicks (cons nick nicks)))
nick-table)
(mapcar (lambda (nick)
(concat nick " => " (gethash nick nick-table)))
(sort nicks 'string<)))
==> ("e1f => Luis Fernandes"
"kensanata => Alex Schroeder"
"pjb => Pascal J. Bourguignon")
</syntaxhighlight>

== Files ==

=== Read ===

Processing a file is usually done with a temporary buffer:

<syntaxhighlight lang="lisp">
(defun process-file (file)
"Read the contents of a file into a temp buffer and then do
something there."
(when (file-readable-p file)
(with-temp-buffer
(insert-file-contents file)
(goto-char (point-min))
(while (not (eobp))
;; do something here with buffer content
(forward-line)))))
</syntaxhighlight>

On the chance that a buffer may already be actively visiting the file,
consider using `find-file-noselect'

<syntaxhighlight lang="lisp">
(defun file-string (file)
"Read the contents of a file and return as a string."
(with-current-buffer (find-file-noselect file)
(buffer-string)))
</syntaxhighlight>

=== Write ===

To write something to a file you can create a temporary buffer, insert the things to write there and write the buffer contents to a file. The following example read a string and a filename (with completion, but doesn't need to exist, see InteractiveCodeChar F) and write the string to that file.

<syntaxhighlight lang="lisp">
(defun write-string-to-file (string file)
(interactive "sEnter the string: \nFFile to save to: ")
(with-temp-buffer
(insert string)
(when (file-writable-p file)
(write-region (point-min)
(point-max)
file))))
</syntaxhighlight>

=== Input and output (I/O) ===

This is a nice and simple way to edit a file with Emacs Lisp,
especially when there's a chance the file might be already be visited
in Emacs and its ok to edit the existing buffer.

<syntaxhighlight lang="lisp">
(with-current-buffer (find-file-noselect "~/logfile")
(goto-char (point-max))
(insert (format "Hash of last line: %s"
(md5
(save-excursion
(forward-line -1)
(buffer-substring-no-properties (point)
(line-end-position))))))
(newline)
(with-temp-message "Writing file..."
(save-buffer))
(message "Writing file...done"))
</syntaxhighlight>

=== Searching ===

If you don't have grep, then you may need to write some Lisp which can find a match in a file.

<syntaxhighlight lang="lisp">
;; Visit file unless its already open.
(with-current-buffer (find-file-noselect "~/.emacs")
(save-excursion ;; Don't change location of point.
(goto-char (point-min)) ;; From the beginning...
(if (re-search-forward ".*load-path.*" nil t 1)
(match-string-no-properties 0)
(error "Search failed"))))
==> "(add-to-list 'load-path \"/usr/share/emacs/site-lisp/\")"
</syntaxhighlight>

=== Filter ===

=== Locking ===

=== Stat ===

An interface to the kernel's stat(2) is provided by the function file-attributes. The way times are represented may be a bit unexpected, though.

=== Deleting ===

<syntaxhighlight lang="lisp">
(if (file-exists-p filename)
(delete-file filename))
</syntaxhighlight>

=== Copy, move and rename ===

== Directories ==

=== Traversing ===

<syntaxhighlight lang="lisp">
(defun walk-path (dir action)
"walk DIR executing ACTION with (dir file)"
(cond ((file-directory-p dir)
(or (char-equal ?/ (aref dir(1- (length dir))))
(setq dir (file-name-as-directory dir)))
(let ((lst (directory-files dir nil nil t))
fullname file)
(while lst
(setq file (car lst))
(setq lst (cdr lst))
(cond ((member file '("." "..")))
(t
(and (funcall action dir file)
(setq fullname (concat dir file))
(file-directory-p fullname)
(walk-path fullname action)))))))
(t
(funcall action
(file-name-directory dir)
(file-name-nondirectory dir)))))

(defun walk-path-visitor (dir file)
"Called by walk-path for each file found"
(message (concat dir file)))

(walk-path "~/" 'walk-path-visitor)
</syntaxhighlight>

=== Path splitting ===

Splitting the path can be done with `split-string' and with the slash. Previously, Emacs would determine the character separating directory names with `directory-sep-char'. However, the variable is obselete with Emacs 21.1.

<syntaxhighlight lang="lisp">
(split-string default-directory "/")
==> ("" "usr" "share" "emacs" "22.2" "lisp" "")
</syntaxhighlight>

For splitting a path variable, Emacs already has the `parse-colon-path' function.

<syntaxhighlight lang="lisp">
(parse-colon-path (getenv "PATH"))
==> ("/usr/lib/qt-3.3/bin/" "/usr/kerberos/bin/" "/usr/local/bin/"
"/usr/bin/" "/bin/" "/usr/local/sbin/" "/usr/sbin/" "/sbin/")
</syntaxhighlight>

== Processes ==

=== Running a program ===

Run a command without caring about its output.

<syntaxhighlight lang="lisp">
(async-shell-command "emacs")
</syntaxhighlight>

Run a command and put its output in the current buffer.

<syntaxhighlight lang="lisp">
(shell-command "seq 8 12 | sort" t)
10
11
12
8
9
</syntaxhighlight>

Run a command and put its output in a new buffer.

<syntaxhighlight lang="lisp">
(shell-command "seq 8 12 | sort"
(get-buffer-create "*Standard output*"))
</syntaxhighlight>

Run a command return its output as a string.

<syntaxhighlight lang="lisp">
(shell-command-to-string "seq 8 12 | sort")
</syntaxhighlight>

XEmacs also comes with `exec-to-string'.

=== Handling signals ===

== Sockets ==

=== Tcp client ===

=== Tcp server ===

Perhaps EmacsEchoServer and EmacsDaytimeServer can be useful here.

== Keyboard events ==

* Call function bound to key

<syntaxhighlight lang="lisp">
(funcall (key-binding (kbd "M-TAB")))
</syntaxhighlight>

or

<syntaxhighlight lang="lisp">
(call-interactively (key-binding (kbd "M-TAB")))
</syntaxhighlight>

[[Category:Customization]]
[[Category:Intermediate]]

Main Page

2012-04-09T20:49:40Z

Gregben: grammatical corrections

'''WikEmacs''' (pronounced wiki-macs) collects useful resources for working with [[GNU Emacs]]. Think of it as a
'''next generation, better structured and improved [http://www.emacswiki.org/ Emacs Wiki]''' .
[[File:Emacs-explanation.png|320px|thumb|right|Basic terminology of typical Emacs GUI Frame]]

---------
'''First time visitors''' can start [[#Explore WikEmacs | exploring WikEmacs]]. We have added lots of useful pages since the launch of WikEmacs. We want to keep you excited and engaged.

-----------
We need more '''[[:Category:WikEmacs Contributor|WikEmacs Contributor]]s'''. You can help the following way.

{{Note| First of all, please take a minute to look at the
[[WikEmacs:Guidelines]] before you start editing.}}

* Priority tasks
** Migrate content from [http://www.emacswiki.org EmacsWiki]. Please adopt the following approach -''I found this on EmacsWiki which was helpful. But it took me a lot of time to find it. Now that I have found it, I will put it in WikEmacs so that others can benefit from it.''

* Intermediate tasks
** Provide tutorials or content for the [[:Category:Popular Package|Popular Packages]] or [[:Category:Native Package|Native Packages]].
** Add more content to [[Special:ShortPages]]
** Document or add more [[:Category:Third Party Package|Third Party Package]]s

* Other tasks
** Copy edit [[Special:RecentChanges]] or be a moral police
** Add more members to various [[Special:Categories]]
** Categorize one of these pages [[Special:UncategorizedPages]]

----
'''Emacs News'''

The latest stable release of Emacs is [[GNU Emacs 23|Emacs-23.4]].
The next major release is [[GNU Emacs 24|Emacs-24.1]] and is in ''Pretest'' stage.

Emacs is available on all popular [[:Category:Install Or Upgrade| Operating Systems]] including [[Installing Emacs on GNU/Linux | GNU/Linux]], [[Installing Emacs on BSD |BSD]], [[Installing Emacs on OS X | OS X]] and [[Installing Emacs on Windows| Windows]]. It supports a variety of [[:Category:Programming languages|programming languages]].

= Explore WikEmacs =

To explore WikEmacs proceed as follows:
* Search for or visit a page of interest
* At the end of the page, there is a list of categories
* Click on individual categories and it will give you a list of all pages that will be of interest to you.

== What is your comfort level with Emacs? ==
* [[:Category:Beginner|Beginner]]
* [[:Category:Intermediate|Intermediate]]
* [[:Category:Expert|Expert]]
** Are you a maintainer of a [[:Category:Built-in Package|Built-in Package]]? If you don't find information about your package, please add it. No one else is better than your are to write about it.
** Have you developed any [[:Category:Third Party Package|Third Party Package]]s? Consider writing about what it is and how to use it.
* [[:Category:Vim User|Vim User]]
* [[:Category:User Level|Other]]

== What do you want to accomplish now? ==
* [[:Category:Install Or Upgrade|Install Or Upgrade]]
* [[:Category:Customization|Customize Emacs]]
* [[Key Bindings|Tweak Key Bindings]]
* [[:Category:Tutorial|Learn more Emacs (Tutorials)]]

== What do you use Emacs for? ==
* [[:Category:Text Editing|Text Editing]]
* [[:Category:Programming|Programming]]
* [[:Category:Document authoring|Document authoring]]
* [[:Category:Organizer|Getting Organized]]
* [[:Category:Email|Emailing]]
* [[:Category:Chat|Chatting]]
* [[:Category:Blogging|Blogging]]
* [[:Category:Browse|Browsing]]
* [[:Category:Workflow|Other]]

== How do you involve yourself with the community? ==
* [[:Category:Emacs User]]
* [[:Category:Emacs Contributor]]
* [[:Category:WikEmacs Contributor]]
* [[:Category:User Role|Other]]

[[Category:WikEmacs]]

Main Page

2012-03-26T16:07:53Z

Gregben: /* Getting started with Emacs */

'''Welcome to WikEmacs - A Community Maintained Emacs Wiki'''

== About ==

Useful resources for working with [http://www.gnu.org/software/emacs/emacs.html GNU Emacs], the extensible, self-documenting text editor. See also [http://en.wikipedia.org/wiki/Emacs Emacs (Wikipedia)].

Emacs is [https://en.wikipedia.org/wiki/Free_software free software (Wikipedia)].

WikEmacs (pronounced wikimacs) is intended as a next generation alternative to the traditional [http://www.emacswiki.org/ EmacsWiki].

See [[WikEmacs:Guidelines]] for information on editing this wiki.

== Getting started with Emacs ==

The latest stable release is [[:Category:Emacs-23.4|Emacs-23.4]]. The next major release is [[:Category:Emacs-24.1|Emacs-24.1]] and is in ''Pretest'' stage.

Emacs is available on all popular [[:Category:Operating System | Operating Systems]] including [[GNU/Linux]], [[OSX]] and [[Windows]]. It supports variety of [[:Category:Programming languages|Programming languages]].

Explore this Wiki based on your needs. Here are some starting points:

; [[:Category:User Role|Pages organized by your role in Emacs community]]
: Whether you are a '''''Emacs User''''', a '''''Emacs Contributor''''' or a '''''Programmer''''', there are few things just for you.

; [[:Category:Workflow|Pages organized by your current workflow]]
: Whether you want to '''''write mails''''', '''''browse the web''''', '''''blog''''', '''''read news feeds''''', '''''author documents''''' or for that matter '''''get organized''''', there are few things just for you.

; [[:Category:User Level|Pages organized by your comfort level with Emacs]]
: Whether you are a '''''beginner''''', '''''intermediate user''''' or an '''''expert user''''', here are a few things just for you:

* [[Starter Kits]]
* [[Learning Resources]] and getting help
* [[Package Managers]]
* [[Key Bindings]]
* [[Look and Feel]]
* [[Emacs for Vim users]]
* [[Emacs Terminology]]
** [[Buffer]]
** [[Window]]
** [[Frame]]
** [[Point and mark]]
** [[Killing and yanking]]
** [[Region]]
** [[Fill]]
** Case-fold (compared with case sensitivity)
** Narrow and widen (compared with collapse and expand)
* Quitting Emacs: type `C-x C-c` (that's Control-X, Control-C)

== Text editing in Emacs ==

* [[ Search and replace ]]
** [[ Incremental Search ]]
** [[ Regexp Search ]]
* [[ Undo and redo ]]
* [[ Spell check ]]
* [[ International Users ]]
* [[ Remote Editing ]] via FTP, ssh, etc.
* [[ Emacs server ]] and [[ emacsclient ]]
* [[ Registers ]]
* [[ Bookmarks ]]
* [[ Rectangles ]]

== Automation in Emacs ==

* [[ Keyboard macros ]]
* [[ Emacs Lisp ]]

== Configuring Emacs ==

* [[ Custom ]] for choosing and setting options.
* Scripting your [[ init.el ]] file (formerly .emacs) using [[ Emacs Lisp ]].

== Convenience ==

* Completion and selection
** [[Ido]]: '''I'''nteractively '''do''' things
** [[Helm]]: incremental completion and selection (formerly [[Anything]])
** [[Icicles]]
** Abbrev and dabbrev
** Auto-complete and hippie-expand
** YaSnippet

== Emacs and Desktop Integration ==
* [[ Dired ]]
** [[ Archive mode ]]
* [[ Battery ]]
* [[ Notifications ]]

== Typesetting, Document Markup and Document Creation in Emacs ==

* [[ Markdown ]]
* [[ Org]] export to HTML, PDF etc
* [[ SGML ]], [[ HTML ]] and [[ XML ]]
* [[TeX]], [[LaTeX]], [[TeXinfo]], [[BibTeX]] etc.

== Emacs for Development ==

You can use Emacs to program in variety of [[:Category:Programming languages|Programming languages]]. If you don't see an entry for your favorite language, please create an page for it and few words about it.

=== Markup Languages ===

* [[CSS]]
* [[HTML]]
* [[JSON]]
* [[Markdown]]
* [[SGML]]
* [[XML]]

=== Compiling ===

* [[ flymake ]]

=== Debugging ===

=== REPLs ===

Interactive command-line environments for Lisp. ('''R'''ead-'''E'''val-'''P'''rint-'''L'''oop)

* [[ Inferior Emacs Lisp Mode ]] (IELM), for interacting with Emacs' own internal Lisp
* [[mozrepl]], for interacting with an external web browser's internal JavaScript engine
* [[SLIME]], for interacting with an external Common Lisp or Clojure instance

=== Emacs as an IDE ===

Integrated Development Environment (IDE) for Emacs is called [http://cedet.sourceforge.net/ CEDET]. See [http://alexott.net/en/writings/emacs-devenv/EmacsCedet.html Gentle Introduction to CEDET].

For Literate Programming see [http://orgmode.org/worg/org-contrib/babel/ Org Babel].

=== [[ Version Control ]] ===

Emacs supports many [[Version Control]] systems out of the box and provides bindings and other shortcuts for a better workflow between Emacs and these systems.

Within Emacs, [[ ediff ]] provides sophisticated diff and merge functions. Both [[vc]] and [[dvc]] integrate well with ediff.

== Productivity ==
* [[ Org ]] Mode
* [[ calc ]]
* [[ calendar ]]
* [[ notification ]]
* [[ diary ]]
* Contacts: [[ bbdb ]]

== Communication ==

* [[ Blogging ]]
* [[ Chat ]]
* [[ Email ]]
* [[ Feed reading ]]
* [[ Microblogging ]]
* [[ Usenet news ]]

== Web browsing and web development ==

* [[w3]]: a pure-Emacs-Lisp text-mode web browser.
* [[w3m-el]]: The text-mode w3m web browser hosted and enhanced within Emacs, with rudimentary inline image support but no JavaScript.
* Launching and interacting with an [[external browser]] from emacs
* Using [[emacs as a browser's external editor]], either when entering text on web pages or when viewing a web page's source document or both.

== Shells and terminal emulation ==

Within Emacs you can interact with various shells and other command-line/text-mode programs running as a sub-process within an Emacs terminal emulator:
* [[ ansi-term ]]
* [[ shell ]]
* [[ term ]]
* [[ multi-term ]]

[[ eshell ]] is a shell (not a terminal emulator, nor a process hosted in one) written in pure [[ Emacs Lisp ]]. It is very powerful, flexible and customizable, but poorly documented at time of writing.

Emacs itself is fully functional either in a terminal or a windowing system. Some keystrokes available under window systems may not work in a terminal and vice versa.

== Accessibility ==

* [http://emacspeak.sourceforge.net/ Emacspeak] for the visually challenged.

== Security and cryptography ==

* [[ Gnu Privacy Guard ]] (GPG) support and integration

== Getting Involved ==
* IRC Channel

* [[ Mailing list archives ]]

* [http://bzr.savannah.gnu.org/lh/emacs/trunk/files Browsable source repository]

[[Contributing to Emacs]]

== Niche Uses ==

* [[ Media player ]]
* [[ Presentations ]]
* [[ Screencasts ]]
* [[ Statistics ]]
* [[ Binary files]]
* [[ Docview ]]
* [[ Pictures ]]
** [[ Inline Images ]]
** [[ Artist mode ]]

== Games and Entertainment ==
* Tetris
* Doctor

* Humor

== History ==

* [http://www.gnu.org/gnu/rms-lisp.html My Lisp Experiences and the Development of GNU Emacs]

* XEmacs and GNU Emacs

== Popular Culture and Community ==
* Adding Emacs-style key bindings to other programs and operating systems.
* St Ignucius and the Church of Emacs
* Saving the world from <tt>vi</tt>

WikEmacs:Guidelines

2012-03-26T16:04:17Z

Gregben: /* General */

Start with http://meta.wikimedia.org/wiki/Help:Wikitext_examples if you are new to MediaWiki markup.

== General ==

* Articles should be geared only towards the current and future versions of Emacs (currently 23 and 24) for maintainability's sake. Mentions of older Emacs versions should be as few as possible.
* Articles should not copy Emacs's or extension's official documentation - they should refer to it instead. An overview, some nice pointers, tips and links.
* Comments and questions should go to an article's discussion page. Always sign your comments with the <nowiki>~~~~</nowiki> special syntax after them, otherwise the discussion will be hard to follow.

== Templates ==

There are templates defined for referencing ''variables'', ''function'', ''command'', ''keys'', ''manual'' etc. Use them for uniform experience. See [http://wikemacs.org/wiki/index.php?title=Special%3AAllPages&from=&to=&namespace=10 Templates]. [[Template:Keys]]

== Categories ==

There are special categories defined for ''Operating system'', ''Emacs releases'', ''Programming languages'' etc. Use these when possible or introduce new ones as required. See [[Special:Categories]].