vc-cc does not work
24 years
Anand Narasimhan
Anand Narasimhan
This bug report will be sent to the XEmacs Development Team,
not to your local site managers!!
Please write in English, because the XEmacs maintainers do not have
translators to read other languages for them.
Please describe as succinctly as possible:
- What happened.
- What you thought should have happened.
- Precisely what you were doing at the time.
Please also include any C or lisp back-traces that you may have.
================================================================
Dear Bug Team!
vc-cc does not seem to work. I loaded vc-cc by typing "M-x
load-library: vc-cc. and I did find-file on a directory that is
under clearcase. I get an error "Wrong number of arguments: vc-dired-mode, 1".
================================================================
System Info to help track down your bug:
---------------------------------------
uname -a: SunOS anandn-ultra 5.6 Generic_105181-21 sun4u sparc
./configure '--with-gcc' '-cpp=/opt/sw/gnu/bin/cpp' '--x-includes=/usr/openwin/include' '--x-libraries=/usr/openwin/lib' '--site-prefixes=/opt/sw/gnu' '--site-includes=/opt/sw/gnu/include' '--site-libraries=/opt/sw/gnu/lib' '--prefix=/opt/sw/xemacs-21.4.4' '--with-prefix=no' '--with-cde' '--with-pop' '--with-workshop' '--with-site-lisp=yes' '--pdump'
XEmacs 21.4.4 "Artificial Intelligence" configured for `sparc-sun-solaris2.6'.
Compilation / Installation:
Source code location: /auto/ntgqa/anandn/gnu/src/xemacs-21.4.4
Installation prefix: /opt/sw/xemacs-21.4.4
Additional header files: /opt/sw/gnu/include
Additional libraries: /opt/sw/gnu/lib
Additional prefixes: /opt/sw/gnu
Runtime library search path: /opt/sw/gnu/lib:/usr/dt/lib:/usr/openwin/lib:/opt/sw/gnu/lib/gcc-lib/sparc-sun-solaris2.6/3.0.1/../../..
Operating system description file: `s/sol2.h'
Machine description file: `m/sparc.h'
Compiler: gcc -g -O3 -Wall -Wno-switch -Winline -Wmissing-prototypes -Wshadow -Wsign-compare -Wpointer-arith
Relocating allocator for buffers: yes
GNU version of malloc: yes
Window System:
Compiling in support for the X window system:
- X Windows headers location: /usr/dt/include /usr/openwin/include
- X Windows libraries location: /usr/dt/lib /usr/openwin/lib
- Handling WM_COMMAND properly.
Using Lucid menubars.
Using Lucid scrollbars.
Using Motif dialog boxes.
Using Motif native widgets.
TTY:
Compiling in support for ncurses.
Images:
Compiling in support for GIF images (builtin).
Compiling in support for XPM images.
Compiling in support for PNG images.
Compiling in support for JPEG images.
Compiling in support for TIFF images.
Sound:
Compiling in support for sound (native).
Databases:
Compiling in support for DBM.
Internationalization:
Mail:
Compiling in support for POP mail retrieval.
Compiling in support for "dot-locking" mail spool file locking method.
Other Features:
Compiling in support for ToolTalk.
Compiling in support for Sun WorkShop.
Compiling in support for dynamic shared object modules.
Using the new portable dumper.
Load-Path Lisp Shadows:
----------------------
(/opt/sw/xemacs-21.4.4/lib/xemacs/xemacs-packages/lisp/edit-utils/setnu
/opt/sw/xemacs-21.4.4/lib/xemacs/xemacs-packages/lisp/jde-2.2.8/setnu)
Installed XEmacs Packages:
-------------------------
((xslt-process :version 1.05 :type regular)
(xemacs-devel :version 1.37 :type single-file)
(xemacs-base :version 1.55 :type regular)
(w3 :version 1.2 :type regular)
(vm :version 6.96 :type regular)
(viper :version 1.26 :type regular)
(view-process :version 1.11 :type regular)
(vc-cc :version 1.16 :type regular)
(vc :version 1.28 :type regular)
(tooltalk :version 1.13 :type regular)
(tm :version 1.29 :type regular)
(time :version 1.11 :type regular)
(textools :version 1.12 :type regular)
(text-modes :version 1.32 :type single-file)
(texinfo :version 1.2 :type regular)
(supercite :version 1.18 :type regular)
(strokes :version 1.08 :type regular)
(speedbar :version 1.21 :type regular)
(sounds-au :version 1.1 :type regular)
(slider :version 1.13 :type regular)
(sh-script :version 1.13 :type regular)
(sgml :version 1.08 :type regular)
(semantic :version 1.1 :type regular)
(rmail :version 1.12 :type regular)
(psgml :version 1.23 :type regular)
(ps-print-nomule :version 1.05 :type regular)
(prog-modes
:version
1
.41
:type
single-file)
(pcomplete :version 1.01 :type regular)
(pcl-cvs :version 1.55 :type regular)
(pc :version 1.2 :type single-file)
(os-utils :version 1.25 :type single-file)
(net-utils :version 1.23 :type single-file)
(mh-e :version 1.13 :type regular)
(mew :version 1.14 :type regular)
(mailcrypt :version 2.09 :type regular)
(mail-lib :version 1.39 :type regular)
(ispell :version 1.23 :type regular)
(ilisp :version 1.19 :type regular)
(igrep :version 1.08 :type regular)
(hm--html-menus :version 1.16 :type regular)
(gnus :version 1.57 :type regular)
(gnats :version 1.12 :type regular)
(fsf-compat :version 1.09 :type single-file)
(frame-icon :version 1.09 :type regular)
(forms :version 1.13 :type regular)
(footnote :version 1.13 :type regular)
(eterm :version 1.13 :type regular)
(eshell :version 1.01 :type regular)
(emerge :version 1.09 :type regular)
(elib :version 1.08 :type single-file)
(eieio :version 1.01 :type regular)
(efs :version 1.26 :type regular)
(edit-utils :version 1.69 :type single-file)
(ediff :version 1.31 :type regular)
(edebug :version 1.14 :type regular)
(dired :version 1.11 :type regular)
(dictionary :version 1.0 :type regular)
(debug :version 1.14 :type regular)
(cc-mode :version 1.26 :type regular)
(calendar :version 1.16 :type regular)
(calc :version 1.17 :type regular)
(c-support :version 1.16 :type single-file)
(build :version 1.02 :type regular)
(auctex :version 1.25 :type regular)
(apel :version 1.2 :type regular)
(Sun :version 1.13 :type regular))
Features:
--------
(mail-abbrevs xemacsbug shadow sendmail vc vc-hooks dired-faces
dired-xemacs dired vc-cc tq comint ring vc-cc-hooks advice
advice-preload pending-del fast-lock lazy-lock font-lock env time
cus-face xslt-process-autoloads xemacs-devel-autoloads
xemacs-base-autoloads w3-autoloads vm-autoloads viper-autoloads
view-process-autoloads vc-cc-autoloads vc-autoloads tooltalk-autoloads
tm-autoloads time-autoloads textools-autoloads text-modes-autoloads
texinfo-autoloads supercite-autoloads strokes-autoloads
speedbar-autoloads sounds-au-autoloads slider-autoloads
sh-script-autoloads sgml-autoloads semantic-autoloads rmail-autoloads
psgml-autoloads ps-print-nomule-autoloads prog-modes-autoloads
pcomplete-autoloads pcl-cvs-autoloads pc-autoloads os-utils-autoloads
net-utils-autoloads mh-e-autoloads mew-autoloads mailcrypt-autoloads
mail-lib-autoloads ispell-autoloads ilisp-autoloads igrep-autoloads
hm--html-menus-autoloads gnus-autoloads gnats-autoloads
fsf-compat-autoloads frame-icon-autoloads forms-autoloads
footnote-autoloads eterm-autoloads eshell-autoloads emerge-autoloads
elib-autoloads eieio-autoloads efs-autoloads edit-utils-autoloads
ediff-autoloads edebug-autoloads dired-autoloads dictionary-autoloads
debug-autoloads cc-mode-autoloads calendar-autoloads calc-autoloads
c-support-autoloads build-autoloads auctex-autoloads apel-autoloads
Sun-autoloads lisp-autoloads loadhist auto-show fontl-hooks
x-iso8859-1 gutter-items menubar-items x-menubar mode-motion mouse
itimer auto-save lisp-mode easymenu iso8859-1 page buff-menu
lib-complete help-nomule cus-file derived frame text-props obsolete
cus-start custom widget cl-extra mini-cl cl cl-19 packages backquote
very-early-lisp sparcworks tooltalk lucid-scrollbars cut-buffer
lucid-menubars motif-dialogs x c-balloon-help tty-frames tty toolbar
native-sound scrollbar unix-processes multicast network-streams
subprocesses modules menu-accelerator-support menubar dbm md5 xemacs
gutter tiff png gif jpeg xpm xbm lisp-float-type usg-unix-v dialog
devices window-system base64)
Recent keystrokes:
-----------------
ESC x l o a d SPC l SPC RET v c - c c RET C-x C-f RET
C-x C-f / v o b / n g / d BS BS BS t g / d e v / j
TAB n TAB a d TAB m TAB s r TAB RET misc-user
Recent messages (most recent first):
-----------------------------------
Parsing /users/anandn/.mailrc...
Loading mail-abbrevs...done
Loading mail-abbrevs...
Loading xemacsbug...done
Wrong number of arguments: vc-dired-mode, 1
Loading xemacsbug...
Reading directory /vob/ntg/dev/java/netsys/adminconsole/mpls/sreditor/...done
Reading directory /vob/ntg/dev/java/netsys/adminconsole/mpls/sreditor/...
Reading directory /users/anandn/...done
Reading directory /users/anandn/...
Loading dired...done
Loading dired...
Loading vc-cc...done
Loading vc-cc...
Loading usg-unix-v-emacs.el...done
Loading pending-del...done
Loading pending-del...
Loading fast-lock...done
Loading fast-lock...
Loading lazy-lock...done
- 2 participants
- 2 comments
mail-lib sync and Gnus package
24 years
Simon Josefsson
Simon Josefsson
I'm trying to sync Emacs sendmail.el with mail-lib, and it seems that
the Emacs version RFC 2047 encodes non-ASCII user names.
So unless mail-lib require the gnus package (which is bad), some files
would need to be moved from the gnus package into the mail-lib
package, namely at least the following (determined by looking at
`require' lines, but there may be hidden dependencies):
rfc2047.el
qp.el
mm-util.el
ietf-drums.el
time-date.el
parse-time.el
mail-prsvr.el
The rfc2047.el file would probably need modifications to work without
the following files as well:
gnus-util.el
nnheader.el
What do you think, especially the gnus package maintainer?
MIME is probably a Pandora's box that will drag in lots of files into
mail-lib, but it is probably inevitable unless we want `M-x mail' to
be a ASCII-only thing, which I think is wrong. What could be a
problem though, is if some MIME related package requires Mule, but I
don't think this is the case.
- 2 participants
- 1 comments
new TUTORIAL; need translation help!
24 years
Ben Wing
Ben Wing
I've made extensive updates to the tutorial. The tutorial was ancient, full of
GNU-Emacs-specific things that were done differently on XEmacs, and very much
focused on TTY's. I redid all of this, so that it now reflects standard XEmacs
ways of doing things and focuses primarily on window systems (e.g. window-system
bindings are used in the examples and are considered the "standard" way of doing
things; TTY bindings are mentioned parenthetically).
There are a very small number of things in the tutorial that don't quite
currently make sense for 21.5; that's because I wrote it with my new Mule
workspace in mind, where I've changed a few key bindings [mostly, I made ESC ESC
the standard "all-purpose exit" on window systems, and left the triple ESC ESC
ESC for TTY's, since ESC ESC is a lot more convenient and TTY users have to deal
with lots of different bindings anyway].
I'm looking for people to update the various foreign-language versions of the
tutorial.
We also have versions of tutorials in five new languages, from GNU Emacs.
[Spanish, Dutch, Czech, Slovak, Slovenian] However, these will need extensive
updating for the new tutorial, as will the others.
Please help!
I'm attaching my new tutorial, plus the versions in the five new languages.
ben
You are looking at the XEmacs tutorial. See end for copyrights and conditions.
XEmacs commands generally involve the CONTROL key (sometimes labeled
CTRL or CTL) or the META key. "META" is a traditional Emacs term; on
most keyboards, the key is labelled "Alt". (On Sun keyboards, the META
key is labelled with a diamond, and is *NOT* the Alt key, which also
exists.) On some TTY's, there is no META key; in this case, use ESC.
Rather than write out META or CONTROL each time we want you to prefix a
character, we'll use the following abbreviations:
C-<chr> means hold the CONTROL key while typing the character <chr>
Thus, C-f would be: hold the CONTROL key and type f.
M-<chr> means hold the META (i.e. Alt) key down while typing <chr>.
(See above for Sun keyboards and TTY's.)
Important note: to end the XEmacs session, type C-x C-c. (Two characters.)
To move to the next screen, type <Next> (often labeled PgDn). On TTY's,
you may not have such a key; use C-v instead. (Hold down the CONTROL key
while typing v.)
To move to the previous screen, type <Prior> (often labeled PgUp). On
TTY's, use M-v. (Remember, this means META + v; if you have no META or Alt
key that works, press and release ESC, then type v.)
The characters ">>" at the left margin indicate directions for you to
try using a command. For instance:
>> Try typing <Next> and then <Prior>, a few times. (Or C-v and M-v,
on TTY's.)
Note that there is an overlap of two lines when you move from screen to
screen; this provides some continuity so you can continue reading the text.
In general, every "cursor key" (the arrows and similar keys set off to the
right side of the keyboard) has an equivalent binding that uses only the
alphanumeric keys in combination with CONTROL and/or META, so that TTY
users can use XEmacs.
(In fact, in olden days, this "older way" was the only way to do things,
and you will still often see references to these keys as the "recommended"
way of doing things. We don't actually recommend that you use these older
bindings in preference to the more obvious cursor keys, since the cursor
keys are easier to remember and usually more convenient to use. However,
it's useful to know the older bindings, either in case you ever use a TTY
or so that you can make sense of references to them. From now on, we will
mention the TTY bindings in parentheses, and expect that TTY users will
subsitute them whenever we mention a cursor key.)
Now you may ask, what is a TTY? A TTY (or "TeleTYpe")is a text-only
connection, the kind you get when you use the "telnet" program to log into
a remote site. Up till 20 years ago or so, such text-only connections were
all that existed to communicate with a computer, usually via a "terminal"
(a combination keyboard and monochrome screen) connected directly to a
computer. Nowadays, such dedicated TTY's are increasingly rare, and most
people only run into them when using telnet. Emacs began in those olden
days, and it still carries some baggage from that time, but things have
greatly improved since then. Now, you are probably using XEmacs under MS
Windows or X Windows, collectively termed a "window system".
* SUMMARY
---------
The following commands are useful for viewing screenfuls:
<Next> Move forward one screenful (C-v on TTY's)
<Prior> Move backward one screenful (M-v on TTY's)
C-l Clear screen and redisplay all the text,
moving the text around the cursor
to the center of the window.
(That's CONTROL-L, not CONTROL-1.)
>> Find the cursor, and note what text is near it.
Then type C-l.
Find the cursor again and notice that the same text
is near the cursor now.
* BASIC CURSOR CONTROL
----------------------
The first thing that you need to know is how to move around from place
to place in the text. You already know how to move forward and backward
one screen, but how do you move to a specific place within the text on
the screen?
There are several ways you can do this. The most basic way is to use
the arrow keys, which we refer to as <Left>, <Right>, <Up>, and <Down>.
Each of these commands moves the cursor one row or column in a
particular direction on the screen.
On a TTY, the arrow keys should, hopefully, work the same, but they
might not, since TTY's are easy to misconfigure. As mentioned above,
for all cursor-key bindings, there are equivalent alphanumeric ones. In
this case, the bindings are unfortunately not at all obvious, since they
were chosen mnemonically and not visually. Here is a table showing the
TTY bindings:
Previous line, C-p
:
:
Backward, C-b .... Current cursor position .... Forward, C-f
:
:
Next line, C-n
>> Move the cursor to the line in the middle of that diagram using <Down>
or <Up>. Then type C-l to see the whole diagram centered in the window.
(Remember, TTY users should substitute the appropriate bindings whenever
necessary. In this case, use C-n and C-p.)
Note the mnemonic significance of the TTY bindings: P for previous, N
for next, B for backward and F for forward. If you're on a TTY, you
really should spend some time now etching these cursor bindings into
your brain. These cursor positioning commands are the most fundamental
way to move around and you'll be using them ALL the time, so you will be
completely lost without them.
Even if you are on a window system and are not forced to learn these
bindings, you should try to memorize at least these four commands and in
particular their associated words, since variations on them show up in
many different keyboard commands, and knowing what they stand for can be
of tremendous help.
>> Do a few <Down>'s to bring the cursor down to this line.
>> Move into the line with <Right>'s and then up with <Up>'s.
See what <Up> does when the cursor is in the middle of the line.
The location of the cursor in the text is also called "point". You will
often see such references to "point" in the documentation, so remember
this term.
Each line of text ends with a Newline character, which serves to separate
it from the following line. The last line in your file ought to have a
Newline at the end. XEmacs does not normally require it to have one, but
you can change this -- see the menu entry "Options/Editing/Newline at End
of File...". (More on menu entries later.)
>> Try to <Left> at the beginning of a line. It should move to
the end of the previous line. This is because it moves back
across the Newline character.
<Right> can move across a Newline just like <Left>.
>> Do a few more <Left>'s, so you get a feel for where the cursor is.
Then do <Right>'s to return to the end of the line.
Then do one more <Right> to move to the following line.
When you move past the top or bottom of the window, the text beyond
the edge shifts onto the screen. This is called "scrolling". It
enables XEmacs to move the cursor to the specified place in the text
without moving it off the screen.
>> Try to move the cursor off the bottom of the window with <Down>, and
see what happens.
If moving by characters is too slow, you can move by words. C-<Right>
(CONTROL + right-arrow key) moves forward a word and C-<Left> moves back a
word. On TTY's, use M-f instead of C-<Right> and M-p instead of C-<Left>.
>> Type a few C-<Right>'s and C-<Left>'s.
When you are in the middle of a word, C-<Right> moves to the end of the
word. When you are in whitespace between words, C-<Right> moves to the
end of the following word. C-<Left> works likewise in the opposite
direction.
>> Type C-<Right> and C-<Left> a few times, interspersed with <Right>'s and
<Left>'s so that you can observe the action of C-<Right> and C-<Left>
from various places inside and between words.
Notice the parallel between <Right> and <Left> on the one hand, and
C-<Right> and C-<Left> on the other hand. Also notice the parallel
between C-f and C-p on the one hand, and M-f and M-p on the other hand.
XEmacs tries fairly hard to maintain parallelism in keyboard commands to
make them easier to remember, and generally adding CONTROL or META to an
operation makes it "more so". META goes beyond CONTROL, often making
the units of movement less basic in the process -- words vs. characters,
balanced parenthetical expressions vs. words, or sentences vs. lines.
Other important cursor motion commands are <Home> and <End> (beginning
and end of the line), and C-<Home> and C-<End> (beginning and end of the
whole text). Note again the parallelism just mentioned.
On TTY's, use C-a and C-e for beginning and end of line, and M-< and M->
for beginning and end of text. (If it helps, think of A as the first
letter of the alphabet, and E as standing for "end".) Note that the <
and > chars (Less-than and Greater-than) are above the comma and period
on most keyboards, so you'll have to use the SHIFT key in conjunction
with META. If you have no META, the order is very important: Type ESC
first, then type < or >.
>> Move the cursor to this line, then try <Home> and <End> a few times.
>> (Read this entire entry before doing anything!) Try C-<Home> now, to
move to the beginning of the tutorial. Then use <Next> repeatedly to
move back here.
>> Try all of these commands now a few times for practice.
These are the most often used commands.
Here is a summary of simple cursor-moving operations. Don't worry if you
can't remember everything; you can always move back to this table for
reference.
KEYSTROKE: SEQUENCE TTY:
<Prior> (PgUp) Move backward a screen M-v
<Next> (PgDn) Move forward a screen C-v
<Left> Move backward a character C-b
<Right> Move forward a character C-f
C-<Left> Move backward a word M-b
C-<Right> Move forward a word M-f
<Up> Move to previous line C-p
<Down> Move to next line C-n
C-<Up> Move 6 lines up
C-<Down> Move 6 lines down
<Home> Move to beginning of line C-a
<End> Move to end of line C-e
C-<Home> Move to beginning of text M-<
C-<End> Move to end of text M->
* PREFIX ARGUMENTS
------------------
Most XEmacs commands accept a numeric argument; for most commands, this
serves as a repeat-count. The way you give a command a repeat count is
by holding down the META key while typing the digits. You really only
need to hold down META for the first digit; for this reason, an
alternative method is to simply hit the ESC key once, then type the
digits. (This latter method works on TTY's as well.) The numeric
argument is also called a "prefix argument", because you type the
argument before the command it applies to.
For instance, M-8 <Right> moves forward eight characters.
>> Try using <Down> or <Up> with a numeric argument, to move the cursor
to a line near this one with just one command.
Sometimes, commands use the term "prefix argument" to refer not to a
numeric argument, but to just a flag that makes the command do something
different if given. (We haven't encountered any such commands so far.)
For such commands, the flag is normally given by typing C-u before the
command, but generally you can also specify any numeric argument -- the
actual number makes no difference.
* SCROLLBARS
------------
Unless you are on a TTY, there is probably a rectangular area called a
scroll bar at the right hand side of the XEmacs window. You can scroll the
text by manipulating the scrollbar with the mouse.
The scrollbar has a button in the middle of it, called a thumb. The
relative position of this thumb within the rectangle indicates where you
are within the file. As you scroll up or down with the cursor keys, the
thumb will follow.
>> Try holding down the left button on the thumb and moving the mouse up
and down. You'll see that the text scrolls up and down as you move the
mouse. (NOTE: Some scrollbars, such as the Athena scrollbars under X
Windows, work differently. On these, you will have to use the middle
button, not the left one.)
>> Try clicking the left button in the area above the thumb. This should
scroll the text up by a screenful. Similarly, clicking the button below
the thumb will scroll down by a screenful. (NOTE: Under Athena, things
work differently.) Holding the button down will cause the text to
repeatedly scroll by a screenful.
>> Most scrollbars have arrows at the top and bottom of the rectangle.
Clicking on these will scroll the text up or down by a line, and holding
the button down will cause the text to repeatedly scroll by a line.
* USING THE MENU
----------------
Unless you are on a TTY, you will notice a menubar at the top of the
XEmacs frame. You can use this menubar to access all the most common
XEmacs commands, such as "open a file". You will find this easier at
first, because you don't need to remember the keystrokes necessary to
access any particular command. Once you are comfortable with XEmacs, it
will be easy to begin using the keyboard commands because each menu item
with a corresponding keyboard command has the command listed next to it.
Note that there are many items in the menubar that have no exact
keyboard equivalents. For example, the Buffers menu lists all of the
available buffers in most-recently used order. You can switch to any
buffer by simply findings its name in the Buffers menu and selecting it.
You can also configure XEmacs so that you can use the META key to access
menu items -- the "accelerator" functionality that is standard under MS
Windows. One easy way to do this in XEmacs is using the menu item
"Options/Menubars/Alt/Meta Selects Menu Items". (The final slash between
"Alt" and "Meta" is part of the item name.)
When this feature is on, you can select a menu or menu item using the
combination of META (i.e. Alt) plus the underlined letter of the menu item.
For example, to exit XEmacs, use M-f M-x. We currently don't turn this on
by default because it interferes with the traditional usage of META in
XEmacs. However, we may do this in the future: Only commands for which
there are top-level menus are shadowed by accelerator bindings, and for all
those commands, there are equivalents either using cursor keys or on the
menus.
When we mention a menu selection, it will be specified as just shown --
i.e. a string, with slashes separating different submenus or items. In
this case, the menu entry just mentioned means "Click the Options menu
on the menubar, then the Menubars submenu, the the entry off of that
labeled "Alt/Meta Selects Menu Items". In general, XEmacs is highly
customizable, and one of these easiest ways to make such customizations
is through the Options menu.
IMPORTANT: If you want a change on the Options menu to last beyond the
current XEmacs session, use "Options/Save Options to Init File". This
way, it will be permanent. Otherwise, all Options changes made in the
current session will be lost.
* WHEN XEMACS IS HUNG OR IN SOME STRANGE MODE
---------------------------------------------
If XEmacs stops responding to your commands, you can stop it safely by
typing C-g. You can use C-g to stop a command which is taking too
long to execute.
You can also use C-g to discard a numeric argument or the beginning of
a command that you do not want to finish.
>> Type M-100 to make a numeric arg of 100 (remember, this means hold
down META and type 100, or type ESC 1 0 0), then type C-g. Now type
<Right>. It should move just one character, because you canceled the
argument with C-g.
If XEmacs is in some strange mode and C-g isn't getting out of it, you
can use the all-purpose escape mechanism: ESC ESC. (On TTY's, you have
to use ESC ESC ESC. The reasons for this are a bit complicated.)
Hitting ESC ESC will get you out of almost any weird mode, including
selected text, split windows, the minibuffer, recursive edits, "stranded
minibuffer requests", and the like. If you have many problems at once,
each invokation of ESC ESC will get rid of one, so keep repeating until
everything's fixed. REMEMBER: ESC ESC does not work if XEmacs is hung
doing some time-consuming operation or running broken code. Use C-g for
that.
* DISABLED COMMANDS
-------------------
Some XEmacs commands are "disabled" so that beginning users cannot use
them by accident.
If you type one of the disabled commands, XEmacs displays a message
saying what the command was, and asking you whether you want to go
ahead and execute the command.
If you really want to try the command, type Space in answer to the
question. Normally, if you do not want to execute the disabled
command, answer the question with "n".
>> Type `C-x n p' (which is a disabled command),
then type n to answer the question.
* "WINDOWS", I.E. PANES
-----------------------
XEmacs can have several panes (i.e. non-overlapping divisions of a window
or a TTY screen), each displaying its own text. For historical reasons,
these panes are called "windows", and what we normally think of as a
window is called a "frame". XEmacs can also have multiple "frames"; this
is described later. From now on, we omit the quotes around the XEmacs
terms, and if we need to use "window" in the standard sense, we will say
"window-system window".
At this stage it is better not to go too deeply into the techniques of
using multiple windows. But you do need to know how to get rid of extra
windows that may appear to display help or output from certain commands.
Most of the time, your cursor will be in the new window; if this is the
case, simply type q. Alternatively, you can type
C-x 0 Delete window.
That is, CONTROL-x followed by the digit 0. This command is unlike the
other commands you have learned in that it consists of two characters. It
starts with the character CONTROL-x. There is a whole series of commands
that start with CONTROL-x; many of them have to do with windows, files,
buffers, and related things. These commands are two, three or four
characters long.
>> Move the cursor to this line and type M-0 C-l.
(That's a zero, not an Oh.)
>> Type CONTROL-h k CONTROL-f.
See how this window shrinks, while a new one appears
to display documentation on the CONTROL-f command.
>> Type q and see the documentation listing window disappear.
(Remember that C-l redraws the screen. If you give a numeric argument to
this command, it means "redraw the screen and put the current line that
many lines from the top of the window." So M-0 C-l means "redraw the
screen, putting the current line at the top.")
* INSERTING AND DELETING
------------------------
If you want to insert text, just type the text. Characters which you can
see, such as A, 7, *, etc. are taken by XEmacs as text and inserted
immediately. Type <Return> (the carriage-return key) to insert a Newline
character.
You can delete the last character you typed by typing <Backspace>.
<Backspace> is a key on the keyboard, which may be labeled simply with a
left arrow sign.
(NOTE: On a few misconfigured TTY's, typing <Backspace> may try to invoke
the help system; the symptom of this is a line like "C-h (Type ? for
further options)" at the bottom of the screen. If this is the case, type
C-g to get out of this, and try using <Delete> from now on in place of
<Backspace>.)
More generally, <Backspace> deletes the character immediately before the
current cursor position.
>> Do this now--type a few characters, then delete them
by typing <Backspace> a few times. Don't worry about this file
being changed; you will not alter the master tutorial. This is
your personal copy of it.
When a line of text gets too big for one line on the frame, the line of
text is "continued" onto a second frame line. An arrow at the right
margin that hooks down and to the left (or a backslash ("\") on TTY's)
indicates a line which has been continued.
>> Insert text until you reach the right margin, and keep on inserting.
You'll see a continuation line appear.
>> Use <Backspace>s to delete the text until the line fits on one frame
line again. The continuation line goes away.
You can delete a Newline character just like any other character.
Deleting the Newline character between two lines merges them into
one line. If the resulting combined line is too long to fit in the
frame width, it will be displayed with a continuation line.
>> Move the cursor to the beginning of a line and type <Backspace>. This
merges that line with the previous line.
>> Type <Return> to reinsert the Newline you deleted.
Remember that most XEmacs commands can be given a repeat count;
this includes text characters. Repeating a text character inserts
it several times.
>> Try that now -- type M-8 * to insert ********.
You've now learned the most basic way of typing something in
XEmacs and correcting errors. You can delete by words or lines
as well. Here is a summary of the delete operations:
<Backspace> delete the character just before the cursor
<Delete> delete the next character after the cursor
C-d same as <Delete> but works on TTY's
M-<Backspace> cut ("kill") the word immediately before the cursor
M-<Delete> cut ("kill") the next word after the cursor
M-d same as M-<Delete> but works on TTY's
C-k cut ("kill") from the cursor position to end of line
M-k cut ("kill") to the end of the current sentence
Notice again the parallelism with no modifier vs. CONTROL vs. META that
was mentioned earlier -- although the parallels are not perfect.
(In the violent old days when Emacs first began, removing text that
could later be re-inserted was called "killing", and re-inserting was
called "yanking" -- evidently the designers of Emacs must have been
thinking of role-playing games, where killed characters could be easily
resurrected with the wave [yank?] of a magic wand. In the more genteel
[and realistic] times we live in, the preferred terms are "cut" and
"paste".)
You can also kill any part of the buffer with one uniform method. Under
window systems, the preferred method is to move to one end of that part,
hold the SHIFT key down, and use the cursor keys to move to the other
end. Then release the SHIFT key and type C-w. That kills all the text
between the two positions.
An alternative method, which also works on TTY's, is to move to one end of
the text, and type C-＠ or C-SPC (either one). (SPC is the Space bar.)
Move to the other end and type C-w.
>> Move the cursor to the A at the start of the previous paragraph.
>> Hold the SHIFT key down.
>> Move the cursor to the n in "end", on the third line of the
paragraph.
>> Release the SHIFT key and type C-w. This will kill the text starting
from the A, and ending just before the n.
Now try it the other way.
>> Type C-/ to undo the killing, or C-_ or C-x u on TTY's.
>> Move the cursor to the same A again.
>> Type C-SPC. XEmacs should display a message "Mark set"
at the bottom of the frame.
>> Move the cursor to the n in "end", on the third line of the
paragraph.
>> Type C-w. You will get the same result as previously.
The difference between "killing" and "deleting" is that "killed" text
can be reinserted, whereas "deleted" things cannot be reinserted.
Reinsertion of killed text is called "yanking". Generally, the
commands that can remove a lot of text kill the text (they set up so
that you can yank the text), while the commands that remove just one
character, or just blank lines and spaces, do deletion (so you cannot
yank that text).
Normally, on a window system "killing" text stores it internally but
also puts it on the clipboard, just like Cut in a word processor, and
"yanking" takes text from the clipboard if available, just like Paste.
(This connection to the clipboard can be turned off from the Options
menu.) There are also menu items, "Edit/Cut" and "Edit/Paste", that
always connect with the clipboard, and equivalent Cut and Paste keys on
Sun keyboards.
>> Move the cursor to the beginning of a line which is not empty.
Then type C-k to kill the text on that line.
>> Type C-k a second time. You'll see that it kills the Newline
which follows that line.
Note that a single C-k kills the contents of the line, and a second
C-k kills the line itself, and makes all the other lines move up. C-k
treats a numeric argument specially: it kills that many lines AND
their contents. This is not mere repetition. M-2 C-k kills two
lines and their newlines; typing C-k twice would not do that.
Bringing back killed text is called "yanking". (Think of it as
yanking back, or pulling back, some text that was taken away.) You
can yank the killed text either at the same place where it was killed,
or at some other place in the buffer, or even in a different file.
You can yank the text several times, which makes multiple copies of
it.
The command for yanking is C-y. It reinserts the last killed text,
at the current cursor position.
>> Try it; type C-y to yank the text back.
If you do several C-k's in a row, all of the killed text is saved
together, so that one C-y will yank all of the lines at once.
>> Do this now, type C-k several times.
Now to retrieve that killed text:
>> Type C-y. Then move the cursor down a few lines and type C-y
again. You now see how to copy some text.
What do you do if you have some text you want to yank back, and then
you kill something else? C-y would yank the more recent kill. But
the previous text is not lost. You can get back to it using the M-y
command. After you have done C-y to get the most recent kill, typing
M-y replaces that yanked text with the previous kill. Typing M-y
again and again brings in earlier and earlier kills. When you have
reached the text you are looking for, you do not have to do anything to
keep it. Just go on with your editing, leaving the yanked text where
it is.
If you M-y enough times, you come back to the starting point (the most
recent kill).
>> Kill a line, move around, kill another line.
Then do C-y to get back the second killed line.
Then do M-y and it will be replaced by the first killed line.
Do more M-y's and see what you get. Keep doing them until
the second kill line comes back, and then a few more.
If you like, you can try giving M-y positive and negative
arguments.
* UNDO
------
If you make a change to the text, and then decide that it was a mistake,
you can undo the change with the undo command, C-/. (On TTY's, use C-_,
i.e. CONTROL + underscore, which is normally above the minus sign;
i.e. you will have to hold the SHIFT key down, as in CONTROL + SHIFT +
minus. If that doesn't work, you can fall back to C-x u; but that has
the unfortunate property that it's difficult to execute several times in
a row.)
Normally, C-/ undoes the changes made by one command; if you repeat
the C-/ several times in a row, each repetition undoes one
additional command.
But there are two exceptions: commands that do not change the text do
not count (this includes cursor motion commands and scrolling
command), and self-inserting characters are usually handled in groups
of up to 20. (This is to reduce the number of C-/'s you have to
type to undo insertion of text.)
>> Kill this line with C-k, then type C-/ and it should reappear.
A numeric argument to C-/ acts as a repeat count.
If you change your mind and want to redo changes that you've undone,
issue any command other than Undo (usually people move the cursor), and
then start undoing again. This will undo your Undo changes; keep
hitting Undo, and you will eventually undo all the Undo's, and start
undoing your original changes. Essentially, XEmacs treats each Undo as
a further change, and records them for undoing just like regular
commands; but as long as you keeping issuing Undo commands directly
after previous ones, XEmacs remembers where you are in the Undo history
so it can keep undoing. Once you issue another command, XEmacs
"forgets" and resets its internal pointer to the end of the Undo
history. This may seem confusing, so try it out:
>> Type a line of text above this one.
>> Move to the end of the line you just typed, and hit <Backspace>
until you've deleted all characters.
>> Type C-/ a number of times to undo some of your deletions.
>> Move the cursor left.
>> Start typing C-/ again, and it will redo your deletions until there's
no text left, then it will start undoing the original deletions.
When all the text appears again, further C-/'s will undo the text you
originally typed, in groups of up to 20 (see above).
As you just saw, you can undo deletion of text just as you can undo
killing of text. The distinction between killing something and deleting
it affects whether you can yank it with C-y; it makes no difference for
undo.
* USING THE MOUSE
-----------------
On window systems, XEmacs is fully integrated with the mouse. You can
position the text cursor by clicking the left button at the desired
location, and you can select text by dragging the left mouse button
across the text you want to select. (Or alternatively, click the left
mouse button at one end of the text, then move to the other end and use
Shift-click to select the text.)
The middle mouse button is commonly used to choose items that are
visible on the screen. For example, if you enter Info (the on-line
XEmacs documentation) using C-h i or the Help menu, you can follow a
highlighted link by clicking the middle mouse button on it. Similarly,
if you are typing a file name in (e.g. when prompted by "Find File") and
you hit <Tab> to show the possible completions, you can click the middle
mouse button on one of the completions to select it. If you have a
two-button mouse, such as some MS Windows systems, you can click both
buttons simultaneously to simulate the middle button.
The right mouse button brings up a popup menu, called a "context menu"
because the contents vary depending on what context you're in, such as
the mode of the window you click in or the text under the mouse. The
menu usually contains the commands most relevant to where you clicked,
so they're easier to access.
>> Press the right mouse button now.
Under X Windows, you may have to hold the button down in order to keep
the menu up.
* FILES
-------
In order to make the text you edit permanent, you must put it in a
file. Otherwise, it will go away when your invocation of XEmacs goes
away. In order to put your text in a file, you must "find" the file
before you enter the text. (This is also called "visiting" the file.)
Finding a file means that you see the contents of the file within
XEmacs. In many ways, it is as if you were editing the file itself.
However, the changes you make using XEmacs do not become permanent
until you "save" the file. This is so you can avoid leaving a
half-changed file on the system when you do not want to. Even when
you save, XEmacs leaves the original file under a changed name in case
you later decide that your changes were a mistake.
If you look near the bottom of the frame you will see a line that begins
and ends with dashes, and contains the string "XEmacs: TUTORIAL" or
something like that. This part of the frame normally shows the name of
the file that you are visiting. Right now, you are visiting a file called
"TUTORIAL" which is your personal scratch copy of the XEmacs tutorial.
When you find a file with XEmacs, that file's name will appear in that
precise spot.
One special thing about the command for finding a file is that you
have to say what file name you want. We say the command "reads an
argument from the terminal" (in this case, the argument is the name of
the file). After you type the command
C-x C-f Find a file
XEmacs asks you to type the file name. The file name you type appears
on the bottom line of the frame. The bottom line is called the
minibuffer when it is used for this sort of input. You can use
ordinary XEmacs editing commands to edit the file name.
While you are entering the file name (or any minibuffer input),
you can cancel the command with C-g.
>> Type C-x C-f, then type C-g. This cancels the minibuffer,
and also cancels the C-x C-f command that was using the
minibuffer. So you do not find any file.
When you have finished entering the file name, type <Return> to
terminate it. Then C-x C-f command goes to work, and finds the file
you chose. The minibuffer disappears when the C-x C-f command is
finished.
In a little while the file contents appear on the screen, and you can
edit the contents. When you wish to make your changes permanent,
type the command
C-x C-s Save the file
This copies the text within XEmacs into the file. The first time you
do this, XEmacs renames the original file to a new name so that it is
not lost. The new name is made by adding "~" to the end of the
original file's name.
When saving is finished, XEmacs displays the name of the file written.
You should save fairly often, so that you will not lose very much
work if the system should crash.
>> Type C-x C-s, saving your copy of the tutorial.
This should show "Wrote ...TUTORIAL" at the bottom of the frame.
NOTE: On some older TTY connections, typing C-s will freeze the screen
and you will see no further output from XEmacs. This indicates that an
operating system "feature" called "flow control" is intercepting the C-s
and not letting it get through to XEmacs. To unfreeze the screen, type
C-q. Then see the section "Spontaneous Entry to Incremental Search" in
the XEmacs manual for advice on dealing with this "feature".
You can find an existing file, to view it or edit it. You can also
find a file which does not already exist. This is the way to create a
file with XEmacs: find the file, which will start out empty, and then
begin inserting the text for the file. When you ask to "save" the
file, XEmacs will really create the file with the text that you have
inserted. From then on, you can consider yourself to be editing an
already existing file.
* BUFFERS
---------
If you find a second file with C-x C-f, the first file remains
inside XEmacs. You can switch back to it by finding it again with
C-x C-f. This way you can get quite a number of files inside XEmacs.
>> Create a file named "foo" by typing C-x C-f foo <Return>.
Then insert some text, edit it, and save "foo" by typing C-x C-s.
Finally, type C-x C-f TUTORIAL <Return>
to come back to the tutorial.
XEmacs stores each file's text inside an object called a "buffer".
Finding a file makes a new buffer inside XEmacs. To see a list of the
buffers that currently exist in your XEmacs job, type
C-x C-b List buffers
>> Try C-x C-b now.
See how each buffer has a name, and it may also have a file name
for the file whose contents it holds. Some buffers do not correspond
to files. For example, the buffer named "*Buffer List*" does
not have any file. It is the buffer which contains the buffer
list that was made by C-x C-b. ANY text you see in an XEmacs window
is always part of some buffer.
>> Type ESC ESC to get rid of the buffer list. (Remember, three ESC's
under TTY's.)
If you make changes to the text of one file, then find another file,
this does not save the first file. Its changes remain inside XEmacs,
in that file's buffer. The creation or editing of the second file's
buffer has no effect on the first file's buffer. This is very useful,
but it also means that you need a convenient way to save the first
file's buffer. It would be a nuisance to have to switch back to
it with C-x C-f in order to save it with C-x C-s. So we have
C-x s Save some buffers
C-x s asks you about each buffer which contains changes that you have
not saved. It asks you, for each such buffer, whether to save the
buffer.
>> Insert a line of text, then type C-x s.
It should ask you whether to save the buffer named TUTORIAL.
Answer yes to the question by typing "y".
* EXTENDING THE COMMAND SET
---------------------------
There are many, many more XEmacs commands than could possibly be put
on all the control and meta characters. XEmacs gets around this with
the X (eXtend) command. This comes in two flavors:
C-x Character eXtend. Followed by one character.
M-x Named command eXtend. Followed by a long name.
These are commands that are generally useful but used less than the
commands you have already learned about. You have already seen two of
them: the file commands C-x C-f to Find and C-x C-s to Save. Another
example is the command to end the XEmacs session--this is the command
C-x C-c. (Do not worry about losing changes you have made; C-x C-c
offers to save each changed file before it kills the XEmacs.)
If you have installed the sample init.el file, you will find that C-x
C-c does not exit XEmacs, but instead outputs a message. This is
intentional, since C-x C-c is easy to hit accidentally. Instead, use
the "File/Exit XEmacs" menu item to exit.
If you are on a TTY, and you want to exit temporarily to execute a shell
command, you should use C-z instead of C-x C-c. Under TTY's, C-z
"suspends" XEmacs; that is, it returns to the shell but does not destroy
the XEmacs. In the most common shells, you can resume XEmacs with the
`fg' command or with `%xemacs'. (On systems which do not implement
suspending, C-z creates a subshell running under XEmacs to give you the
chance to run other programs and return to XEmacs afterward; it does not
truly "exit" from XEmacs. In this case, the shell command `exit' is the
usual way to get back to XEmacs from the subshell.)
There are many C-x commands. Here is a list of the ones you have learned:
C-x C-f Find file.
C-x C-s Save file.
C-x C-b List buffers.
C-x C-c Quit XEmacs.
C-x 0 Delete the current window.
C-x u Undo (TTY version).
Named eXtended commands are commands which are used even less
frequently, or commands which are used only in certain modes. An
example is the command replace-string, which globally replaces one
string with another. When you type M-x, XEmacs prompts you at the
bottom of the frame with M-x and you should type the name of the
command; in this case, "replace-string". Just type "repl s<Tab>" and
XEmacs will complete the name. (<Tab> is the Tab key, usually found
above the CapsLock or Shift key near the left edge of the keyboard.)
End the command name with <Return>.
The replace-string command requires two arguments--the string to be
replaced, and the string to replace it with. You must end each
argument with <Return>.
>> Move the cursor to the blank line two lines below this one.
Then type M-x repl s<Return>changed<Return>altered<Return>.
Notice how this line has changed: you've replaced
the word c-h-a-n-g-e-d with "altered" wherever it occurred,
after the initial position of the cursor.
* AUTO SAVE
-----------
When you have made changes in a file, but you have not saved them yet,
they could be lost if your computer crashes. To protect you from this,
XEmacs periodically writes an "auto save" file for each file that you
are editing. The auto save file name has a # at the beginning and the
end; for example, if your file is named "hello.c", its auto save file's
name is usually "#hello.c#". When you save the file in the normal way,
XEmacs deletes its auto save file.
If the computer crashes, you can recover your auto-saved editing by
finding the file normally (the file you were editing, not the auto
save file) and then typing M-x recover file<Return>. When it asks for
confirmation, type yes<Return> to go ahead and recover the auto-save
data.
* ECHO AREA
-----------
If XEmacs sees that you are typing multicharacter commands slowly, it
shows them to you at the bottom of the frame in an area called the
"echo area". The echo area contains the bottom line of the frame.
* MODELINE
----------
The line immediately above the echo area it is called the "modeline".
The mode line says something like this:
--**-XEmacs: TUTORIAL (Fundamental)--L670--58%----------------
This line gives useful information about the status of XEmacs and
the text you are editing.
You already know what the filename means--it is the file you have
found. -NN%-- indicates your current position in the text; it means
that NN percent of the text is above the top of the window. If the
top of the file is on the screen, it will say --Top-- instead of
--00%--. If the bottom of the text is on the screen, it will say
--Bot--. If you are looking at text so small that all of it fits on
the screen, the mode line says --All--.
The L and digits indicate position in another way: they give the
current line number of point.
The stars near the front mean that you have made changes to the text.
Right after you visit or save a file, that part of the mode line shows
no stars, just dashes.
The part of the mode line inside the parentheses is to tell you what
editing modes you are in. The default mode is Fundamental which is
what you are using now. It is an example of a "major mode".
XEmacs has many different major modes. Some of them are meant for
editing different languages and/or kinds of text, such as Lisp mode,
Text mode, etc. At any time one and only one major mode is active,
and its name can always be found in the mode line just where
"Fundamental" is now.
Each major mode makes a few commands behave differently. For example,
there are commands for creating comments in a program, and since each
programming language has a different idea of what a comment should
look like, each major mode has to insert comments differently. Each
major mode is the name of an extended command, which is how you can
switch to that mode. For example, M-x fundamental-mode is a command to
switch to Fundamental mode.
If you are going to be editing English text, such as this file, you
should probably use Text Mode.
>> Type M-x text-mode<Return>.
Don't worry, none of the XEmacs commands you have learned changes in
any great way. But you can observe that C-<Right> and C-<Left> now treat
apostrophes as part of words. Previously, in Fundamental mode,
C-<Right> and C-<Left> treated apostrophes as word-separators.
Major modes usually make subtle changes like that one: most commands
do "the same job" in each major mode, but they work a little bit
differently.
To view documentation on your current major mode, type C-h m.
>> Use M-4 C-l to bring this line near the top of the window.
>> Type C-h m, to see how Text mode differs from Fundamental mode.
>> Type q to remove the documentation from the screen.
Major modes are called major because there are also minor modes.
Minor modes are not alternatives to the major modes, just minor
modifications of them. Each minor mode can be turned on or off by
itself, independent of all other minor modes, and independent of your
major mode. So you can use no minor modes, or one minor mode, or any
combination of several minor modes.
One minor mode which is very useful, especially for editing English
text, is Auto Fill mode. When this mode is on, XEmacs breaks the line
in between words automatically whenever you insert text and make a
line that is too wide.
You can turn Auto Fill mode on by doing M-x auto-fill-mode<Return>.
When the mode is on, you can turn it off again by doing M-x
auto-fill-mode<Return>. If the mode is off, this command turns it on,
and if the mode is on, this command turns it off. We say that the
command "toggles the mode".
>> Type M-x auto-fill-mode<Return> now. Then insert a line of "asdf "
over again until you see it divide into two lines. You must put in
spaces between them because Auto Fill breaks lines only at spaces.
The margin is usually set at 70 characters, but you can change it
with the C-x f command. You should give the margin setting you want
as a numeric argument.
>> Type C-x f with an argument of 20. (M-20 C-x f).
Then type in some text and see XEmacs fill lines of 20
characters with it. Then set the margin back to 70 using
C-x f again.
If you make changes in the middle of a paragraph, Auto Fill mode
does not re-fill it for you.
To re-fill the paragraph, type M-q (META-q) with the cursor inside
that paragraph.
>> Move the cursor into the previous paragraph and type M-q.
* SEARCHING
-----------
XEmacs can do searches for strings (these are groups of contiguous
characters or words) either forward through the text or backward
through it. Searching for a string is a cursor motion command;
it moves the cursor to the next place where that string appears.
The XEmacs search command is different from the search commands
of most editors, in that it is "incremental". This means that the
search happens while you type in the string to search for.
The command to initiate a search is C-s for forward search, and C-r
for reverse search. BUT WAIT! Don't try them now.
When you type C-s you'll notice that the string "I-search" appears as
a prompt in the echo area. This tells you that XEmacs is in what is
called an incremental search waiting for you to type the thing that
you want to search for. <Return> terminates a search.
>> Now type C-s to start a search. SLOWLY, one letter at a time,
type the word 'cursor', pausing after you type each
character to notice what happens to the cursor.
Now you have searched for "cursor", once.
>> Type C-s again, to search for the next occurrence of "cursor".
>> Now type <Backspace> four times and see how the cursor moves.
>> Type <Return> to terminate the search.
Did you see what happened? XEmacs, in an incremental search, tries to
go to the occurrence of the string that you've typed out so far,
highlighting it for your convenience. To go to the next occurrence of
'cursor' just type C-s again. If no such occurrence exists XEmacs
beeps and tells you the search is currently "failing", C-g would also
terminate the search.
NOTE: On some older TTY connections, typing C-s will freeze the screen
and you will see no further output from XEmacs. This indicates that an
operating system "feature" called "flow control" is intercepting the C-s
and not letting it get through to XEmacs. To unfreeze the screen, type
C-q. Then see the section "Spontaneous Entry to Incremental Search" in
the XEmacs manual for advice on dealing with this "feature".
If you are in the middle of an incremental search and type <Backspace>,
you'll notice that the last character in the search string is erased
and the search backs up to the last place of the search. For
instance, suppose you have typed "c", to search for the first
occurrence of "c". Now if you type "u", the cursor will move
to the first occurrence of "cu". Now type <Backspace>. This erases
the "u" from the search string, and the cursor moves back to
the first occurrence of "c".
If you are in the middle of a search and type a control or meta
character (with a few exceptions--characters that are special in
a search, such as C-s and C-r), the search is terminated.
The C-s starts a search that looks for any occurrence of the search
string AFTER the current cursor position. If you want to search for
something earlier in the text, type C-r instead. Everything that we
have said about C-s also applies to C-r, except that the direction of
the search is reversed.
* MULTIPLE "WINDOWS" (I.E. PANES)
---------------------------------
One of the nice features of XEmacs is that you can split the current
frame (i.e. window-system window) into more than one pane, or "window"
in XEmacs parlance.
>> Move the cursor to this line and type M-0 C-l (that's zero, not Oh,
and CONTROL-L, not CONTROL-1).
>> Now type C-x 2 which splits the frame into two windows.
Both windows display this tutorial. The cursor stays in the top window.
>> Type M-<Next> to scroll the bottom window.
(C-M-v on TTY's. If you do not have a real META key, type ESC C-v.)
>> Type C-<Tab> to move the cursor to the bottom window. (Use C-x o -- "o"
for "other" -- on TTY's.)
>> Use <Next> and <Prior> in the bottom window to scroll it.
Keep reading these directions in the top window.
>> Type C-<Tab> again to move the cursor back to the top window.
The cursor in the top window is just where it was before.
You can keep using C-<Tab> to switch between the windows. Each
window has its own cursor position, but only one window actually
shows the cursor. All the ordinary editing commands apply to the
window that the cursor is in. We call this the "selected window".
If you have more than two windows, C-<Tab> cycles between them, and
C-Sh-<Tab> (i.e. CONTROL-SHIFT-TAB) in the opposite direction. (There is
no TTY equivalent for C-Sh-<Tab>.)
The commands M-<Prior> and M-<Next> are very useful when you are editing
text in one window and using the other window just for reference. You
can keep the cursor always in the window where you are editing, and
scroll forward or back through the other window with these commands.
On TTY's, use C-M-v in place of M-<Next>, and there's no equivalent of
M-<Prior>. C-M-v is an example of a CONTROL-META character. If you
have a real META key, you can type C-M-v by holding down both CONTROL
and META while typing v. It does not matter whether CONTROL or META
"comes first," because both of these keys act by modifying the
characters you type. If you do not have a real META key, and you use
ESC instead, the order does matter: you must type ESC followed by
CONTROL-v, because CONTROL-ESC v will not work. This is because ESC is
a character in its own right, not a modifier key.
>> Type C-x 1 (in the top window) to get rid of the bottom window.
(If you had typed C-x 1 in the bottom window, that would get rid
of the top one. Think of this command as "Keep just one
window--the window I am already in.")
You do not have to display the same buffer in both windows. If you
use C-x C-f to find a file in one window, the other window does not
change. You can find a file in each window independently.
Here is another way to use two windows to display two different
things:
>> Type C-x 4 f followed by the name of one of your files.
End with <Return>. See the specified file appear in the bottom
window. The cursor goes there, too.
>> Type C-<Tab> to go back to the top window, and C-x 1 to delete
the bottom window.
* MULTIPLE "FRAMES" (I.E. WINDOW-SYSTEM WINDOWS)
------------------------------------------------
On window systems, you can also create multiple "frames", or
window-system windows. These exist independently of each other at the
top level, just like separate programs. (There is no support for the MS
Windows feature called MDI, or Multiple Document Interface, where
multiple overlapping child windows exist inside of a single top-level
window.)
The commands for frames are similar to those for windows, but begin with
"C-x 5".
>> Type C-x 5 2 to create a new frame.
>> Move the mouse into it, and click. (On X Windows, you may not need
to click; this depends on the window manager.)
>> Scroll up or down. Note that, just like for XEmacs windows, two frames
can be showing the same buffer but in different positions.
>> Type C-x 2. Note that each frame can have separate windows,
independently of other frames.
>> Type C-x 5 o (or Alt-Tab under MS Windows) to go back to the first frame.
>> Type C-x 5 0 to kill the old frame.
>> Note that we're still here! XEmacs will not exit until all frames
are deleted, no matter what order they were created in.
>> Type C-x 1 to get back to one window.
You can also use C-x 5 f to open a file in a new frame, just like C-x 4
f opens a file in a new window in the same frame.
* RECURSIVE EDITING LEVELS
--------------------------
Sometimes you will get into what is called a "recursive editing
level". This is indicated by square brackets in the mode line,
surrounding the parentheses around the major mode name. For
example, you might see [(Fundamental)] instead of (Fundamental).
To get out of the recursive editing level, use the all-purpose escape
mechanism mentioned earlier: ESC ESC. (Remember, it's ESC ESC ESC on
TTY's.) You can also use it for eliminating extra windows, canceling a
selection, and getting out of the minibuffer.
>> Type M-x to get into a minibuffer; then type ESC ESC to get out.
You cannot use C-g to get out of a recursive editing level. This is
because C-g is used for canceling commands and arguments WITHIN the
recursive editing level.
* GETTING MORE HELP
-------------------
In this tutorial we have tried to supply just enough information to
get you started using XEmacs. There is so much available in XEmacs that
it would be impossible to explain it all here. However, you may want
to learn more about XEmacs since it has many other useful features.
XEmacs provides commands for reading documentation about XEmacs
commands. These "help" commands all start with the character
CONTROL-h, which is called "the Help character".
To use the Help features, type the C-h character, and then a
character saying what kind of help you want. If you are REALLY lost,
type C-h ? ? and XEmacs will tell you what kinds of help it can give.
If you have typed C-h and decide you do not want any help, just
type C-g to cancel it.
(Note for TTY users: Some sites change the meaning of the character C-h.
They really should not do this as a blanket measure for all users, so you
have grounds to complain to the system administrator. Meanwhile, if C-h
does not display a message about help at the bottom of the screen, try
typing the F1 key or M-? instead.)
The most basic HELP feature is C-h c. Type C-h, the character c, and
a command character or sequence; then XEmacs displays a very brief
description of the command.
>> Type C-h c <Up>.
The message should be something like
up runs the command previous-line
This tells you the "name of the function". Function names are used
mainly for customizing and extending XEmacs. But since function names
are chosen to indicate what the command does, they can serve also as
very brief documentation--sufficient to remind you of commands you
have already learned.
Multi-character commands such as C-x C-s and <ESC>v are also allowed
after C-h c.
To get more information about a command, use C-h k instead of C-h c.
>> Type C-h k <Up>.
This displays the documentation of the function, as well as its
name, in an XEmacs window. When you are finished reading the
output, type q to get rid of the help text.
Here are some other useful C-h options:
C-h f Describe a function. You type in the name of the
function.
>> Try typing C-h f previous-line<Return>.
This displays all the information XEmacs has about the
function which implements the <Up> command.
A similar command C-h v displays the documentation of variables whose
values you can set to customize XEmacs behavior. You need to type in
the name of the variable when XEmacs prompts for it.
C-h a Hyper Apropos. Type in a keyword and XEmacs will list
all the functions and variables whose names contain
that keyword. For commands that can be invoked with
META-x, an asterisk will be displayed to the left.
>> Type C-h a newline<Return>.
This displays a list of all functions and variables with "newline" in
their names. Press <Return> or click the middle mouse button to find
out more about a function or variable. Type `q' to exit hyper-apropos.
C-h i Read On-line Manuals (a.k.a. Info). This command puts
you into a special buffer called `*info*' where you
can read on-line manuals for the packages installed on
your system. Type m xemacs <Return> to read the XEmacs
manual. If you have never before used Info, type ?
and XEmacs will take you on a guided tour of Info mode
facilities. Once you are through with this tutorial,
you should consult the XEmacs Info manual as your
primary documentation.
* CONCLUSION
------------
Remember, to exit XEmacs permanently use the menu item "File/Exit XEmacs",
or type C-x C-c. On TTY's, to temporarily exit to a shell, so that you
can come back in, use C-z.
This tutorial is meant to be understandable to all new users, so if
you found something unclear, don't sit and blame yourself - complain!
COPYRIGHTS, COPYING, ORIGINS
----------------------------
Copyright (c) 1985, 1996 Free Software Foundation.
Copyright (c) 2001 Ben Wing.
This tutorial is synched with FSF 21.0.106.
This tutorial descends from a long line of Emacs tutorials starting with
the one written by Stuart Cracraft for the original Emacs. Ben Wing
updated the tutorial for X Windows. Martin Buchholz and Hrvoje Niksic
added more corrections for XEmacs. Ben Wing later synched up to FSF
21.0.105 and rehashed many sections to match the current XEmacs norms.
This version of the tutorial, like XEmacs, is copyrighted, and
comes with permission to distribute copies on certain conditions:
Permission is granted to anyone to make or distribute verbatim copies
of this document as received, in any medium, provided that the
copyright notice and permission notice are preserved,
and that the distributor grants the recipient permission
for further redistribution as permitted by this notice.
Permission is granted to distribute modified versions
of this document, or of portions of it,
under the above conditions, provided also that they
carry prominent notices stating who last altered them.
The conditions for copying XEmacs itself are more complex, but in the
same spirit. Please read the file COPYING and then do give copies of
XEmacs to your friends. Help stamp out software obstructionism
("ownership") by using, writing, and sharing free software!
Copyright (c) 1985,96,97 Free Software Foundation, Inc; See end for conditions.
Emacs. Prvo berilo.
Ukazi v Emacsu v splo¹nem vkljuèujejo tipki CONTROL (vèasih oznaèeni
CTRL ali CTL) in META (vèasih oznaèena EDIT ali ALT). Namesto, da bi ju
vedno izpisali s celim imenom, bomo uporabili naslednji okraj¹avi:
C-<chr> pomeni, da moramo dr¾ati pritisnjeno tipko CONTROL, ko
vtipkamo znak <chr>. Oznaka C-f tako pomeni: dr¾imo
pritisnjeno tipko CONTROL in pritisnemo tipko f.
M-<chr> pomeni, da moramo dr¾ati pritisnjeno tipko META, EDIT ali ALT,
ko vtipkamo znak <chr>. Èe na tipkovnici ni tipk META, EDIT
ali ALT, pritisnemo tipko ESC, jo spustimo in zatem
pritisnemo tipko <chr>. Tipko ESC bomo oznaèevali z <ESC>.
Pomembno: Emacs zapustimo z ukazom C-x C-c (dva znaka).
V uèbeniku so vaje, s katerimi preskusite nove ukaze. Oznaèujeta jih
znaka ,>>` ob levem robu. Primer:
<<help-with-tutorial napolni preostanek s praznimi vrsticami>>
>> Vtipkajte zdaj ukaz C-v (View next screen, Prika¾i naslednji zaslon),
da se premaknete na naslednji zaslon (kar poskusite, pritisnite
hkrati kontrolno tipko in V). Od zdaj naprej boste morali to
napraviti sami vsakiè, ko pridete do konca zaslona.
Ste opazili, da sta se dve vrstici s prej¹njega zaslona ponovili? Ta
kontinuiteta olaj¹a branje pri skakanju s strani na stran.
Prva stvar, ki si jo morate zapomniti, je, kako se premikate po
datoteki. Zdaj ¾e veste, da se premaknete za cel zaslon naprej z
ukazom C-v. Za cel zaslon nazaj pa se premaknete z ukazom M-v
(pritisnite tipko META in jo dr¾ite ter pritisnite tipko v, ali pa
pritisnite in spustite <ESC> ter zatem pritisnite tipko v, èe tipke
META, EDIT ali ALT na va¹i tipkovnici ni).
>> Nekajkrat pritisnite M-v in C-v, da vidite, kako ukaza delujeta.
* POVZETEK
----------
Za pregled celega zaslona besedila so uporabni naslednji ukazi:
C-v Premik se za cel zaslon naprej
M-v Premik se za cel zaslon nazaj
C-l Cel zaslon premaknemo tako, da je zdaj po vertikali
centriran okoli besedila, kjer se nahaja kazalèek (znak v
C-l je èrka L, ne ¹tevka 1)
>> Poi¹èite kazalèek na zaslonu in si zapomnite besedilo okoli njega.
Vtipkajte C-l.
Ponovno poi¹èite kazalèek. Besedilo okoli njega je ostalo isto.
* PREMIKANJE KAZALÈKA
---------------------
Premiki za celo stran naprej in nazaj so sicer uporabni, ampak kako pa
pridemo do izbranega mesta na zaslonu?
Naèinov je veè. Najosnovnej¹i je uporaba ukazov C-p, C-b, C-f in
C-n. Ti po vrsti premaknejo kazalèek v prej¹njo vrstico, znak nazaj,
znak naprej, in v naslednjo vrstico. Grafièno prikazano:
prej¹nja vrstica, C-p
:
:
nazaj, C-b .... trenutni polo¾aj kazalèka .... naprej, C-f
:
:
naslednja vrstica, C-n
>> S pritiski na C-n ali C-p premaknite kazalèek v sredinsko vrstico
na diagramu zgoraj. Zatem pritisnite C-l. S tem diagram postavite na
sredino zaslona.
V angle¹èini ima izbor tipk nazoren pomen. P kot ,previous` (prej¹nji),
N kot ,next` (naslednji), B kot ,backward` (nazaj) in F kot ,forward`
(naprej). To so osnovni ukazi za premikanje kazalèka in uporabljali jih
boste VES ÈAS. Èim prej se jih nauèite, tem bolje.
>> Nekajkrat pritisnite C-n, da pride kazalèek do te vrstice.
>> Z nekaj C-f se pomaknite na desno na sredo vrstice, nato pa nekajkrat
pritisnite C-p. Opazujte, kaj se dogaja s kazalèkom na sredini
vrstice.
Vsaka vrstice v besedilu je zakljuèena z znakom za novo vrstico
(angl. Newline). Ta loèuje vrstico v besedilu od naslednje. Tudi
zadnja vrstica v datoteki mora biti zaljuèena z znakom za novo vrstico
(èeprav tega Emacs ne zahteva).
>> Poskusite ukaz C-b, ko je kazalèek na zaèetku vrstice. Kazalèek se
mora premakniti na konec prej¹nje vrstice. To je zato, ker se je
ravnokar premaknil prek znaka za konec vrstice.
Ukaz C-f premika kazalèek prek znaka za novo vrstico enako kot C-b.
>> Poskusite ¹e nekajkrat pritisniti C-b, da dobite obèutek za
premikanje kazalèka. Potem nekajkrat poskusite C-f, da pridete do konca
vrstice. ©e enkrat pritisnite C-f, da skoèite v naslednjo vrstico.
Ko s kazalèkom dose¾ete zgornji ali spodnji rob zaslona, se besedilo
toliko premakne, da kazalèek ostane na zaslonu. V angle¹èini se temu
pravi ,,scrolling``. To omogoèa, da lahko premaknemo kazalèek na
katerokoli mesto v besedilu, a vseeno ostanemo na zaslonu.
>> Poskusite kazalèek pripeljati s C-n èisto do dna zaslona in si oglejte,
kaj se zgodi.
Èe se vam zdi premikanje po en znak prepoèasno, se lahko premikate za
celo besedo. M-f (Meta-f) premakne kazalèek za eno besedo naprej, M-b
pa za besedo nazaj.
>> Poskusite nekajkrat M-f in M-b.
Èe je kazalèek sredi besede, ga M-f prestavi na konec besede. Èe je v
belini med besedami, ga M-f premakne na konec naslednje besede. M-b
deluje podobno, a v nasprotni smeri.
>> Nekajkrat poskusite M-f in M-b, vmes pa ¹e nekaj C-f in
C-b. Opazujte uèinke M-f in M-b, ko je kazalèek sredi besede ali
med besedami.
Ste opazili paralelo med C-f in C-b na eni strani ter M-f in M-b na
drugi? V Emacsu se dostikrat ukazi Meta nana¹ajo na operacije nad
enotami jezika (besede, stavki, odstavki), medtem ko se ukazi Control
nana¹ajo na operacije, neodvisne od zvrsti besedila (znaki, vrstice
ipd.).
Podobna zveza je tudi med vrsticami in stavki: ukaza C-a in C-e
premakneta kazalèek na zaèetek oz. konec vrstice, M-a in M-e pa na
zaèetek oz. konec stavka.
>> Poskusite nekaj ukazov C-a, potem pa nekaj ukazov C-e.
Poskusite nekaj ukazov M-a, potem pa nekaj ukazov M-e.
Ste opazili, da ponovljeni C-a ne napravijo niè, ponovljeni M-a pa se
premikajo naprej? Èeprav se ne obna¹ata enako, pa je vendar obna¹anje
enega in drugega po svoje naravno.
Polo¾aju kazalèka na zaslonu pravimo tudi ,,point``, toèka.
Parafrazirano: kazalèek ka¾e na zaslonu, kje je toèka v besedilu.
Povzetek preprostih ukazov za premikanje kazalèka, vkljuèno s premiki
po besedo in stavek:
C-f Premik za znak naprej
C-b Premik za znak nazaj
M-f Premik za besedo naprej
M-b Premik za besedo nazaj
C-n Premik v naslednjo vrstico
C-p Premik v prej¹njo vrstico
C-a Premik na zaèetek vrstice
C-e Premik na konec vrstice
M-a Premik na zaèetek stavka
M-e Premik na konec stavka
>> Za vajo nekajkrat poskusite vsakega od teh ukazov.
To so najpogosteje uporabljani ukazi.
©e dva pomembna ukaza za premikanje kazalèka sta M-< (Meta-manj¹i od),
ki ga premakne na zaèetek datoteke, in M-> (Meta-veèji od), ki ga
premakne na konec datoteke.
Na ameri¹kih tipkovnicah najdete znak < nad vejico in morate
pritisniti tipko Shift, da pridete do njega. Z ukazom M-< je enako -
prav tako morate pritisniti tipko Shift, sicer moste izvedli drug
ukaz, Meta-vejica. Na na¹ih tipkovnicah sta oba znaka na isti tipko,
in za ukaz M-> morate pritisniti ¹e tipko Shift.
>> Poskusite zdaj M-<, skok na zaèetek tega uèbenika.
Potem se vrnite nazaj z zaporednimi C-v.
>> Poskusite zdaj M->, skok na konec tega uèbenika.
Potem se vrnite nazaj z zaporednimi M-v.
Èe ima va¹a tipkovnica kurzorske tipke, lahko premikate kazalèek po
zaslonu tudi z njimi. Vseeno priporoèamo, da se privadite ukazov C-b,
C-f, C-n in C-p, in to iz treh razlogov. Prviè, delujejo na èisto vseh
terminalih. Drugiè, z nekaj prakse v Emacsu boste opazili, da je
tipkanje ukazov s Control hitrej¹e od tipkanja s kurzorskimi tipkami, ker
ni treba ves èas premikati desnice s tipkovnice na kurzorske tipke in
nazaj. In tretjiè, ko se enkrat navadite teh ukazov s Control, se boste
enostavneje nauèili tudi bolj zapletenih ukazov za premikanje kazalèka.
Veèini ukazov v Emacsu lahko podamo ¹tevilèni argument; najveèkrat ta
pove, kolikokrat zapovrstjo naj se ukaz izvede. Veèkratno ponovitev
ukaza izvedemo tako, da najprej vtipkamo C-u, zatem ¹tevilo,
kolikokrat naj se ukaz ponovi, in nazadnje ¾eljeni ukaz. Èe ima va¹a
tipkovnica tipko META (ali EDIT ali ALT), lahko izpustite ukaz C-u in
namesto tega vtipkate ¹tevilo ponovitev, medtem ko dr¾ite pritisnjeno
tipko META. Druga metoda je sicer kraj¹a, priporoèamo pa prvo, ker
deluje na vseh terminalih. Tak¹en ¹tevilèni argument je ,,prefiksni``
argument, ker vnesemo argument pred ukazom, na katerega se nana¹a.
Primer: C-u 8 C-f premakne kazalèek za osem znakov naprej.
>> Poskusite s primernim argumentom za ¹tevilo ponovitev ukaza
C-n ali C-p priti èim bli¾e tej vrstici v enem samem skoku.
Veèina ukazov, ne pa vsi, uporablja ¹tevilèni argument kot ¹tevilo
ponovitev ukaza. Nekateri ukazi (nobeden od tistih, ki smo si jih
ogledali do zdaj) ga uporabljajo kot stikalo: s podanim prefiksnim
argumentom napravi ukaz nekaj drugega kot obièajno.
Ukaza C-v in M-v sta tudi izjemi, a drugaèni. Èe jima podamo argument,
premakneta zaslon za navedeno ¹tevilo vrstic, ne pa zaslonov. Ukaz C-u
4 C-v, na primer, premakne zaslon navzgor za 4 vrstice.
>> Poskusite zdaj C-u 8 C-v
To bi moralo zaslon premakniti navzgor za osem vrstic. Èe bi ga radi
premaknili nazaj, poskusite M-v z istim argumentom.
Èe uporabljate X Windows, imate verjetno ob levem robu Emacsovega
okna navpièno pravokotno ploskev, imenovano drsnik. Pogled na
besedilo lahko premikate tudi tako, da z mi¹ko kliknete na drsnik.
>> Postavite kazalec na vrh oznaèenega obmoèja na drsniku in pritisnite
srednji gumb na mi¹ki. To bi moralo premakniti besedilo na mesto,
doloèeno s tem, kako visoko ali nizko na drsnik ste kliknili.
>> Medtem ko dr¾ite srednji gumb pritisnjen, premikajte mi¹ko gor in
dol. Vidite, kako se premika besedilo v Emacsovem oknu, ko
premikate mi¹ko?
* ÈE SE EMACS OBESI
-------------------
Èe se Emacs preneha odzivati na va¹e ukaze, ga lahko varno prekinete z
ukazom C-g. Z njim lahko prekinete ukaze, za katere bi trajalo
predolgo, da bi se izvedli.
Isti ukaz, C-g, lahko uporabite tudi, da preklièete ¹tevilèni
argument, ali pa zaèetek ukaza, ki ga ne ¾elite izvesti.
>> Vtipkajte C-u 100, s èimer ste izbrali ¹tevilèni argument 100,
zatem pa vtipkajte C-g. Vtipkajte zdaj C-f. Kazalèek se je
premaknil le za en znak, ker ste ¹tevilèni argument vmes preklicali
s C-g.
Tudi èe ste po nesreèi vtipkali <ESC>, se ga lahko znebite s C-g.
* ONEMOGOÈENI UKAZI
-------------------
Nekaj ukazov v Emacsu je namenoma ,,onemogoèenih``, da bi jih
zaèetniki ne izvedli po nesreèi.
Èe vtipkate tak onemogoèen ukaz, se bo na zaslonu pojavilo novo okno z
obvestilom, kateri ukaz ste sku¹ali izvesti, in vas vpra¹alo, èe ga
res ¾elite izvesti.
Èe v resnici ¾elite poskusiti ukaz, pritisnite preslednico kot odgovor
na vpra¹anje. Normalno verjetno ukaza ne ¾elite izvesti, zato na
vpra¹anje odgovorite z ,n`.
>> Vtipkajte <ESC> : (ki je onemogoèen ukaz), zatem odgovorite n.
* OKNA
------
Emacs lahko prika¾e veè oken in v vsakem svoje besedilo. Kasneje bomo
razlo¾ili, kako uporabljamo veè oken hkrati. Zaenkrat bomo povedali
le, kako se znebite dodatnih oken, ki jih lahko odpre vgrajena pomoè ali
pa izpis kak¹nega drugega programa. Preprosto je:
C-x 1 Eno okno (torej, zaprimo vsa ostala).
To je Ctrl-x, ki mu sledi ¹tevka 1. Ukaz C-x 1 raztegne èez cel
zaslon okno, v katerem se nahaja kazalèek, ostala pa zapre.
>> Premaknite kazalèek do te vrstice in vtipkajte C-u 0 C-l
>> Vtipkajte Ctrl-h k Ctrl-f.
Vidite, kako se je to okno skrèilo in odstopilo prostor oknu,
ki pojasnjuje ukaz Ctrl-f?
>> Vtipkajte C-x 1 in spodnje okno se bo zaprlo.
Za razliko od ukazov, ki smo se jih nauèili do zdaj, je ta ukaz
sestavljen iz dveh znakov. Zaène se z znakom Control-x. Cela vrsta
ukazov se zaène enako, in mnogi od njih zadevajo delo z datotekami,
delovnimi podroèji in podobnim. Vsem tem ukazom je skupno, da se
zaènejo s Control-x, ki mu sledi ¹e en, dva ali trije znaki.
* VRIVANJE IN BRISANJE
----------------------
Èe ¾elite v obstojeèe besedilo vriniti novo, preprosto premaknite
kazalèek na ¾eljeno mesto in zaènite tipkati. Znake, ki jih lahko
vidite, na primer A, 7, * in podobno, razume Emacs kot del besedila in
jih takoj vrine. S pritiskom na Return (ali Enter) vrinete znak za
skok v novo vrstico.
Zadnji vtipkani znak lahko izbri¹ete s pritiskom na tipko <Delete>. Na
nekaterih tipkovnicah je oznaèena z <Del>. Ponekod (ne pa povsod!)
slu¾i za brisanje tipka <Backspace>.
Splo¹no <Delete> pobri¹e znak neposredno pred trenutnim polo¾ajem
kazalèka.
>> Vtipkajte zdaj nekaj znakov in jih zatem s tipko <Delete> pobri¹ite.
Niè naj vas ne skrbi, èe se je ta vrstica spremenila. Izvirnika
tega uèbenika ne boste pokvarili -- tole je samo va¹a osebna kopija.
Ko vrstica postane predolga za zaslon, se ,,nadaljuje`` v naslednji
vrstici na zaslonu. Obrnjena po¹evnica (znak ,\`) ob desnem robu
oznaèuje vrstico, ki se nadaljuje v naslednji zaslonski vrstici.
>> Zdaj zaènite tipkati besedilo, dokler ne dose¾ete desnega roba, in
¹e naprej. Opazili boste, da se pojavi znak za nadaljevanje.
>> S tipko <Delete> pobri¹ite toliko znakov, da vrstica ne sega
veè èez ¹irino zaslona. Znak za nadaljevanje v naslednji
vrstici je izginil.
Znak za novo vrstico lahko pobri¹emo enako kot vsak drug znak. S tem,
ko pobri¹emo znak za novo vrstico, zdru¾imo vrstici v eno samo. Èe bo
nova vrstica predolga, da bi cela pri¹la na zaslon, bo razdeljena v
veè zaslonskih vrstic.
>> Premaknite kazalèek na zaèetek vrstice in pritisnite <Delete>. To
zdru¾i vrstico s prej¹njo.
>> Pritisnite <Return>. S tem ste ponovno vrinili znak za skok v novo
vrstico, ki ste ga malo prej zbrisali.
Spomnimo se, da lahko za veèino ukazov v Emacsu doloèimo, naj se
izvedejo veèkrat zaporedoma; to vkljuèuje tudi vnos teksta. Ponovitev
obièajnega znaka ga veèkrat vrine v besedilo.
>> Poskusite zdaj tole: da vnesete osem zvezdic, vtipkajte C-u 8 *
Zdaj ste se nauèili najpreprostej¹i naèin, da v Emacsu nekaj natipkate
in popravite. Bri¹ete lahko tudi besede ali vrstice. Tu je povzetek
ukazov za brisanje:
<Delete> pobri¹e znak tik pred kazalèkom (levo od
oznake za kazalèek)
C-d pobri¹e znak tik za kazalèkom (,pod` oznako
za kazalèek)
M-<Delete> pobri¹e besedo tik pred kazalèkom
M-d pobri¹e besedo tik za kazalèkom
C-k zavr¾e besedilo desno od kazalèka do konca vrstice
M-k zavr¾e besedilo od polo¾aja kazalèka do konca stavka
Èrka ,d` je iz angle¹ke besede ,delete` (pobrisati), èrka ,k` pa iz
besede ,kill` (pobiti). Ste opazili, da <Delete> in C-d na eni, ter
M-<Delete> in M-d na drugi strani nadaljujeta paralelo, ki sta jo zaèela
C-f in M-f (<Delete> pravzaprav ni kontrolni znak, kar pa naj nas ne
moti). C-k in M-k sta v enakem sorodu s C-e in M-e: prvi deluje na
vrstice, drugi na stavke.
Kadarkoli pobri¹ete kaj veè kot en sam znak naenkrat, si Emacs za vsak
primer zapomni, kaj ste zavrgli, in lahko zavr¾eno vrnete (angl.
,,yank`` -- potegniti). Besedilo, ki smo ga zavrgli, lahko vrinemo
nazaj na isto mesto ali kam drugam. Lahko ga vrinemo tudi veèkrat, in
tako napravimo veè kopij. Ukaz za vraèanje zavr¾enega besedila je C-y.
Razlika med tem, èe zavr¾ete cel odstavek besedila (angl. ,,kill``,
pobiti) ali pa èe pobri¹ete znak (angl. ,,delete``), je ta, da lahko
prvega vrnete nazaj z ukazom C-y, drugega pa ne. Na splo¹no ukazi, ki
lahko povzroèijo veliko ¹kode (pobri¹ejo veliko besedila), shranijo
pobrisano besedilo; tisti, ki pobri¹ejo samo posamezni znak, ali samo
prazne vrstice in presledke, pa ne.
>> Postavite kazalèek na zaèetek neprazne vrstice. Pritisnite C-k, da
pobri¹ete vsebino vrstice.
>> ©e enkrat pritisnite C-k. To pobri¹e ¹e znak za novo vrstico.
Ste opazili, da prvi C-k pobri¹e vsebino vrstice, naslednji C-k pa ¹e
vrstici samo, s èimer se vse besedilo pod biv¹o vrstico premakne za
eno vrstico navzgor? Ukaz C-k obravnava ¹tevilèni argument malo
drugaèe: pobri¹e toliko in toliko vrstic z vsebinami vred. To ni zgolj
ponovitev. C-u 2 C-k pobri¹e dve polni vrstici besedila, kar je nekaj
drugega, kot èe dvakrat vtipkate C-k.
Besedilo, ki ste ga prej pobrisali, je shranjeno, in ga lahko povrnete
tja, kjer je trenutno kazalèek, z ukazom C-y.
>> Poskusite z ukazom C-y povrniti pobrisano besedilo.
Ukaz C-y si predstavljajte, kot da potegnete nazaj nekaj, kar vam je
nekdo odnesel. Èe ste uporabili veè zaporednih ukazov C-k, je vse
pobrisano besedilo shranjeno skupaj, in en sam C-y bo vrnil vse tako
pobrisane vrstice.
>> Poskusite, nekajkrat vtipkajte C-k.
Zdaj pa vrnimo pobrisano besedilo:
>> Vtipkajte C-y. Zdaj pa premaknite kazalèek za nekaj vrstic navzdol
in ¹e enkrat vtipkajte C-y. Vidite zdaj, kako se kopira dele
besedila?
Kaj pa, èe ste pobrisali nekaj besedila, ki bi ga radi vrnili, vendar
ste za iskanim odlomkom pobrisali ¹e nekaj? C-y vrne samo nazadnje
pobrisan odlomek. Vendar tudi prej¹nje besedilo ni izgubljeno. Do
njega lahko pridete z ukazom M-y. Ko ste vrnili nazadnje zbrisano
besedilo s C-y, pritisnite M-y, ki ga zamenja s predzanje pobrisanim
besedilom. Vsak naslednji M-y prika¾e ¹e eno prej. Ko ste konèno
pri¹li do iskanega besedila, ni treba napraviti niè posebnega, da bi
ga obdr¾ali. Preprosto nadaljujte z urejanjem, in vrnjeno besedilo bo
ostalo, kamor ste ga odlo¾ili.
Èe pritisnete M-y dovolj velikokrat, se boste vrnili na zaèete, torej
spet na zadnje pobrisano besedilo.
>> Pobri¹ite vrstico, premaknite se nekam drugam, in pobri¹ite ¹e
eno vrstico.
Z ukazom C-y dobite nazaj to drugo vrstico.
Z ukazom M-y pa jo zamenjate s prvo vrstico.
Ponovite ukaz M-y ¹e nekajkrat in si oglejte, kaj dobite na
zaslon. Ponavljajte ga, dokler se ne prika¾e ponovno nazadnje
pobrisana vrstica, in ¹e naprej. Èe ¾elite, lahko tudi ukazu
M-y podate pozitivno ali negativno ¹tevilo ponovitev.
* PREKLIC UKAZA (UNDO)
----------------------
Èe ste besedilo spremenili, a ste se kasneje premislili, lahko
besedilo vrnete v prvotno stanje z ukazom Undo, C-x u. Normalno vrne
C-x u zadnjo spremembo besedila; èe ukaz ponovimo, preklièemo ¹e
predzadnjo spremembo, in vsaka nadaljnja ponovitev se¾e ¹e eno
spremembo globlje v zgodovino.
Emacs hrani bolj ali manj celotno zgodovino na¹ih ukazov, z dvema
izjemama: ukazov, ki niso napravili nobene spremembe v besedilu
(npr. premik kazalèka), ne shranjuje, in zaporedje do 20 vrinjenih
znakov shrani kot en sam ukaz. Slednje prihrani nekaj ukazov C-x u, ki
bi jih morali vtipkati.
>> Pobri¹ite to vrstico z ukazom C-k, potem jo priklièite nazaj s C-x u.
C-_ je alternativni ukaz za preklic zadnjega ukaza. Deluje enako kot
s C-x u, ga je pa la¾je odtipkati, èe morate ukaz ponoviti veèkrat
zaporedoma. Te¾ava z ukazom C-_ je, da na nekaterih tipkovnicah ni
povsem oèitno, kako ga vtipkati, zato je podvojen ¹e kot C-x u. Na
nekaterih terminalih moramo na primer vtipkati /, medtem ko dr¾imo
pritisnjeno tipko CONTROL.
Èe podamo ukazu C-_ ali C-x u numerièni argument, je to enako, kot èe
bi ukaz roèno ponovili tolikokrat, kot pravi argument.
* DATOTEKE
----------
Da bi bile spremembe v besedilu trajne, morate besedilo shraniti v
datoteko. V nasprotnem primeru jih boste za vedno izgubili tisti hip,
ko boste zapustili Emacs. Besedilo postavimo v datoteko tako, da
na disku ,,poi¹èemo`` (angl. find) datoteko, preden zaènemo tipkati
(pravimo tudi, da ,,obi¹èemo`` datoteko).
Poiskati datoteko pomeni, da v Emacsu vidimo vsebino datoteke. To je
bolj ali manj tako, kot da z Emacsom urejamo datoteko samo. Vendar pa
spremembe ne postanejo trajne, dokler datoteke ne shranimo
(angl. save) na disk. Tako imamo mo¾nost, da se izognemo temu, da bi
nam na pol spremenjene datoteke le¾ale po disku, kadar tega ne
¾elimo. Ker pa Emacs ohrani izvorno datoteko pod spremenjenim imenom,
lahko prvotno datoteko priklièemo nazaj celo ¹e potem, ko smo datoteko
¾e shranili na disk.
V predzadnji vrstici na dnu zaslona vidite vrstico, ki se zaène in
konèa z vezaji, in vsebuje niz znakov ,,--:-- TUTORIAL``. Ta del
zaslona navadno vsebuje ime datoteke, ki smo jo obiskali. Zdajle je to
,,TUTORIAL``, va¹a delovna kopija uèbenika Emacsa. Ko boste poiskali
kak¹no drugo datoteko, bo na tem mestu pisalo njeno ime.
Posebnost ukaza za iskanje datoteke je, da moramo povedati, katero
datoteko i¹èemo. Pravimo, da ukaz ,,prebere argument s terminala`` (v
tem primeru je argument ime datoteke). Ko vtipkate ukaz
C-x C-f (poi¹èi datoteko)
vas Emacs povpra¹a po imenu datoteke. Kar vtipkate, se sproti vidi v
vrstici na dnu zaslona. Temu delovnemu podroèju pravimo pogovorni
vmesnik (minibuffer), kadar se uporablja za tovrstni vnos. Znotraj
pogovornega vmesnika lahko uporabljate obièajne ukaze za urejanje, èe
ste se na primer pri tipkanju zmotili.
Sredi tipkanja imena datoteke (ali katerega koli drugega opravila v
pogovornem vmesniku) lahko ukaz preklièete s C-g.
>> Vtipkajte C-x C-f, zatem pa ¹e C-g. Zadnji ukaz od treh je
zaprl pogovorni vmesnik in tudi preklical ukaz C-x C-f, ki je
uporabljal pogovorni vmesnik. Konec z iskanjem datoteke.
Ko ste dokonèali ime, ga vnesete s pritiskom na <Return>. S tem se
po¾ene ukaz C-x C-f in poi¹èe iskano datoteko. Pogovorni vmesnik
izgine, ko je ukaz izveden.
Trenutek kasneje se vsebina datoteke pojavi na zaslonu. Zdaj lahko
dopolnjujete, urejate ali kako drugaèe spreminjate vsebino. Ko ¾elite,
da ostanejo spremembe trajne, izvedete ukaz:
C-x C-s (shrani datoteko)
Besedilo se s tem shrani iz pomnilnika raèunalnika na datoteko na
disk. Ko prviè izvedete ta ukaz, se izvorna datoteka preimenuje, tako
da ni izgubljena. Najdete jo pod novim imenom, ki se od starega
razlikuje po tem, da ima na koncu pripet znak ,,~``.
Ko je Emacs shranil datoteko, izpi¹e njeno ime. Shranjujte raje
pogosteje kot ne, da v primeru, èe gre z raèunalnikom kaj narobe, ne
izgubite veliko.
>> Vtipkajte C-x C-s, s èimer boste shranili svojo kopijo tega
uèbenika. Emacs bo v vrstici na dnu zaslona izpisal ,,Wrote
...TUTORIAL``.
Opozorilo: na nekaterih sistemih bo ukaz C-x C-s zamrznil zaslon, in
tako ne boste videli, da Emacs ¹e kaj izpi¹e. To je znak, da je
operacijski sistem prestregel znak C-s in ga interpretiral kot znak za
prekinitev toka podatkov, namesto da bi ga posredoval Emacsu. Zaslon
,,odmrznete`` z ukazom C-q. Èe je va¹ sistem eden takih, si za nasvet,
kako re¹iti to nev¹eènost, oglejte razdelek ,,Spontaneous Entry to
Incremental Search`` v priroèniku za Emacs.
Poi¹èete lahko lahko ¾e obstojeèo datoteko, da si jo ogledate ali
popravite, ali pa tudi datoteko, ki ¹e ne obstaja. To je naèin, kako z
Emacsom ustvarimo novo datoteko: poi¹èite datoteko z izbranim imenom,
ki bo sprva prazna, in zaènite pisati. Ko jo boste prviè shranili, bo
Emacs ustvaril datoteko z vne¹enim besedilom. Od tod dalje delate na
¾e obstojeèi datoteki.
* DELOVNA PODROÈJA
------------------
Tudi èe ste z ukazom C-x C-f poiskali in odprli drugo datoteko, prva
ostane v Emacsu. Nanjo se vrnete tako, da jo ¹e enkrat ,,poi¹èete`` z
ukazom C-x C-f. Tako imate lahko v Emacsu hkrati kar precej datotek.
>> Ustvarite datoteko z imenom ,,foo`` tako, da vtipkate C-x C-f
foo <Return>. Natipkajte nekaj besedila, ga po potrebi popravite, in
shranite v datoteko ,,foo`` z ukazom C-x C-s. Ko ste konèali, se
vrnite v uèbenik z ukazom C-x C-f TUTORIAL <Return>.
Emacs hrani besedilo vsake datoteke v takoimenovanem ,,delovnem
podroèju`` (angl. buffer). Ko poi¹èemo datoteko, Emacs ustvari zanjo
novo delovno podroèje. Vsa obstojeèa delovna podroèja v Emacsu vidimo
z ukazom:
C-x C-b Seznam delovnih podroèij.
>> Poskusite C-x C-b zdaj.
Vidite, da ima vsako delovno podroèje svoje ime, pri nekaterih pa pi¹e
tudi ime datoteke, katere vsebina se hrani v njem. Druga delovna
podroèja pa ne pripadajo nobeni datoteki. Podroèje ,,*Buffer List*``,
na primer, je ¾e eno takih. To delovno podroèje smo ustvarili
ravnokar, ko smo pognali ukaz C-x C-b. VSAKO besedilo, ki ga vidite v
katerem od Emacsovih oken, je vedno del kak¹nega delovnega podroèja.
>> Z ukazom C-x 1 se znebite seznama delovnih podroèij.
Èe ste spreminjali besedilo ene datoteke, potem pa poiskali drugo, to
ne shrani spremeb v prvo datoteko. Te ostanejo znotraj Emacsa, na
delovnem podroèju, ki pripada prvi datoteki. Ustvarjenje ali
spreminjanje delovnega podroèja druge datoteke nima nobenega vpliva na
podroèje prve. To je zelo uporabno, pomeni pa tudi, da potrebujemo
udobno pot, da shranimo delovno podroèje prve datoteke. Nerodno bi
bilo preklapljanje na prvo podroèje s C-x C-f, da bi shranili s C-x
C-s. Namesto tega imamo:
C-x s Shrani nekatera delovna podroèja
Ukaz C-x poi¹èe delovna podroèja, katerih vsebina je bila spremenjena,
odkar je bila zadnjiè shranjena na datoteko. Za vsako tako delovno
podroèje C-x s vpra¹a, èe ga ¾elite shraniti.
* RAZ©IRJEN NABOR UKAZOV
------------------------
©e mnogo, mnogo je ukazov Emacsa, ki bi zaslu¾ili, da jih obesimo na
razne kontrolne in meta znake. Emacs se temu izogne z ukazom X (iz angl.
eXtend - raz¹iriti), ki uvede ukaz iz raz¹irjenega nabora. Dveh vrst je:
C-x Znakovna raz¹iritev (angl. Character eXtend).
Sledi mu en sam znak.
M-x Raz¹iritev s poimenovanim ukazom. Sledi mu dolgo ime
ukaza.
Tudi ti ukazi so na splo¹no uporabni, ne uporabljamo pa jih tako
pogosto kot tiste, ki ste se jih ¾e nauèili. Dva ukaza iz raz¹irjenega
nabora ¾e poznamo: C-x C-f, s katerim poi¹èemo datoteko, in C-x C-s, s
katerim datoteko shranimo. ©e en primer je ukaz, s katerim Emacsu
povemo, da ¾elimo konèati z delom iz iziti iz Emacsa. Ta ukaz je C-x
C-c (ne skrbite: preden konèa, Emacs ponudi, da shrani vse spremenjene
datoteke).
Z ukazom C-z Emacs zapustimo samo *zaèasno*, tako da lahko ob vrnitvi
nadaljujemo z delom, kjer smo ostali.
Na sistemih, ki to dopu¹èajo, ukaz C-z izide iz Emacsa v ukazno
lupino, a ga ne konèa - èe uporabljate ukazno lupino C, se lahko
vrnete z ukazom ,fg` ali splo¹neje z ukazom ,,%emacs``.
Drugod ukaz C-z po¾ene sekundarno ukazno lupino, tako da lahko
po¾enete kak¹en drug program in se kasneje vrnete v Emacs. V tem
primeru pravzaprav Emacsa ne zapustimo. Ukaz ,,exit`` v ukazni lupini
je navadno naèin, da zapremo sekundarno lupino in se vrnemo v Emacs.
Ukaz C-x C-c uporabimo, èe se nameravamo odjaviti s sistema. To je
tudi pravilen naèin za izhod iz Emacsa, èe je tega pognal program za
delo s po¹to ali kak drug program, saj ta verjetno ne ve, kaj
napraviti z zaèasno prekinjenim Emacsom. V vseh ostalih primerih pa,
èe se ne nameravate odjaviti s sistema, uporabite C-z, in se vrnite v
Emacs, ko bi radi spet urejali besedilo.
Ukazov C-x je veliko. Zaenkrat smo spoznali naslednje:
C-x C-f Poi¹èi datoteko.
C-x C-s Shrani datoteko.
C-x C-b Seznam delovnih podroèij.
C-x C-c Konèaj Emacs.
C-x u Preklic zadnjega ukaza.
Poimenovani raz¹irjeni ukazi so ukazi, ki se uporabljajo ¹e bolj
poredko, ali pa se uporabljajo samo v nekaterih naèinih dela. Eden
takih je na primer ukaz replace-string, ki po vsem besedilu zamenja en
niz znakov z drugim. Ko vtipkate M-x, se to izpi¹e v pogovornem
vmesniku na dnu zaslona, Emacs pa èaka, da vtipkate ime ukaza, ki ga
¾elite priklicati; v tem primeru je to ,,replace-string``. Vtipkajte
samo ,,repl s<TAB>`` in Emacs bo dopolnil ime. Ukaz vnesete s
pritiskom na <Return>.
Ukaz replace-string potrebuje dva argumenta -- niz, ki ga ¾elite
zamenjati, in niz, s katerim bi radi zamenjali prvega. Vsakega posebej
vnesete in zakljuèite s pritiskom na tipko Return.
>> Premaknite kazalèek na prazno vrstico dve vrstici pod to, zatem
vtipkajte M-x repl s<Return>zamenjala<Return>spremenila<Return>.
Opazite, kako se je ta vrstica zamenjala? Vse besede
z-a-m-e-n-j-a-l-a od tod do konca besedila ste nadomestili z besedo
,,spremenila``.
* AVTOMATIÈNO SHRANJEVANJE
--------------------------
Spremembe v datoteki, ki jih ¹e niste shranili na disk, so izgubljene,
èe medtem denimo zmanjka elektrike. Da bi vas zavaroval pred tem,
Emacs periodièno avtomatièno shrani vse datoteke, ki jih
urejate. Avtomatièno shranjena datoteka se od izvorne razlikuje po
znaku ,#` na zaèetku in koncu imena: èe se je va¹a datoteka imenovala
,,hello.c``, se avtomatièno shranjena datoteka imenuje
,,#hello.c#``. Ko normalno shranite datoteko, avtomatièno shranjena
datoteka ni veè potrebna, in Emacs jo pobri¹e.
Èe res pride do izgube podatkov v pomnilniku, lahko povrnete avtomatièno
shranjeno besedilo tako, da normalno poi¹èete datoteko (pravo ime
datoteke, ne ime avtomatièno shranjene datoteke), zatem pa vtipkate M-x
recover file<Return>. Ko vas vpra¹a za potrditev, vtipkajte yes<Return>
za nadaljevanje in povrnitev avtomatièno shranjenenih podatkov.
* ODZIVNO PODROÈJE
------------------
Kadar Emacs opazi, da poèasi vtipkavate ukaz, odpre v zadnji vrstici
na dnu zaslona odzivno podroèje in v njem sproti prikazuje natipkano.
* STATUSNA VRSTICA
------------------
Vrstica nad odzivnim podroèjem je statusna vrstica. Ta ka¾e verjetno
nekaj podobnega kot:
--:** TUTORIAL (Fundamental)--58%----------------------
V njej so izpisani pomembni podatki o stanju Emacsa in besedilu, ki ga
urejate.
Zdaj ¾e veste, kaj pomeni ime datoteke -- to je datoteka, ki ste jo
poiskali. Oznaka --NN%-- pomeni, da je nad vrhom zaslona ¹e NN
odstotkov celotne datoteke. Èe je zaèetek datoteke na zaslonu, bo
namesto --00%-- pisalo --Top--. Podobno bo pisalo --Bot--, èe je
zadnja vrstica datoteke na zaslonu. Èe je datoteka, ki jo ogledujete,
tako kratka, da gre vsa na en zaslon, pa bo pisalo --All--.
Zvezdice na zaèetku vrstice pomenijo, da ste datoteko ¾e spreminjali.
Tik po tem, ko ste odprli ali shranili datoteko, ni nobenih zvezdic,
so samo èrtice.
Del statusne vrstice znotraj oklepajev vam pove, v kak¹nem naèinu dela
Emacs. Privzeti naèin je osnovni naèin (Fundamental), v katerem ste
sedaj. Fundamental je eden od glavnih naèinov (angl. major
mode). Emacs pozna veliko razliènih glavnih naèinov. Nekateri od njih
so namenjeni pisanju programov, kot na primer Lisp, ali pisanju
besedil, kot npr. Text. Naenkrat je lahko aktiven le en glavni naèin,
njegovo ime pa je vedno izpisano v statusni vrstici, kjer zdaj pi¹e
Fundamental.
Glavni naèini lahko spremenijo pomen nekaterim ukazom. Obstajajo,
denimo, ukazi za pisanje komentarjev v programu, in ker ima vsak
programski jezik svoje predstave o tem, kako mora komentar izgledati,
mora vsak glavni naèin vnesti komentarje drugaèe. Ker je vsak glavni
naèin ime raz¹irjenega ukaza, lahko tako tudi izbiramo glavni
naèin. Na primer, M-x fundamental-mode vas postavi v naèin
Fundamental.
Èe nameravate popravljati slovensko (ali angle¹ko) besedilo, kot je na
primer tole, boste verjetno izbrali tekstovni naèin (Text).
>> Vtipkajte M-x text mode<Return>.
Ne skrbite, noben od ukazov, ki ste se jih nauèili, se s tem ne
spremeni kaj dosti. Lahko pa opazite, da Emacs zdaj jemlje opu¹èaje za
dele besed, ko se premikate z M-f ali M-b. V osnovnem naèinu jih je
obravnaval kot meje med besedami.
Glavni naèini navadno poèenjajo majhne spremembe, kot je ta: veèina
ukazov ,,opravi isti posel``, vendar pa to poènejo na razlièen naèin.
Dokumentacijo o trenutno aktivnem glavnem naèinu dobite z ukazom C-h m.
>> Uporabite C-u C-v enkrat ali veèkrat, toliko, da bo ta vrstica blizu
vrha zaslona.
>> Vtipkajte C-h m, da vidite, v èem se tekstovni naèin (Text) razlikuje
od osnovnega (Fundamental).
>> Vtipkajte C-x 1, da umaknete dokumentacijo z zaslona.
Glavnim naèinom pravimo glavni naèini zato, ker obstajajo tudi
podnaèini (angl. minor modes). Podnaèini ne nadome¹èajo glavnih
naèinom, ampak le spreminjajo njihovo obna¹anje. Podnaèine lahko
aktiviramo ali deaktiviramo neodvisno od glavnega naèina in neodvisno
od ostalih podnaèinov. Tako lahko ne uporabljate nobenega podnaèina,
en podnaèin, ali kombinacijo veèih podnaèinov.
Podnaèin, ki je zelo uporaben, posebno za pisanje besedil, je Auto
Fill. Ko je vklopljen, Emacs med pisanjem avtomatièno deli vrstice na
presledkih med besedami, tako da vrstice niso predolge.
Vklopite ga lahko z ukazom M-x auto fill mode<return>. Ko je
vklopljen, ga lahko izklopite z istim ukazom, M-x
auto fill mode<return>. Z istim ukazom torej preklapljamo
(angl. toggle) med vklopljenim in izklopljenim stanjem.
>> Vtipkajte zdaj M-x auto fill mode. Potem zaènite tipkati "asdf asdkl
sdjf sdjkf"... dokler ne opazite, da je Emacs razbil vrstico na dve.
Med tipkanjem mora biti dovolj presledkov, saj Auto Fill prelamlja
vrstice samo na presledkih.
©irina besedila je navadno postavljena na 70 znakov, kar pa lahko
spremenite z ukazom C-x f. Novo ¹irino morate podati kot ¹tevilèni
argument.
>> Vtipkajte C-x f in argument 20. (C-u 2 0 C-x f). Zatem vtipkajte
nekaj besedila in poglejte, èe bo Emacs res delil vrstice pri 20
znakih. Potem z ukazom C-x f postavite mejo nazaj na 70.
Auto Fill deluje le, kadar pi¹ete novo besedilo, ne pa,
kadar popravljate ¾e napisan odstavek.
Tak odstavek lahko poravnate tako, da kazalèek premaknete nekam
znotraj odstavka in uka¾ete M-q (Meta-q).
>> Premaknite kazalèek v prej¹nji odstavek in izvedite M-q.
* ISKANJE
---------
Emacs lahko v besedilu poi¹èe niz znakov (zaporedje znakov ali besed),
naprej ali nazaj po besedilu. Iskanje spada v skupino ukazov za
premikanje kazalèka, saj premakne kazalèek na kraj v besedilu, kjer je
na¹el iskani niz.
Iskanje v Emacsu je morda nekoliko drugaèno od tistega, ki ste ga
navajeni, in sicer je ,,inkrementalno``. To pomeni, da se iskanje
odvija hkrati s tem, ko tipkate iskani niz.
Ukaza za iskanje sta C-s za iskanje naprej po datoteki in C-r za
iskanje nazaj po datoteki. POÈAKAJTE! Ne preizku¹ajte jih ¹e ta hip!
Ko boste natipkali C-s, boste opazili niz ,,I-search`` kot pozivnik
v pogovornem vmesniku. To vam pove, da je Emacs v inkrementalnem iskanju
in vas èaka, da zaènete tipkati, kar i¹èete. <Return> zakljuèi iskanje.
>> Pritisnite zdaj C-s. POÈASI, èrko za èrko, vtipkajte besedo
,,kazalèek``. Za vsako vtipkano èrko se ustavite in si oglejte, kaj
se je zgodilo s kazalèkom.
>> ©e enkrat pritisnite C-s, da poi¹èete naslednji ,,kazalèek``.
>> ©estkrat pritisnite <Delete> in opazujte, kako se premika kazalèek.
>> Konèajte iskanje s tipko <Return>.
Ste videli, kaj se je zgodilo? Emacs pri inkrementalnem iskanju sku¹a
poiskati niz, ki ste ga natipkali do tistega hipa. Da poi¹èete
naslednje mesto, kjer se pojavi ,,kazalèek``, samo ¹e enkrat
pritisnete C-s. Èe takega mesta ni, Emacs èivkne in vam sporoèi, da
iskanje ni uspelo. Tudi C-g prekine iskanje.
OPOZORILO: Na nekaterih sistemih bo s pritiskom na C-s ekran
zmrznil. To je znak, da je operacijski sistem prestregel znak C-s in
ga interpretiral kot znak za prekinitev toka podatkov, namesto da bi
ga posredoval programu Emacs. Ekran ,,odtajate`` s pritiskom na
C-q. Potem si oglejte razdelek ,,Spontaneous Entry to Incremental
Search`` v priroèniku za nasvet, kako se spopasti s to nev¹eènostjo.
Èe sredi inkrementalnega iskanja pritisnete <Delete>, boste opazili,
da to pobri¹e zadnji znak v iskanem nizu, kazalèek pa se premakne
nazaj na mesto v besedilu, kjer je na¹el kraj¹i niz. Na primer,
predpostavimo, da ste do zdaj natipkali ,,ka`` in je kazalèek na
mestu, kjer se prviè pojavi ,,ka``. Èe zdaj pritisnete <Delete>, boste
s tem v pogovornem vmesniku izbrisali ,a`, hkrati pa se bo kazalèek
postavil na mesto, kjer je prviè na¹el ,k`, preden ste natipkali ¹e
,a`.
Èe sredi iskanja vtipkate katerikoli kontrolni znaki ali metaznak
(razen tistih, ki imajo poseben pomen pri iskanju, to sta C-s in C-r),
se iskanje prekine.
C-s zaène iskati na mestu v datoteki, kjer trenutno stoji kazalèek, in
i¹èe do konca datoteke. Èe bi radi iskali proti zaèetku datoteke,
namesto C-s vtipkamo C-r. Vse, kar smo povedali o ukazu C-s, velja
tudi za C-r, le smer iskanja je obrnjena.
* VEÈ OKEN NA ZASLONU
---------------------
Ena simpatiènih lastnosti Emacsa je, da zna hkrati prikazati veè oken
na ekranu, tudi èe ne delamo v grafiènem naèinu.
>> Premaknite kazalèek v to vrstico in vtipkajte C-u 0 C-l.
>> Zdaj vtipkajte C-x 2, da razdelite zaslon na dve okni.
V obeh oknih imate odprt ta priroènik. Kazalèek je ostal v zgornjem
oknu.
>> Pritisnite C-M-v za listanje v spodnjem oknu.
(Èe nimate tipke Meta, tipkajte ESC C-v).
>> Vtipkajte C-x o (o kot ,,other``, drugi), da preselite kazalèek v
spodnje okno.
>> S C-v in M-v se v spodnjem oknu premikate po vsebini datoteke.
Zgornje okno ¹e vedno ka¾e ta navodila.
>> Ponovni C-x o vas vrne v zgornje okno. Kazalèek se je vrnil na
mesto, kjer je bil, preden smo skoèili v spodnje okno.
Z ukazom C-x o lahko preklapljamo med okni. Vsako okno si zapomni, kje
v oknu je ostal kazalèek, samo trenutno aktivno okno pa kazalèek tudi
v resnici prika¾e. Vsi obièajni ukazi za urejanje, ki smo se jih
nauèili, veljajo za aktivno okno.
Ukaz C-M-v je zelo uporaben, kadar urejamo besedilo v enem oknu,
drugega pa uporabljamo samo za pomoè. Kazalèek ostaja ves èas v oknu,
v katerem urejamo, po vsebini spodnjega okna pa se vseeno lahko
premikamo, ne da bi morali venomer skakati iz enega okna v drugega.
C-M-v je primer znaka CONTROL-META. Èe imate v resnici tipko Meta (na
PC navadno levi Alt), lahko vtipkate C-M-v tako, da dr¾ite pritisnjeni
tako CONTROL kot META, medtem ko vtipkate v. Ni pomembno, katero od
tipk, CONTROL ali META, pritisnete prvo, saj obe delujeta ¹ele, ko
pritisnete znak, ki sledi (v zgornjem primeru ,v`).
Nasprotno pa je vrstni red pritiskanja pomemben, èe nimate tipke META
in namesto nje uporabljate ESC. V tem primeru morate najprej
pritisniti ESC, potem pa Control-v. Obratna kombinacija, Control-ESC v ne
deluje. To je zato, ker je ESC znak sam po sebi, ne pa modifikator,
kot sta CONTROL in META.
>> V zgornjem oknu vtipkajte C-x 1, da se znebite spodnjega okna.
(Èe bi vtipkali C-x 1 v spodnjem oknu, bi se znebili
zgornjega. Razmi¹ljajte o tem ukazu kot ,,Obdr¾i samo eno okno, in
sicer tisto, v katerem sem zdaj.``)
Seveda ni nujno, da obe okni ka¾eta isto delovno podroèje. Èe v enem
oknu izvedete C-x C-f in poi¹èete novo datoteko, se vsebina drugega
okna ne spremeni. V vsakem oknu lahko neodvisno obdelujete drugo
datoteko.
Pa ¹e ena pot, kako v dveh oknih prika¾ete dve razlièni datoteki:
>> Vtipkajte C-x 4 C-f, in na pozivnik vtipkajte ime ene va¹ih
datotek. Konèajte z <Return>. Odpre se ¹e eno okno in izbrana
datoteka se pojavi v drugem oknu. Tudi kazalèek se preseli v drugo
okno.
>> Vtipkajte C-x o, da se vrnete nazaj v zgornje okno, in C-x 1, da
zaprete spodnje okno.
* REKURZIVNI NIVOJI UREJANJA
----------------------------
Vèasih boste pri¹li v nekaj, èemur se pravi ,,rekurzivni nivo
urejanja``. To se vidi po tem, da v statusni vrstici oglati oklepaji
oklepajo ime glavnega naèina. V osnovnem naèinu bi, na primer, videli
[(Fundamental)] namesto (Fundamental).
Iz rekurzivnega nivoja urejanja se re¹ite, èe vtipkate ESC ESC ESC. To
zaporedje je vsenamenski ukaz ,,pojdi ven``. Uporabite ga lahko tudi
za ukinjanje odveènih oken, ali vrnitev iz pogovornega vmesnika.
>> Pritisnite M-x, da odprete pogovorni vmesnik, zatem pa vtipkajte
ESC ESC ESC, da pridete ven iz njega.
Z ukazom C-g ne morete iz rekurzivnega nivoja urejanja, ker C-g
preklièe ukaze ali argumente ZNOTRAJ rekurzivnega nivoja.
* DODATNA POMOÈ
---------------
V tem uvodu smo posku¹ali zbrati dovolj informacij, da lahko zaènete
Emacs uporabljati. Emacs ponuja toliko, da bi bilo nemogoèe vse to
zbrati tukaj. Verjetno pa bi se vseeno radi nauèili kaj o ¹tevilnih
koristnih mo¾nostih, ki jih ¹e ne poznate. Emacs ima ¾e vgrajene
veliko dokumentacije, do katere lahko pridete s pritiskom na CTRL-h (h
kot ,,help``, pomoè).
Za pomoè pritisnete C-h, potem pa vtipkate znak, ki pove, kak¹no pomoè
¾elite. Èe ste poplnoma izgubljeni, vtipkajte C-h ? in Emacs vam bo
povedal, kak¹na pomoè je sploh na voljo. Èe ste vtipkali C-h, pa ste
si premislili, lahko ukaz preklièete s C-g.
(Ponekod se znak C-h preslika v kaj drugega. To ni dobro, in v takem
primeru se prito¾ite sistemskemu vzdr¾evalcu. Medtem pa, èe C-h ne
prika¾e sporoèila o pomoèi na dnu zaslona, namesto tega poskusite
pritisniti tipko F1 ali pa vtipkajte M-x help <Return>.)
Najosnovnej¹i tip pomoèi prika¾e C-h c. Pritisnite C-h, tipko c, zatem
pa ukazni znak ali zaporedje ukaznih znakov, in Emacs bo izpisal
kratek opis ukaza.
>> Vtipkajte C-h c Control-p.
Izpi¹e se nekaj takega kot
C-p runs the command previous-line
Ukaz je izpisal ime funkcije, ki izvede ukaz. Imena funkcij
uporabljamo, kadar pi¹emo prilagoditve in raz¹iritve Emacsa. Ker pa so
navadno imena funkcij izbrana tako, da kaj povedo o tem, kaj funkcija
poène, bo verjetno to tudi dovolj za kratko osve¾itev, èe ste se z
ukazom ¾e kdaj sreèali.
Ukazu C-h lahko sledi tudi zaporedje znakov, kot na primer C-x C-s,
ali, èe nimate tipke META, <Esc>v.
Za veè informacij o ukazu vtipkajte C-h k namesto C-h c.
>> Vtipkajte C-h k Control-p.
To odpre novo okno in v njem prika¾e dokumentacijo o funkciji, obenem
z njenim imenom. Ko ste opravili, vtipkajte C-x 1, da se znebite okna
z pomoèjo. Tega seveda ni potrebno napraviti takoj, ampak lahko
urejate, medtem ko imate odprto okno s pomoèjo, in ga zaprete, ko ste
konèali.
Sledi ¹e nekaj uporabnih mo¾nosti, ki jih ponuja pomoè:
C-h f Opi¹i funkcijo. Kot argument morate podati ime
funkcije.
>> Poskusite C-h f previous-line<Return>.
To izpi¹e vse podatke, ki jih ima Emacs o funkciji, ki izvede ukaz C-p.
C-h a Apropos. Vtipkajte kljuèno besedo in Emacs bo izpisal
vse ukaze, ki vsebujejo to kljuèno besedo. Vse te
ukaze lahko priklièete z Meta-x. Pri nekaterih ukazih
bo Apropos izpisal tudi eno ali dvoznakovno
zaporedje, s katerim dose¾ete isti uèinek.
>> Vtipkajte C-h a file<Return>.
To odpre novo okno, v katerem so vsa dolga imena ukazov, ki vsebujejo
,,file`` v imenu. Izvedete jih lahko z M-x. Pri nekaterih se izpi¹e
tudi kratek ukaz, npr. C-x C-f ali C-x C-w pri ukazih find-file in
write-file.
>> Pritisnite C-M-v, da se sprehajate po oknu s pomoèjo. Poskusite
nekajkrat.
>> Vtipkajte C-x 1, da zaprete okno s pomoèjo.
* ZAKLJUÈEK
-----------
Zapomnite si, da Emacs zapustite z ukazom C-x C-c. Èe bi radi samo
zaèasno skoèili v ukazno lupino in se kasneje vrnili v Emacs, pa
storite to z ukazom C-z.
Ta uèbenik je napisan z namenom, da bi bil razumljiv vsem novincem v
Emacsu. Èe se vam kaj ne zdi jasno napisano, ne valite krivde nase -
prito¾ite se!
RAZMNO®EVANJE IN RAZ©IRJANJE
----------------------------
Angle¹ki izvirnik tega uvoda v Emacs je naslednik dolge vrste tovrstnih
besedil, zaèen¹i s tistim, ki ga je Stuart Cracraft napisal za izvorni
Emacs. V sloven¹èino ga je prevedel Primo¾ Peterlin.
To besedilo, kot sam GNU Emacs, je avtorsko delo, in njegovo
razmno¾evanje in raz¹irjanje je dovoljeno pod naslednjimi pogoji:
Copyright (c) 1985, 1996, 1997 Free Software Foundation
Dovoljeno je izdelovati in raz¹irjati neokrnjene kopije tega spisa
v kakr¹nikoli obliki pod pogojem, da je ohranjena navedba o
avtorstvu in to dovoljenje, ter da distributer dovoljuje prejemniku
nadaljnje raz¹irjanje pod pogoji, navedenimi v tem dovoljenju.
Pod pogoji iz prej¹njega odstavka je dovoljeno raz¹irjati
spremenjene verzije tega spisa ali njegovih delov, èe je jasno
oznaèeno, kdo je nazadnje vnesel spremembe.
Pogoji za razmno¾evanje in raz¹irjanje samega Emacsa so malo drugaèni,
a v istem duhu. Prosimo, preberite datoteko COPYING in potem dajte
kopijo programa GNU Emacs svojim prijateljem. Pomagajte zatreti
obstrukcionizem (,,lastni¹tvo``) v programju tako, da uporabljate,
pi¹ete in delite prosto programje!
;;; Local Variables:
;;; coding: iso-latin-2
;;; End:
Copyright (c) 1985 Free Software Foundation, Inc; Vea al final las
condiciones. Usted está viendo el tutorial de Emacs.
Los comandos de Emacs generalmente ivolucran a la tecla CONTROL (algunas
veces llamada CTRL O CTL) o la tecla meta algunas veces llamada (EDIT o
ALT). En lugar de escribir esto completamente en cada ocasión, usaremos
las siguientes abreviaciones.
C-<chr> significa mantener presionada la tecla CONTROL mientras digita el
caracter <chr>. Por lo tanto C-f será: Mantenga presionada la
tecla CONTROL y digite f.
M-<chr> significa mantega presionada la tecla META o EDIT o ALT mientras
digita <chr>. Si no hay teclas META, EDIT o ALT, en su lugar
presione y libere la tecla <esc> y luego digite <CHR>.
Escribimos <ESC> para la tecla ESC.
Nota importante: para finalizar la sesión de Emacs presione C-x C-c.
(dos caracteres.) los caracteres ">>" al margen izquierdo indican
instrucciones para que usted trate de usar un comando. Por ejemplo:
<<Blank lines inserted here by startup of help-with-tutorial>>
>> Ahora digite C-v (ver la proxima pantalla) para desplazarse a la
siguiente pantalla (hágalo manteniendo la tecla control oprimida
mientras digita v).
Desde ahora usted deberia hacer esto cada vez que termine de
leer la pantalla
Note que se sobrelapan dos líneas cuando usted se mueve de pantalla en
pantalla; esto proveé una continuidad para que pueda seguir leyendo el
texto.
La primera cosa que necesita saber es como moverse de un lugar a otro en
el texto. Usted ya sabe como adelantar una pantalla con C-v. Para mover
atras una pantalla oprima M-v (mantega oprimida la tecla META y digite v,
o presione <ESC>v si no tiene las teclas META, EDIT o ALT).
>> Intente oprimir M-v y luego C-v, varias veces.
* RESUMEN
---------
Los siguentes comandos son útiles para ver pantallas completas:
C-v Avanzar una pantalla completa
M-v Retroceder una pantalla completa
C-l Limpiar la pantalla y mostrar todo el texto de nuevo,
moviendo el texto alrededor del cursor al centro de la
pantalla (Esto es control-L, no control-1.)
>> Encuentre el cursor,y note cual texto está cerca a este.
Luego oprima C-l.
Encuentre el cursor otra vez y note que el mismo texto está cerca al
cursor ahora.
* MOVIMIENTO BÁSICO DE CURSOR
-----------------------------
Moverse de una pantalla completa a otra es útil, pero cómo moverse a
un lugar específico dentro del texto en la pantalla?
Hay varias formas para que pueda hacerlo. La forma más básica es usar los
comandos C-p, C-b, C-f, y C-n. Cada uno de estos comandos mueve el cursor
una fila o columna en una dirección particular en la pantalla.
Aquí hay una tabla mostrando estos cuatro comandos y las direcciones en
que ellos mueven
Línea Anterior, C-P
:
:
Atrás, C-b.... Posición actual del cursor .... Adelante, C-f
:
:
Línea siguiente, C-n
>> Mueva el cursor a la línea en la mitad del diagrama
usando C-n o C-p. Luego presione C-l para ver el
diagrama completo centrado en la pantalla.
Usted probablemente encontrará fácil recordarlos mediante las letras
P de Previous (anterior), N de Next (siguiente), B de Backward (atrás)
y F de Forward (adelante).
Estos son los comandos básicos de posicionamiento del cursor y estará
usándolos TODO el tiempo, serán de gran beneficio si los aprende a usar
ahora.
>> Presione unas veces C-n para traer el cursor a esta línea.
>> Muévase en la línea con C-f y hacia arriba con C-p.
Observe lo que hace C-p cuando el cursor está en la mitad de la línea.
Cada línea de texto termina con un caracter de nueva línea, esto sirve
para separarla de la siguiente línea. La última línea en su archivo debe
tener una nueva línea al final (pero Emacs no requiere que esta lo tenga).
>> Intente usar C-b al comienzo de una línea. Debería moverse al
final de la línea previa. Esto es porque retrocede antes del caracter
de nueva línea.
C-f puede moverse por una nueva línea justo como C-b.
>> Presione algunas C-b más para que entienda donde se encuentra el cursor.
Luego presione C-f para retornar al final de la línea.
Al final presione una vez mas C-f para moverse a la siguiente línea.
Cuando pase el tope o el final de la pantalla, el texto más alla del borde
de la pantalla se mostrará. Esto es llamado "desplazamiento" Esto le
permite a Emacs mover el cursor al lugar especificado en el texto sin
moverlo fuera de la pantalla.
>> Intente mover el cursor fuera del borde de la pantalla con C-n y
observe qué pasa.
Si moverse por caracteres es muy lento, se puede mover por palabras. M-f
(META-F) mueve adelante una palabra y M-b mueva atrás una palabra.
>> Oprima unas veces M-f y M-b
Cuando está en la mitad de una palabra, M-f mueve al final de la palabra.
Cuando está en un espacio entre dos palabras, M-f mueve al final de la
siguiente palabra. M-b trabaja de la misma forma en la dirección opuesta.
>> Oprima unas veces M-f y M-b, intercale con C-f y C-b de tal forma que
observe la acción de M-f y M-b desde varios sitios dentro y entre
palabras.
Note el paralelo entre C-f y C-b de un lado y M-f y M-b del otro.
Muy frecuentemente los caracteres Meta son usados para operaciones
relacionadas, con las unidaes definidas por el lenguaje
(palabras, oraciones y parrafos), mientras los caracteres Control operan
sobre unidades que son independientes de lo que usted está
editando (caracteres, líneas, etc).
Este paralelo se aplica entre líneas y oraciones: C-a y C-e para moverse
al comienzo o al final de la línea; y M-a y M-e para mover al comienzo o
al final de una oración.
>> Intente unas veces C-a, y a continuación C-e.
>> Intente unos M-a, y otros M-e.
Mire cómo la repeticion de C-a no hace nada, pero la repeticion de M-a
sigue moviendo una oración adelante, aunque no son muy análogas, cada una
parece natural.
La localización del cursor en el texto es también llamada "punto", en
otras palabras el cursor muestra sobre la pantalla donde esta el punto
localizado dentro del texto.
Aquí hay un resumen de operaciones simples del movimiento del cursor,
incluyendo los comandos de movimiento en oracion y palabra:
C-f Moverse adelante un caracter
C-d Moverse atrás un caracter
M-f Moverse adelante una palabra
M-b Moverse atrás una palabra
C-n Moverse a la línea siguiente
C-p Moverse a la línea anterior
C-a Moverse al comienzo de la línea
C-e Moverse al final de la línea
M-a Moverse al comienzo de la oración
M-e Moverse al final de la oración
>> Pruebe todos estos comandos unas veces para practicar.
Estos comandos son los usados más frecuentemente.
Otros dos comandos de movimiento del cursor importantes son M-< (Meta
Menor que), el cual se mueve al comienzo del texto entero, y M->( Meta
Mayor que), el cual se mueve al final del texto entero.
En la mayoría de terminales, el "<" está sobre la coma, por lo tanto usted
puede usar la tecla shift para generarlo. En estas terminales usted podrá
usar la tecla shift también al teclear M-<; sin la tecla shift, usted
estaría escribiendo M-coma.
>> Ahora pruebe M-<, para moverse al comienzo del tutorial.
A continuación use C-v repetidamente para regresar aquí.
>> Ahora pruebe M->, para moverse el final del tutorial.
Después use M-v repetidamente para regresar aquí.
También puede mover el cursor con las teclas de la flecha si su
terminal tiene teclas de flecha. Recomendamos aprender C-b, C-f,
C-n y C-p por tres razones. Primero, ellos funcionan en todo tipo de
terminales. Segundo, una vez usted gane práctica usando Emacs, usted
encontrará que teclear estos caracteres Control es más rápido que
usar teclas de flecha ( porque no tendrá que retirar sus manos de
la posición para teclear). Tercero, una vez tenga el hábito de usar
estos comandos Control, también puede aprender fácilmente a usar otros
comandos avanzados de movimiento de cursor.
La mayoría de comandos de Emacs aceptan un argumento númerico; para
la mayoría de comandos esto sirve como un factor de repetición. La manera que
a un comando usted da un factor de repetición es tecleando C-u y luego los
dígitos antes de introducir los comandos. Si usted tiene una tecla META
( o EDIT o ALT), hay una manera alternativa para ingresar un argumento
númerico: teclear los dígitos mientras presiona la tecla META.
Recomendamos aprender el método C-u porque este funciona en cualquier terminal.
El argumento númerico es también llamado un "argumento prefijo", porque usted
teclea el argumento antes del comando al que se aplica.
Por ejemplo, C-u 8 C-f mueve hacia adelante ocho caracteres.
>> Pruebe usar C-n o C-p con un argumento númerico, para mover el cursor
a una línea cerca a esta con solo un comando.
La mayoría de comandos usan argumentos numéricos como un factor de repetición,
pero algunos comandos lo usan de otra forma. Varios comandos (pero ninguno
de los que ha aprendido hasta ahora) usan esto como una marca -- la
presencia de un argumento prefijo, sin tener en cuenta su valor, hace
que el comando actúe de forma diferente.
C-v y M-v son otro tipo de excepción. Cuando se les da un argumento,
ellos desplazan la pantalla arriba o abajo esa cantidad de líneas, en vez
de una pantalla completa. Por ejemplo, C-u 8 C-v desplaza la pantalla 8
líneas.
>> Pruebe tecleando C-u 8 C-v ahora.
Este debió haber desplazado la pantalla hacia arriba 8 líneas.
Si usted quisiera desplazarla hacia abajo de nuevo, usted puede dar un
argumento a M-v.
Si usted esta usando X Window, debe haber una área rectangular larga
llamada una barra de desplazamiento al lado izquierdo de la ventana de
Emacs. Usted puede desplazar el texto al oprimir el boton del mouse en la
barra de desplazamiento.
>> Pruebe presionando el botón del medio en la parte superior del area
resaltada en la barra de desplazamiento. Este debe desplazar el texto a
una posición determinada por cuán alto o bajo oprima el botón.
>> Intente mover el mouse arriba y abajo, mientras mantiene el botón el
medio presionado. Usted verá que el texto se desplaza arriba y abajo
a medida que mueve el mouse.
* CUANDO EMACS ESTÁ BLOQUEADO
-----------------------------
Si Emacs deja de responder a sus comandos, usted puede detenerlo con
seguridad al teclear C-g. Puede usar C-g para detener un comando
que está tomando mucho tiempo para ejecutarse.
También puede usar C-g para descartar un argumento númerico o el comienzo
de un comando que usted no quiere finalizar.
>> Escriba C-u 100 para hacer un argumento númerico de 100, entonces
pruebe C-g. Ahora pruebe C-f. Esto deberá mover sólo un caracter, ya
que usted canceló el argumento con C-g.
Si usted ha digitado <ESC> por error, usted puede desecharlo con un C-g.
* COMANDOS DESACTIVADOS
-----------------------
Algunos comandos de Emacs son "desactivados" de manera que los usuarios
principiantes no puedan usarlos por accidente.
Si usted prueba uno de los comandos desactivados, Emacs muestra un mensaje
informando cuál comando era, y preguntándole si usted quiere continuar y
ejecutar el comando.
Si usted realmente quiere intentar el comando, oprima espacio como repuesta
a la pregunta. Normalmente, si usted no quiere ejecutar el comando
desactivado, conteste la pregunta con "n".
>> Escriba C-x C-1 (que es un comando desactivado), a continuación escriba
n para responder la pregunta.
* VENTANAS
----------
Emacs puede tener varias ventanas, cada una mostrando su propio texto.
Explicaremos después como usar múltiples ventanas. Ahora queremos
explicar cómo deshacerse de ventanas adicionales y volver a la edición
básica en una ventana. Es sencillo:
C-x 1 Una ventana (i.e., elimina todas las otras ventanas).
Esto es Control x seguido por el digito 1. C-x 1 expande la ventana que
contiene el cursor, para ocupar toda la pantalla. Esto borra todas las
otras ventanas.
>> Mueva el cursor a esta línea y escriba C-u 0 C-l.
>> Escriba Control-h k Control-f.
Mire como esta ventana se encoge, mientras una nueva aparece y
muestra documentacion sobre el comando Control-f.
>> Escriba C-x 1 y vea la ventana de listado de documentación desaparecer.
Este comando es diferente a los otros comandos que usted ha aprendido en
que este consiste de dos caracteres. Este comienza con el caracter Control-x.
Hay toda una serie de comandos que comienzan con Control-x; muchos de
ellos tienen que ver con ventanas, archivos, buffers y cosas
relacionadas. Estos comandos son de una longitud de dos, tres o cuatro
caracteres.
* INSERTANDO Y BORRANDO
-----------------------
Si usted quiere insertar un texto sólo escribalo. Los caracters que
usted puede ver, tales como A, 7, *, etc. Son tomados por Emacs como texto
e insertados inmediatamente. Oprima <Return> (la tecla Enter) para
insertar un caracter de nueva línea.
Usted puede borrar el último caracter que escribió oprimiendo <Delete>.
<Delete> es una tecla, que puede estar marcada como "Del". En algunos
casos la tecla "Backspace" sirve como <Delete>, ¡pero no siempre!
Generalmente <Delete> borra el caracter inmediatamente anterior a la
posición actual del cursor.
>> Haga esto ahora -- Teclee unos pocos caracteres, y bórrelos con
la tecla <Delete>. No se preocupe si este archivo cambia, no alterará
el tutorial principal. Esta es su copia personal.
Cuando una línea de texto se hace muy grande para una sola línea en la
pantalla, la línea de texto es "continuada" en una segunda línea. Un
backslash ("\") en el margen derecho indica que la línea ha sido
continuada.
>> Inserte texto hasta que llegue al margen derecho, y siga insertando.
Verá a continuación aparecer una línea.
>> Use <Delete> para borrar el texto hasta que la línea de nuevo quepa
en la pantalla. La línea de continuación se pierde.
Puede borrar un caracter de Nueva línea justo como cualquier otro
caracter. Al borrar un caracter de Nueva línea entre dos líneas
las combina en una sola. Si el resultado de la combinación de líneas es
demasiado largo para caber en el ancho de la pantalla, será mostrada
una línea de continuación.
>> Mueva el cursor al comienzo de una línea y oprima <Delete>. Esto
unirá esta línea con la anterior.
>> Oprima <Return> para reinsertar la nueva línea que borró.
Recuerde que a la mayoría de los comandos de Emacs se les puede dar un
factor de repetición, esto incluye caracteres de texto. Repetir un
caracter de texto lo inserta varias veces.
>> Ahora trate esto -- teclee C-u 8 * para insertar ********.
Usted ha aprendido la manera más básica de teclear algo en Emacs
y corregir errores. Puede borrar por palabras o por líneas. Este es un
resumen de las operaciones de borrado:
<Delete> borra el caracter justo antes que el cursor
C-d borra el siguiente caracter después del cursor
M-<Delete> Elimina la palabra inmediatamente antes del cursor
M-d Elimina la siguiente palabra antes del cursor
C-k Elimina desde el cursor hasta el fin de la línea
M-k Elimina hasta el final de la oración actual.
Note que <Delete> y C-d contra M-<Delete> y M-d extienden el paralelo
iniciado por C-f y M-f (bien, <Delete> no es realmente una tecla de
control, pero no nos preocuparemos ahora por eso). C-k y M-k son como
C-e y M-e, en ciertas forma, en que las líneas son oraciones opuestas.
También puede eliminar cualquier parte del buffer con un método uniforme.
Muevase a un extremo de esa parte, y digite C-＠ o C-SPC (cualquiera de
los dos). Muévase al extremo de esa parte y teclee
C-w. Eso elimina todo el texto entre las dos posiciones.
>> Mueva el cursor a la letra T al inicio del párrafo anterior.
>> Teclee C-SPC. Emacs debe mostrar el mensaje "Mark set" en la parte de
abajo de la pantalla.
>> Mueva el cursor a la x en "extremo", en la segunda línea del parrafo.
>> Teclee C-w. Esto eliminará el texto que comienza desde la T, y
termina justo antes de la x.
Cuando usted borra más de un caracter a la vez, Emacs salva el texto
borrado de manera que usted lo puede recuperar. Recuperar el texto se
llamará "yanking". Usted puede recuperar el texto eliminado en el
lugar donde fue eliminado, o en otro lugar en el texto. Usted puede
recuperar el texto varias veces para hacer múltiples copias de este. El
comando para recuperar es C-y.
Note la diferencia entre "Eliminar" y "Borrar" las cosas que "elimina"
pueden ser recuperadas y las que "borra" no. Generalmente,
los comandos que pueden remover mucho texto lo salvan, mientras los
comandos que borran sólo un caracter, o líneas y espacios, no salvan el
texto borrado.
>> Mueva el cursor al comienzo de una línea que no esté desocupada. Luego
digite C-k para eliminar el texto de esa línea.
>> Oprima C-k por segunda vez. Usted verá que elimina la nueva
línea que sigue a esa.
Note que al oprimir C-k una sola vez elimina el contenido de la línea , y
un segundo C-k elimina la línea misma, y hace que todas las otras líneas
se muevan hacia arriba. C-k trata un argumento numérico especialmente:
Elimina ese número de líneas y sus contenidos. Esto no es una simple
repetición. C-u 2 C-k elimina dos líneas y sus nuevas líneas, tecleando
C-k dos veces no hace esto.
Para recuperar el último texto eliminado y ponerlo donde el cursor
actualmente está, oprima C-y
>>Inténtelo; oprima C-y para recuperar el texto.
Piense en C-y como si estuviera recuperando algo que alguien le quitó. Note
que si usted hace varias C-k seguidas, todo lo que ha sido eliminado del
texto se salva junto, de manera que un C-y recuperará todas las líneas.
>>Haga esto ahora, oprima C-k varias veces.
Ahora para recuperar ese texto eliminado:
>> Teclee C-y. Entonces baje el cursor unas pocas líneas y oprima C-y de
nuevo. Ahora sabe como copiar un texto.
Qué hacer si usted tiene algún texto que quiere recuperar, pero elimina
otro antes de recuperarlo? C-y recuperaría la eliminación más reciente,
pero el texto previo no está perdido. Puede regresar a éste usando el
comando M-y. Después de haber tecleado C-y para conseguir la eliminación
más reciente, escribiendo M-y reemplaza el texto recuperado con la
eliminación previa. Tecleando M-y una y otra vez traerá las
eliminaciones anteriores. Cuando usted ha encontrado el texto que
buscaba, usted no tiene que hacer nada para conservarlo.Sólo siga con
su edición, dejando el texto recuperado donde está.
Si usted digita M-y suficientes veces, usted regresa al punto inicial
(la eliminación más reciente)
>> Elimine una línea muévase, elimine otra línea.
Luego oprima C-y para recuperar la segunda línea eliminada.
Entonces oprima M-y, y será reemplazada por la primera línea eliminada.
Oprima más veces M-y y vea lo que sucede. Siga haciéndolo hasta que la
segunda línea eliminada regrese, y entonces unas pocas más. Si usted
quiere, puede tratar de darle a M-y argumentos positivos y negativos.
* DESHACER
----------
Si hace un cambio al texto, y luego decide que fue un error,
puede deshacer el cambio con el comando deshacer C-x u.
Normalmente, C-x u deshace los cambios hechos por un comando; si repite
varias veces seguidas C-x u, cada repetición deshará un comando
adicional.
Pero hay dos excepciones: comandos que no cambian el texto no cuentan
(esto incluye los comandos de movimiento del cursor y el comando de
desplazamiento), y los caracteres de autoinserción son usualmente manejados
en grupos de hasta 20 (estos es para reducir el numero de C-x u que tiene que
realizar para deshacer una inserción en el texto).
>> Elimine esta línea con C-k, después C-x u debería reaparecerla.
C-_ es un comando alterno para deshacer, este trabaja igual que C-x u,
pero es más facil de usar varias veces seguidas. La desventaja
de C-_ es que en algunos teclados no es obvio como se genera. Por esto
proveemos C-x u también. En algunas terminales, usted puede oprimir C-_
al digitar / mientras oprime CONTROL.
Un argumento numérico para C-_ o C-x u actúa como un factor de repetición.
* ARCHIVOS
----------
Para hacer permanente el texto que edite, lo debe colocar en un
archivo. De otra manera, este se se perderá cuando cierre Emacs.
Para poder poner su texto en un archivo, usted debe "encontrar" el
archivo antes de ingresar el texto (esto también es llamado "visitar"
el archivo.)
Encontrar un archivo significa que usted puede observar su contenido
dentro de Emacs. Esto de cierta forma, es como si usted estuviera editando
el archivo. Aunque los cambios que usted haga usando Emacs no serán
permanentes hasta que "salve" el archivo. Esto es para no dejar un archivo
a medio cambiar en el sistema cuando usted no quiere. Incluso cuando
usted salve, Emacs dejará el archivo original bajo un nombre cambiado en
caso de que luego usted decida que sus cambios fueron un error.
Si mira cerca del final de la pantalla podrá ver una línea que
comienza y termina con guiones, y comienza con "--:-- TUTORIAL" o algo
así. Esta parte de la pantalla normalmente muestra el nombre del archivo
que está visitando. En este momento usted está visitando un archivo
llamado "TUTORIAL" que es su borrador personal del tutorial de Emacs. Cuando
encuentre un archivo con Emacs, el nombre del archivo aparecerá en ese
mismo sitio.
Una cosa especial acerca del comando para encontrar un archivo, es que
usted tendrá que decir cual archivo desea. Decimos que el comando
"lee un argumento desde la terminal" (en este caso, el argumento es
el nombre del archivo). Despues de generar el comando:
C-x C-f Encontrar un archivo
Emacs le pide que digite el nombre del archivo. El nombre de archivo que
digite aparecerá en la línea final de la pantalla. A la línea final de la
pantalla se le denomina minibuffer cuando es usada para este tipo de entradas.
Puede usar comandos de edición ordinarios de Emacs para editar el nombre
del archivo.
Cuando está ingresando el nombre del archivo (o cualquier otra
información al minibuffer) usted puede cancelar el comando con C-g.
>> Oprima C-x C-f, luego oprima C-g. Esto cancela el minibuffer y
también cancela el comando C-x C-f que estaba usando el
minibuffer. Así que no encontrará archivo alguno.
Cuando usted haya finalizado de ingresar el nombre del archivo, oprima
<Return> para terminarlo. Entonces el comando C-x C-f trabaja y encuentra
el archivo que usted escogió. El minibuffer desaparece cuando el comando
C-x C-f termina.
Después aparece el contenido del archivo en la pantalla y usted puede editarlo.
Cuando quiera hacer cambios permanentes, teclee el comando
C-x C-s Salvar el archivo
Este copia el texto de Emacs al archivo. La primera vez que usted haga
esto, Emacs renombrará el archivo original con un nuevo nombre para que
este no se pierda. El nuevo nombre se obtendrá adicionándo "~"
al final del nombre del archivo original.
Cuando la operación de salvar haya terminado, Emacs mostrará el
nombre del archivo escrito. Usted debería salvar frecuentemente, para que
no pierda mucho trabajo si el sistema deja de funcionar.
>> Presione C-x C-s, salvando la copia del tutorial. Esto debería
imprimir "Wrote...TUTORIAL" al final de la pantalla.
NOTA: En algunos sistemas, oprimir C-x C-s dejará inmóvil la pantalla y
usted no podrá ver más respuesta de Emacs. Esto indica que una
"característica" del sistema operativo llamada ''control de flujo''
está interceptando el comando C-s y no permitiéndole llegar a Emacs.
Para descongelar la pantalla, presione C-q. Entonces consulte la sección
"entrada espontánea para búsqueda incremental'' en el manual de
Emacs para encontrar información de cómo tratar con esta "característica".
Usted puede encontrar un archivo existente para verlo o editarlo,
también puede hacerlo con un archivo que no existe. Esta es la forma
de crear un archivo en Emacs: encuentre el archivo, comenzará vacio, luego
comience a introducir el texto al archivo. Cuando invoque "salvar" el archivo,
Emacs creará realmente el archivo con el texto que introdujo. Desde ahí,
usted puede considerarse estar editando un archivo existente.
* BUFFERS
---------
Si visita un segundo archivo con C-x C-f, el primer archivo permanece en
Emacs. Usted puede volver al primer encontrándolo de nuevo con C-x C-f. De
esta forma usted puede mantener un gran número de archivos en Emacs.
>> Cree un archivo llamado "foo" presionando C-x C-f foo <Return>
luego inserte algún texto, edítelo, y salve "foo" presionando C-x
C-s. Finalmente presione C-x C-f TUTORIAL <Return> para regresar al
tutorial.
Emacs almacena cada archivo de texto dentro de un objeto llamado
"buffer". Al encontrar un archivo se crea un nuevo buffer dentro de
Emacs. Para mirar la lista de los buffers que existen actualmente en
su sesión de Emacs, presione:
C-x C-b Lista de Buffers
>> Intente ahora C-x C-b.
Mire como cada buffer tiene un nombre, y ademas puede tener un nombre de
archivo para el archivo que contiene. Algunos Buffers no corresponden a
archivos; por ejemplo, el buffer llamado "*Buffer List*" no tiene ningún
archivo. Este es el buffer que tiene la lista de buffers que fue creado
por C-x C-b. CUALQUIER archivo de texto que vea en una ventana de Emacs,
es siempre parte de algún Buffer.
>> Presione C-x 1 para deshacerse de la lista de buffers.
Si usted hace cambios al texto de un archivo, y luego encuentra otro
archivo, esto no salva el primer archivo. Estos cambios permanecerán
dentro de Emacs en el buffer del archivo. La creación o edición del
segundo buffer de archivo no afecta al primero. Esto es muy útil pero
significa que necesita una forma conveniente para salvar el archivo del
primer buffer. Sería una molestia tener que volver a este con C-x
C-f para salvarlo con C-x C-s así que tenemos
C-x s Guardar algunos buffers
C-x s le pregunta sobre cada buffer que contenga cambios que usted no
ha salvado. Le pregunta por cada buffer si salvarlo o no.
>> Inserte una línea de texto, y teclee C-x s.
Esto debería preguntarle si desea salvar el buffer llamado TUTORIAL.
Conteste si a la pregunta presionando "y".
* EXTENDIENDO EL CONJUNTO DE COMANDOS
-------------------------------------
Hay muchísimos más comandos de Emacs que podrían ser posiblemente
puestos en todos los caracteres control y meta. Emacs puede lograrlo
usando el comando X (eXtendido). Este viene de dos formas:
C-x Caracter eXtendido seguido por un caracter.
M-x Comando eXtendido por nombre. Seguido por un nombre largo.
Estos comandos son generalmente útiles pero usados menos que los
comandos que usted hasta ahora ha aprendido. Hasta ahora ha visto dos
de estos: los comandos de archivo C-x C-f para encontrar y C-x C-s
para salvar. Otro ejemplo es el comando para terminar la sesión de
Emacs -- este es el comando C-x C-c ( no se preocupe por perder los
cambios que usted haya hecho; C-x C-c ofrece salvar cada archivo alterado
antes de que este elimine a Emacs.)
C-z es el comando para salir de Emacs *temporalmente*-- para que usted
pueda regresar a la misma sesión de Emacs después.
En sistemas que lo permiten C-z "suspende" Emacs; esto es, se retorna
al shell pero no se destruye Emacs. En los shells más comunes, usted
puede reanudar Emacs con el comando `fg' o con `%emacs'.
En sistemas que no se implemente el suspendido, C-z crea un subshell
que corre bajo Emacs para darle la opción de correr otros programas y
regresar a Emacs después; esto en realidad no "sale" de Emacs. En este
caso, el comando shell `exit' es la vía usual para regresar a Emacs
desde el subshell.
El momento para usar C-x C-c es cuando usted está listo para salir.
Es además el paso correcto para salir de Emacs llamado bajo programas de
manejo de correo y otra variedad de utilidades, puesto que ellos no
saben cómo lidiar con la suspensión de Emacs. En circunstancias normales,
si usted no va a salir, es mejor suspender Emacs con C-z en lugar de
salir de este.
Existen varios comandos C-x. Aqui hay una lista de algunos que usted
ha aprendido:
C-x C-f Encontrar archivo.
C-x C-s Salvar archivo.
C-x C-b Lista de buffers.
C-x C-c Salir de Emacs.
C-x 1 Borrar todo menos una ventana.
C-x u Deshacer.
Los comandos llamados eXtendidos son comandos usados con menos frecuencia
o comandos que son usados únicamente en ciertos modos. Un ejemplo es
el comando replace-string, el cual globalmente reemplaza una cadena
con otra. Cuando usted teclea M-x, Emacs le pregunta al final de la
pantalla con M-x y usted debe escribir el nombre del comando; en este
caso "replace-string". Solo escriba "repl s<TAB>" y Emacs completará
el nombre. Finalice el nombre del comando con <Return>.
El comando replace-string requiere dos argumentos -- la cadena a
reemplazar, y la cadena para reemplazarla. Usted debe terminar cada
argumento con <Return>.
>> Mueva el cursor hacia la línea en blanco dos líneas debajo de esta. A
continuación escriba
M-x repl s<Return>cambiado<Return>alterado<Return>.
Note cómo esta línea ha cambiado: usted reemplaza la palabra
c-a-m-b-i-a-d-o con "alterado" en cada ocurrencia, después de la
posición inicial del cursor.
* AUTO SALVADO
--------------
Cuando usted ha hecho cambios en un archivo, pero usted no ha salvado
estos todavía, estos podrían perderse si su sistema deja de funcionar. Para
protegerlo de esto, Emacs periódicamente escribe un archivo "auto salvado"
para cada archivo que usted está editando. El nombre del
archivo auto salvado tiene un # al principio y al final; por ejemplo, si su
archivo se llama "hola.c", su archivo auto salvado es "#hola.c#". Cuando
usted salva por la vía normal, Emacs borra su archivo de auto salvado.
Si el sistema deja de funcionar usted puede recuperar su edición de
auto salvado encontrando el archivo normal (el archivo que estuvo editando,
no el archivo de auto salvar) y entonces presionando M-x recover file<Return>.
Cuando le pregunte por la confirmación, teclee yes<Return> para ir y
recuperar la información del auto-salvado.
* AREA ECO
----------
Si Emacs ve que usted está presionando comandos de multicaracteres
lentamente, este le muestra estos al final de la pantalla en un área
llamada "área de eco". El área de eco contiene la línea final de la pantalla.
* LÍNEA DE MODO
---------------
La línea inmediatamente encima del área de eco es llamada el "línea de modo"
dice algo así:
--:** TUTORIAL (Fundamental)--l730--58%---------
Esta línea da información útil acerca de el estado de Emacs y del
texto que usted está editando.
Usted ya sabe qué significa el nombre del archivo -- este es el
archivo que usted ha encontrado. --NN%-- indica posición actual en el
texto; esto significa que NN porciento del texto está encima de la
parte superior de la pantalla. Si el principio del archivo está en la
pantalla, este dirá --Top-- en vez de --00%--. Si el final del texto está
en la pantalla, este dirá --Bot--. Si usted está mirando un texto tan
pequeño que cabe en la pantalla, el modo de línea dirá --All--.
La L y los dígitos indican la posición de otra forma: ellos dan el
número de línea actual del punto.
Las estrellas cerca del frente significan que usted ha hecho cambios
al texto. Exactamente despues de que usted visite o salve un archivo,
esa parte del modo de línea no muestra estrellas, solo los guiones.
La parte del modo de línea dentro de los paréntesis es para indicarle
en qué modo de edición está usted. El modo por defecto es Fundamental,
el cual es el que usted está usando ahora. Este es un ejemplo de un
"modo mayor".
Emacs tiene diferentes modos mayores. Algunos de estos están
hechos para editar diferentes lenguajes y/o clases de texto, tales como
modo Lisp, modo de Texto, etc. En cualquier momento solamente un modo
mayor está activo, y su nombre se encuentra siempre en el modo
de línea donde "Fundamental" está ahora.
Cada modo mayor hace que algunos comandos actúen diferente
por ejemplo, hay comandos para crear comentarios en un programa, y como
cada lenguaje de programación tiene una idea diferente de cómo debe verse
un comentario, cada modo mayor tiene que insertar comentarios de
forma distinta. Cada modo mayor es el nombre de un comando
extendido, que es como usted puede cambiar a ese modo. Por ejemplo,
M-x fundamental-mode es un comando para cambiar al modo fundamental.
Si usted va a editar un texto en español, tal como este archivo,
probablemente tendrá que usar el modo de texto.
>> Teclee M-x text-mode<Return>.
No se preocupe, ninguno de los comandos de Emacs que ha aprendido cambia
de manera significativa. Pero usted puede ver que M-f y M-b tratan a los
apóstrofes como parte de las palabras. Previamente, en modo Fundamental,
M-f y M-b trataban los apóstrofes como separadores de palabras.
Los modos mayores usualmente hacen cambios sutiles como el
anterior: La mayoría de comandos hacen "el mismo trabajo" en cada modo
mayor, pero funcionan un poco diferente.
Para ver documentación en su modo mayor actual, teclee C-h m.
>> Use C-u C-v una vez o mas para llevar esta línea cerca de la
parte superior de la pantalla.
>> Teclee C-h m, para ver cómo el modo de texto difiere del modo
Fundamental.
>> Teclee C-x 1 para eliminar la documentación de la pantalla.
Los modos mayores son llamados así porque también hay modos menores.
Los modos menores no son alternativas para los modos mayores, apenas
modificaciones menores de estas. Cada modo menor puede ser activado o
desactivado por si mismo, independiente de todos los otros modos
menores, e independiente de su modo mayor. Entonces usted puede no usar
modos menores, o un modo menor o alguna combinación de varios modos
menores.
Un modo menor que es muy útil, especialmente para editar textos en
inglés, es el modo Auto Fill. Cuando este modo es encendido, Emacs
rompe la línea entre palabras automáticamente cuando quiera que inserte
texto y haga una línea que es bastante ancha.
Usted puede activar el modo Auto Fill al hacer M-x auto fill mode<Return>.
Cuando el modo este activado, usted puede desactivarlo nuevamente usando
M-x autofill mode<Return>.
Si el modo está desactivado, este comando lo activa, y si el modo está
activado, este comando lo desactiva. Decimos que el comando "cambia el
modo".
>> Teclee M-x auto fill mode<Return> ahora. Luego inserte una línea
de "asdf " repetidas veces hasta que la vea dividida en dos líneas.
Usted debe intercalar espacios porque Auto Fill sólo rompe
líneas en espacios.
El margen es usualmente puesto en 70 caracteres, pero usted puede
cambiarlo con el comando C-x f. Usted debe dar el margen deseado
como un argumento numérico.
>> Teclee C-x f con un argumento de 20. (C-u 2 0 C-x f).
Entonces teclee algún texto y vea como Emacs llena con este líneas de
20 caracteres. Entonces ponga de nuevo el margen a 70 usando otra
vez C-x f.
Si usted hace cambios en el medio de un párrafo, el modo Auto Fill no
lo rellenará por usted.
Para rellenar el párrafo, teclee M-q (Meta-q) con el cursor dentro de
ese párrafo.
>>Mueva el cursor al párrafo anterior y teclee M-q.
* BUSCANDO
----------
Emacs puede hacer búsquedas de cadenas (estas son grupos de caracteres
contiguos o palabras) hacia adelante a través del texto o para atrás
en el mismo. La busqueda de una cadena es un comando de movimiento de
cursor; esto mueve el cursor al próximo lugar donde esa cadena aparece.
El comando de búsqueda de Emacs es diferente a los comandos de búsqueda
de los demás editores, en que este es "incremental". Esto significa que
la búsqueda ocurre mientras usted teclea la cadena para buscarla.
El comando para iniciar una búsqueda es C-s para búsqueda hacia adelante,
y C-r para la búsqueda hacia atrás. PERO ESPERE! no intente esto ahora.
Cuando teclee C-s usted verá que la cadena "I-search" aparece como un
llamado en el área de eco. Esto le dice que Emacs está en lo que se
conoce como búsqueda incremental, esperando que usted teclee la cosa que
quiere buscar. <Return> termina una busqueda.
>> Ahora teclee C-s para comenzar la búsqueda. LENTAMENTE, una letra a
la vez, teclee la palabra 'cursor', haciendo pausa después de cada
caracter para notar lo que pasa con el cursor.
Ahora ha buscado "cursor", una vez.
>> Ahora teclee C-s de nuevo, para buscar la próxima aparición de
"cursor".
>> Ahora presione <Delete> cuatro veces y mire como se mueve el cursor.
>> Teclee <Return> para terminar la búsqueda.
Vió lo que ocurrió? Emacs, en una búsqueda incremental, trata de ir a la
ocurrencia de la cadena que usted ha tecleado hasta el momento. Para ir
a la próxima ocurrencia de "cursor" solo teclee C-s de nuevo. Si tal
ocurrencia no existe, Emacs pita y le dice que la búsqueda actual está
fallando (failing). C-g también termina la búsqueda.
NOTA: En algunos sistemas, oprimir C-x C-s dejará inmovil la pantalla y
usted no podra ver más respuesta de Emacs. Esto indica que una
"característica" del sistema operativo llamada ''control de flujo''
está interceptando el comando C-s y no permitiéndole llegar a Emacs.
Para descongelar la pantalla, presione C-q. Entonces consulte la sección
"entrada espontánea para búsqueda incremental'' en el manual de
Emacs para encontrar información de cómo tratar con esta "característica".
Si usted está en medio de una búsqueda incremental y teclea <Delete>,
usted notara que el último caracter de la cadena buscada es borrado y
la búsqueda vuelve al último sitio de la búsqueda. Por ejemplo, suponga
que usted ha tecleado "c", para buscar la primera ocurrencia de "c".
Ahora, si teclea "u", el cursor se moverá a la primera ocurrencia de
"cu". Ahora teclee <Delete>. Esto borra la "u" de la cadena buscada,
y el cursor vuelve a la primera ocurrencia de "c".
Si usted está en medio de una búsqueda y teclea un caracter
control o meta (con algunas pocas excepciones-- los caracteres que son
especiales en una búsqueda, tales como C-s y C-r), la búsqueda es
terminada.
El C-s inicia una exploración que busca alguna ocurrencia de la cadena
buscada DESPUES de la posición actual del cursor. Si usted quiere buscar
algo anterior en el texto, teclee en cambio C-r. Todo lo que hemos
dicho sobre C-s también se aplica a C-r, excepto que la dirección de la
búsqueda es invertida.
* MúLTIPLES VENTANAS
--------------------
Una de las agradables características de Emacs es que usted puede mostrar más
de una ventana en la pantalla al mismo tiempo.
>> Mueva el cursor a esta línea y teclee C-u 0 C-l.
>> Ahora teclee C-x 2 que divide la pantalla en dos ventanas. Ambas
ventanas muestran este tutorial. El cursor permanece en la ventana
superior.
>> Teclee C-M-v para desplazar la ventana inferior. (si usted no
tiene una tecla Meta real, teclee ESC C-v)
>> Teclee C-x o ("o" para "otro") para mover el cursor a la ventana
inferior.
>> Use C-v y M-v en la ventana inferior para desplazarla. Siga
leyendo estas direcciones en la ventana superior.
>> Teclee C-x o de nuevo para mover el cursor de vuelta a la ventana
superior. El cursor en la ventana superior está justo donde estaba
antes.
Usted puede continuar usando C-x o Para cambiar entre las ventanas. Cada
ventana tiene su propia posición del cursor, pero únicamente una
ventana actual muestra el cursor. Todos los comandos de edición comunes
se aplican a la ventana en que está el cursor. Nosotros la llamamos
"ventana seleccionada".
El comando C-M-v es muy útil cuando usted está editando un texto en una
ventana y usando la otra ventana como referencia. Usted puede mantener
el cursor siempre en la ventana donde está editando, y avanzar a la
otra ventana secuencialmente con C-M-v.
C-M-v es un ejemplo de un carácter CONTROL-META. Si usted tiene una
tecla Meta real, usted puede oprimir C-M-v Sosteniendo a la vez CONTROL
y META mientras oprime v. No importa cual tecla oprima primero CONTROL o META.
Porque las dos teclas actúan modificando los caracteres que usted digita.
Si usted no tiene una tecla META real, y en vez de esta usa ESC, el
orden importa: usted debe digitar ESC seguido de Control-v, porque
Control-ESC v no trabajará. Esto es porque ESC es un carácter que tiene
valor en sí mismo, no es una tecla modificadora.
>> digite C-x 1 (en la parte de arriba de la ventana) para deshacerse
de la ventana del final.
(Si usted hubiera digitado C-X 1 en la ventana inferior, esto eliminaría la
superior. Piense en este comando como "mantener sólo una ventana -- la
ventana en la cual estoy".)
Usted no tiene que mostrar el mismo buffer en ambas ventanas. Si usted
usa C-x C-f para encontrar un archivo en una ventana, la otra ventana
no cambia. Usted puede encontrar un archivo en cada ventana
independientemente.
Aquí hay otra forma para usar dos ventanas para mostrar dos cosas
diferentes:
>> Digite C-x 4 C-f seguido del nombre de uno de sus archivos.
Finalice con <Return>. Vea que el archivo especificado aparece en la
ventana inferior. El cursor vá allá también.
>> Digite C-x o para regresar a la ventana superior, y C-x 1 para borrar
la ventana inferior.
* NIVELES RECURSIVOS DE EDICIÓN
--------------------------------
Algunas veces usted entrará a lo que es llamado un "nivel recursivo
de edición". Esto está indicado por paréntesis cuadrados en la línea de modo
, rodeando los paréntesis del nombre del modo mayor. Por ejemplo,
usted probablemente vea [(Fundamental)] en vez de (Fundamental)
Para salir de los niveles recursivos de edición, presione ESC ESC ESC.
Este es un comando de "salida" para todo propósito. Usted también lo
puede usar para eliminar ventanas extras, y salir del minibuffer.
>> Digite M-x para entrar a un minibuffer; Entonces digite ESC ESC ESC
para salir.
Usted no puede usar C-g para salir de los "niveles recursivos de
edición". Esto es porque C-g es usado para cancelar comandos y
argumentos DENTRO del nivel recursivo de edición.
* CONSIGUIENDO MAS AYUDA
------------------------
En este tutorial hemos tratado de ofrecer suficiente información para
que usted empiece a usar Emacs. Hay tanto disponible en Emacs que
sería imposible explicar todo aquí, sin embargo, usted puede querer
aprender más sobre Emacs, ya que este tiene muchas otras características
útiles. Emacs provee comandos para leer documentación acerca de los
comandos de Emacs. Estos comandos de "ayuda" todos comienza con el
caracter Control-h, que es llamado el caracter de ayuda (help).
Para usar las características de ayuda, digite el caracter C-h, y
entonces un carácter diciciendo qué tipo de ayuda quiere. Si usted está
REALMENTE perdido digite c-h ? y Emacs le dirá qué tipo de ayuda puede
ofrecerle. Si usted ha digitado C-h y decide que no quiere ninguna
ayuda, digite C-g para cancelarlo.
(Algunos sitios cambian el significado del carácter C-h. Ellos realmente
no deberían hacer esto como una política para todos los
usuarios, así que usted tiene argumentos para quejarse al administrador
del sistema. Mientras tanto, sí C-h no muestra un mensaje de ayuda en
el final de la pantalla, intente digitar la tecla F1 o en su lugar M-x
help <Return>).
La característica más básica en la AYUDA es C-h c. Digite C-h, el
caracter c y un caracter de comando o una secuencia de comando; entonces
Emacs muestra una muy breve descripción del comando.
>> Digite C-h c C-p.
El mensaje debe ser algo como
C-p runs the command previous-line
Esto le dice el "nombre de la función". Los nombres de función son
usados principalmente para adecuar y extender Emacs. Pero ya que los
nombres de las funciones son seleccionados para indicar lo que el comando
hace, ellos tambien pueden servir como una breve documentación --
suficiente para recordarle los comandos que ha aprendido.
Los comandos de múltiples caracteres tales como C-x C-s y (sí usted no
tiene las teclas META o EDIT o ALT) <Esc>v, están permitidos también
después de C-h c.
Para conseguir más información sobre un comando use C-h k en vez de
C-h c.
>> Digite C-h k C-p.
Esto muestra la documentación de la función, al igual que el nombre, en
una ventana de Emacs. Cuando usted haya terminado de leer el resultado,
digite C-x 1 para deshacerse del texto de ayuda. No tiene que hacer esto
ahora. Usted puede hacer algunas ediciones mientras se refiere al texto
de ayuda, y entonces digitar C-x 1.
Aquí hay algunas otras opciones útiles de C-h:
C-h f Describe una función. Usted digita el nombre de la
función.
>> Intente digitar C-h f previous-line<Return>.
Esto imprime toda la información que Emacs tiene sobre la función que
implementa el comando C-p
C-h a Comando Apropos. Digite una palabra y Emacs hará una
lista de todos los comandos que contengan la palabra
digitada. Todos Estos comandos pueden ser invocados con
Meta-x. Para algunos comandos, el comando Apropos
también listará una secuencia de uno a dos caracteres
la cual correrá el mismo comando.
>> Digite C-h a file<Return>.
Esto muestra en otra ventana una lista de todos los comandos M-x con
la palabra "file" en sus nombres. Usted verá comandos de caracteres como
C-x C-f listados además de los nombres de los comandos correspondientes
tales como find-file.
>> Digite C-M-v para desplazar la ventana de ayuda. Haga esto unas pocas
veces.
>> Digite C-x 1 para borrar la ventana de ayuda.
* CONCLUSIÓN
------------
Recuerde, Para salir permanentemente de Emacs use C-x C-c. Para salir a un
Shell temporalmente, de forma que usted puede volver a Emacs después, use C-z.
Este tutorial intenta ser entendible para todos los usuarios
nuevos, así que si encuentra algo confuso, no se siente y se culpe a sí
mismo - quéjese!
* COPIADO
---------
Este tutorial desciende de una larga línea de tutoriales de Emacs
comenzando con el escrito por Stuart Cracraft para el Emacs original.
La versión en español fue traducida por estudiantes del Gimnasio Fidel Cano
(un colegio en Santafé de Bogotá, Colombia):
Carlos Alberto López Troncoso
Andrés Felipe Mancipe Galvis
Lina Fernanda Pinto García
Liliana Carolina Quitián Cedeño
Leonardo Ramírez Vargas <leonardoramirez(a)latinmail.com>
Juan David Vargas Botero <cyberbob1164(a)hotmail.com>
Juan Pablo Yela Gallón
Jorge Enrique Cárdenas Carrillo <platypus_life(a)hotmail.com>
además la versión en español ha sido revisada y corregida por:
Pablo Reyes <reyes_pablo(a)hotmail.com>
Igor Támara <ikks(a)bigfoot.com>
Melissa Giraldo de Támara <melagira(a)yahoo.com>
Vladimir Támara <vtamara(a)gnu.org>
Por favor, en caso de duda, sólo es válido el original en inglés de la
siguiente nota de derechos de reproducción (que puede encontrar en el
archivo TUTORIAL).
Copyright (c) 1985, 1996 Free Software Foundation
Se permite a cualquiera hacer o distribuir copias literales de este
documento como se recibe, en cualquier medio, siempre que la nota de
derechos de reproducción y la nota de permiso se preserven, y que el
distribuidor permita que el que la recibe hacer distribución posterior
como lo permite esta nota.
Se permite distribuir versiones modificadas de este documento, o
porciones de este, bajo las condiciones anteriores, siempre que
ellas tengan nota visible especificando quién fue el último en
alterarlas.
Las condiciones para copiar Emacs mismo son más complejas, pero con el
mismo espíritu. Por favor lea el archivo COPYING y entonces distribuya copias
de GNU Emacs a sus amigos. Ayude a erradicar el obstruccionismo del
software ("propietariedad") usando, escribiendo, y compartiendo software
libre!
Copyright (c) 1985 Free Software Foundation, Inc; Zie de voorwaarden onderaan.
Je leest nu de Emacs uitleg, zoals vertaald door Pieter Schoenmakers.
De meeste Emacs commando's gebruiken de CONTROL toets (soms CTRL of CTL
genaamd) en/of de META toets (soms genaamd EDIT of ALT). In plaats van
steeds de volledige naam te noemen, gebruiken we de volgende afkortingen:
C-<chr> betekent: houd de CONTROL toets ingedrukt en type de toets <chr>
Dus C-f wordt: houd de CONTROL toets ingedrukt en type f.
M-<chr> betekent: houd de META, EDIT of ALT toets ingedrukt en type de
toets <chr>. Als er geen toets META, EDIT of ALT is, kun je ook
eerst de ESC toets typen, gevolgd door <chr>. We refereren aan
de ESC toets als <ESC>.
BELANGRIJK: om Emacs te verlaten, type C-x C-c (twee tekens).
De tekens ">>" tegen de linker kantlijn nodigen je uit om een
bepaald commando te proberen. Bijvoorbeeld:
<<Blank lines inserted here by startup of help-with-tutorial>>
>> Type nu C-v (volgend scherm) om naar het volgende scherm te gaan.
(Geef nu het commando door de control toets ingedrukt te houden
terwijl je de v typt.)
Vanaf nu moet je dit steeds herhalen als je klaar bent met het
lezen van een scherm.
Merk op dat er een tweeregelige overlap is als je van een scherm naar
het volgende scherm gaat; dit zorgt voor continuiteit bij het lezen van
de tekst.
Het eerste wat je moet weten is hoe je naar verschillende plaatsen in de
tekst kan bewegen. Je weet al hoe je een scherm vooruit moet gaan: met
C-v. Om een scherm terug te gaan, type M-v (houd de META toets ingedrukt
en type v, of type <ESC>v als je geen META, EDIT of ALT toets hebt).
>> Probeer nu een paar keer M-v, steeds gevolgd door C-v.
* SAMENVATTING
--------------
De volgende commando's zijn handig volledige schermen te bekijken:
C-v ga een scherm vooruit
M-v ga een scherm terug
C-l maak het scherm schoon en teken alle tekst
opnieuw, waarbij de regel waarop de cursor
staat op het midden van het scherm terecht
komt. (C-l is control-L, niet control-1.)
>> Kijk waar de cursor is en onthoud de tekst in zijn omgeving.
Type C-l.
Zoek de cursor en merk op dat 'ie nog steeds bij dezelfde tekst staat.
* BASISCOMMANDO'S CURSORBEWEGINGEN
----------------------------------
Het is handig om per scherm te bewegen, maar hoe beweeg je nu
naar een specifieke plaats op het scherm?
Er is een aantal manieren waarop je dit kan doen. De basismanier is
m.b.v de commando's C-p, C-b, C-f en C-n. Elk van deze commando's
verplaatst de cursor precies een rij of colomn in een bepaalde richting
op het scherm. Hier volgt een figuur met de vier commando's en de
richting waarin ze de cursor bewegen:
vorige regel, C-p
:
:
achteruit, C-b .... huidige cursorpositie .... vooruit, C-f
:
:
volgende regel, C-n
>> Verplaats, m.b.v. C-n of C-p, de cursor naar de middelste regel van
de figuur. Type dan C-l om de hele figuur in het midden van het
centrum te plaatsen.
Met een beetje kennis van het engels zijn deze commando's gemakkelijk te
onthouden: de P komt van previous (vorige), de N van next (volgende), de
B van backward (achteruit) en de F van forward (vooruit). Dit zijn de
basiscommando's om de cursor te bewegen, dus je zult ze CONTINUE
gebruiken: Het is slim als je ze nu leert te gebruiken.
>> Type een paar keer C-n om de cursor op deze regel te krijgen.
>> Beweeg binnen de regel met C-f (herhaaldelijk) en terug omhoog met C-p
Let op wat C-P doet als de cursor midden in een regel staan.
Elke regel eindigt met een Newline teken (het engelse `new line' betekent
`nieuwe regel'); dit teken scheidt elke regel van de volgende. De laatste
regel in een bestand moet eigenlijk ook met een Newline eindigen (maar dat
is niet noodzakelijk voor Emacs ).
>> Type een C-b terwijl de cursor aan het begin van een regel staat.
De cursor zal naar het eind van de vorige regel bewegen, omdat je
achteruit over het Newline teken gaat.
Net als C-b kan ook C-f over Newline tekens heen bewegen.
>> Type nog wat C-b's zodat je door krijgt waar de cursor is.
Type dan C-f's om terug naar het einde van de regel te bewegen.
Een C-f beweegt dan naar de volgende regel.
Wanneer je de cursor voorbij het begin of het einde van het scherm beweegt
zal de tekst over het scherm heen schuiven. Dit heet `scrollen', of
`schuiven' in goed nederlands. Door te scrollen zorgt Emacs ervoor dat
de cursor de gewenste beweging kan doen zonder dat de cursor van het
scherm af beweegt.
>> Probeer de cursor voorbij de onderkant van het scherm te bewegen met
C-n en zie wat er gebeurt.
Als beweging op karakterbasis te langzaam gaat, kan je ook per woord
bewegen. M-f (Meta-f) beweegt een woord vooruit en M-b een woord
achteruit.
>> Type een paar M-f's en M-b's.
Als je midden in een woord staan beweegt M-f naar het eind van het
woord. Als je op witruimte tussen woorden staat beweegt M-f naar het
eind van het volgende woord. M-b beweegt analoog, de andere kant op.
>> Type een paar M-f's en M-b's met tussendoor wat C-f's en C-b's zodat
je ziet wat M-f en M-b doen vanaf bepaalde plaatsen in een woord en
tussen twee woorden.
Merk op dat er een analogie zit tussen enerzijds C-f en C-b en
anderzijds M-f en M-b. Het is bij veel commando's zo dat Meta tekens
gebruikt worden om iets te doen in eenheden van de taal (woorden,
zinnen, paragrafen) terwijl Control tekens te maken hebben met dingen
die los staan van wat je aan het editen bent (tekens, regels, etc).
Deze analogie gaat ook op voor regels en zinnen: C-a en C-e bewegen naar
het begin of eind van een regel, terwijl M-a en M-e naar het begin of
eind van een zin gaan.
>> Probeer een paar C-a's gevolgd door een paar C-e's.
Probeer een paar M-a's gevolgd door een paar M-e's.
Zie hoe herhaalde C-a's niets doen, terwijl herhaalde M-a's steeds een
zin terug bewegen. Alhoewel ze niet volledig overeenkomen is het gedrag
van allebei niet onnatuurlijk.
De plaats van de cursor in de tekst wordt `punt' genoemd (zonder
lidwoord, `point' in het engels). Anders gezegd: de cursor laat op het
scherm de plek zien waarop punt in de tekst staat.
Nu volgt een samenvatting van eenvoudige cursorbewegingsoperaties,
inclusief die commando's die per woord of zin bewegen:
C-f ga een teken vooruit
C-b ga een teken achteruit
M-f ga een woord vooruit
M-b ga een woord achteruit
C-n ga naar de volgende regel
C-p ga naar de vorige regel
C-a ga naar het begin van de regel
C-e ga naar het eind van de regel
M-a ga terug naar het begin van de zin
M-e ga vooruit naar het eind van de zin
>> Probeer al deze commando's een paar keer als oefening.
Deze commando's worden het frequentst gebruikt.
Er zijn nog twee belangrijk cursorbewegingsoperaties: M-<
(Meta kleiner-dan) beweegt naar het begin van het bestand,
en M-> (Meta groter-dan) beweegt naar het eind.
Op de meeste toetsenborden zit de "<" boven de comma, zodat je de Shift
toets (ook wel bekend als de hoofdlettertoets) moet gebruiken om het "<"
teken in te typen. Op deze toetsenborden moet je ook de shift gebruiken
om M-< in te typen: zonder shift zou je M-, (Meta komma) typen.
>> Type nu M-< om naar het begin van dit bestand te gaan.
Gebruik daarna C-v om hier weer terug te komen.
>> Type nu M-> om naar het eind van het bestand te springen.
Gebruik daarna M-v om hier weer terug te komen.
Als je toetsenbord pijltjestoetsen heeft kan je ook die gebruiken om de
cursor te verplaatsen. We raden je aan om C-b, C-f, C-n en C-p op zijn
minst te leren, om drie redenen. Ten eerste werken ze op alle
toetsenborden, ook die zonder pijltjestoetsen. Ten tweede zul je merken
dat, wanneer je eenmaal wat ervaring hebt opgedaan in omgaan met Emacs,
het gebruik van deze CTRL tekens sneller is dan de pijltjestoetsen (omdat
je handen in de typehouding kunnen blijven). Ten derde, als je eenmaal
gewend bent aan deze commando's met CTRL tekens, kan je makkelijk andere
geavanceerde cursorbewegingscommandos leren.
De meeste Emacs commando's accepteren een numeriek argument. Voor de
meeste commando's is dit argument het aantal keren dat het commando
herhaald moet worden. Je geeft dit numerieke argument aan door voor het
commando, C-u gevolgd door de cijfers van het getal te typen. Als je
toetsenbord een META (of EDIT of ALT) toets heeft, is er ook een andere
manier om het getal aan te geven: type de cijfers terwijl je de META toets
ingedrukt houdt. We raden je aan de C-u manier te leren omdat die werkt
op elk willekeurig toetsenbord.
Bijvoorbeeld, C-u 8 C-f beweegt de cursor 8 plaatsen naar voren.
>> Probeer eens om met C-n of C-p en een numeriek argument de cursor
met slechts een commando naar een regel in de buurt van deze zin
te bewegen.
Voor de meeste commando's is het numerieke argument het aantal keren dat
het commando herhaald moet worden. Voor sommige commando's betekent het
echter iets anders, en C-v en M-v vallen hier ook onder. Met een numeriek
argument verschuiven deze commando's de tekst het aangegeven aantal regels
in plaats van (bijna) een heel scherm. Bijvoorbeeld, C-u 4 C-v verschuift
de tekst 4 regels.
>> Probeer nu C-u 8 C-v.
Als het goed is is de tekst daarmee 8 regels opgeschoven. Als je het weer
terug omlaag wil scrollen kan je een argument aan M-v geven.
Als je een windowing systeem gebruikt, zoals X Windows, dan zou je een
lange rechthoek moeten zien aan de linkerkant van het Emacs window. Deze
rechthoek heet een scrollbar (misschien is `verschuifbalk' een goede
vertaling). Je kan de tekst scrollen door met de muis in de scrollbar te
klikken.
>> Klik met de middelste muisknop bovenaan het donkere gebied in de
scrollbar. Dit zou de tekst moeten scrollen naar een positie die
afhankelijk is van hoe hoog of laag je klikt.
>> Beweeg de muis heen en weer terwijl je de middelste muisknop ingedrukt
houdt. Je zal zien dat de tekst met de muis mee heen en weer scrollt.
* ALS EMACS HANGT
-----------------
Als Emacs niet meer op commando's reageert kan je haar veilig onderbreken
door C-g te typen. Je kan C-g gebruiken om een commando te stoppen als
het te lang duurt om uit te voeren.
Je kan C-g ook gebruiken om een numeriek argument weg te gooien of
om het begin van een commando dat je niet wilt afmaken te vergeten.
>> Type nu C-u 100 om een numeriek argument te maken met de waarde 100, en
type dan C-g. Type vervolgens C-f. Als het goed is is de cursor maar
een positie verplaatst, omdat het argument weggegooid hebt met C-g.
Als je per ongeluk een <ESC> typt kan je daarvan komen met een C-g.
* ONMOGELIJKE COMMANDO'S
------------------------
Sommige Emacs commando's zijn onmogelijk gemaakt zodat beginnende
gebruikers ze niet per ongeluk kunnen uitvoeren.
Als je een van de onmogelijke commando's intypt laat Emacs uitleg zien
over het commando dat je gegeven hebt en vraagt of je het werkelijk uit
wilt voeren.
Wanneer je het commando echt wilt uitvoeren, type dan Spatie (de
spatiebalk) als antwoord op de vraag. Normaliter wil je het commando niet
uitvoeren en beantwoord je de vraag met "n" (van `no' of `nee').
>> Type <ESC> : (een onmogelijk commando),
en type dan n als antwoord op de vraag.
* VENSTERS
----------
Emacs kan meerdere vensters laten zien, elk venster met zijn eigen tekst.
We zullen later uitleggen hoe je met meerdere vensters om kan gaan. Op
dit moment willen we slechts uitleggen hoe je van extra vensters af kunt
komen en terug kan keren naar simpelweg editen met 1 venster. Het is
eenvoudig:
C-x 1 een enkel venster (i.e. gooi alle andere vensters weg)
Het commando is Control-x gevolgd door het cijfer 1. C-x 1 vergroot het
venster waar de cursor in staat tot het hele scherm. Alle andere vensters
worden weggegooid.
>> Zet de cursor op deze regel en type C-u 0 C-l.
>> Type nu Control-h k Control-f.
Zie hoe dit venster kleiner wordt, terwijl een nieuw venster verschijnt
om de documentatie van het Control-f commando te laten zien.
>> Type nu C-x 1 en zie het documentatievenster verdwijnen.
* TOEVOEGEN EN WEGHALEN
-----------------------
Als je tekst toe wilt voegen type je die eenvoudigweg in. Tekens die je
kan zien, zoals A, 7, *, en dergelijke, worden door Emacs als tekst
ge-interpreteerd en meteen aan de tekst toegevoegd. Type <Return> (de
`volgende regel' toets) om een Newline toe te voegen en dus een nieuwe
regel te beginnen.
Je kan het laatste teken dat je intypte weghalen door <Delete> te typen.
<Delete> is een toets op het toetsenbord, die misschien ook wel "Del"
heet. In sommige gevallen dient de "Backspace" toets als <Delete>, maar
niet altijd!
In het algemeen haalt <Delete> het teken dat juist voor de cursorpositie
staat weg.
>> Probeer dit nu: type een paar letters en haal ze weer weg door een paar
keer op <Delete> te drukken. Maak je niet druk over het feit dat dit
bestand verandert; je zal niets veranderen aan de originele versie van
deze uitleg. Je zit slechts je eigen copie te wijzigen.
Als een regel tekst te lang wordt om op een regel op het scherm te laten
zien dan gaat de regel verder op een volgende schermregel. Een backslash
("\") in de rechtermarge laat dan zien dat de regel op de volgende
schermregel verder gaat.
>> Voeg nu tekst toe totdat je de rechter kantlijn raakt, en blijf
toevoegen. Je zal zien dat er een vervolgregel verschijnt.
>> Type weer wat <Delete>s om zoveel tekens weg te halen tot de regel weer
op een schermregel past. De vervolgregel zal verdwijnen.
Je kan een Newline weggooien als elk ander teken. Als je een Newline
weggooit voeg je de twee regels waar de Newline tussen staat samen tot een
enkele regel. Als de regel die het resultaat is van deze operatie niet op
een schermregel past zal ze getoond worden met een vervolgregel.
>> Beweeg de cursor naar het begin van een regel en type <Delete>. Dit
voegt de huidige en vorige regel samen.
>> Type <Return> om de Newline die je net weggooide weer toe te voegen.
Je herinnert je dat je bij de meeste Emacs commando's het aantal keren dat
het herhaald moet worden op kan geven. Dit geldt ook voor gewone tekens.
Als je een gewoon teken herhaalt wordt dat teken herhaaldelijk toegevoegd.
>> Probeer dat nu: type C-u 8 * om ******** toe te voegen.
Je hebt nu de basismanier geleerd om iets in Emacs te typen en fouten te
corrigeren. Je kan tekst ook per woord of regel weggooien. Hier volgt
een samenvatting van de commando's om tekst te verwijderen:
<Delete> haal het teken weg dat voor de cursor staat
C-d haal het teken weg dat achter de cursor staat
M-<Delete> gooi het woord weg dat voor de cursor staat
M-d gooi het woord weg dat achter de cursor staat
C-k gooi alles weg van de cursor tot het eind van de regel
M-k gooi alles weg van de cursor tot het eind van de zin
Merk op dat <Delete> en C-d met M-<Delete> en M-d de analogie die begon
met C-f en M-f verder trekken (waarbij we voor het gemak even vergeten dat
<Delete> niet echt een control teken is). C-k en M-k lijken enigzins op
C-e en M-e in hun relatie tot regels en zinnen.
Als je meer dan een enkel teken tegelijk weghaalt bewaart Emacs de tekst
die je weggooit zodat je haar weer terug kan halen. Weggegooide tekst
terughalen heet "yanken". Je kan weggegooide tekst terugbrengen op de
plaats waar je haar hebt weggegooid of op een andere plaats in de tekst.
Je kan ook meerdere keren yanken om er meedere copi-en van te maken. Het
yank-commando is C-y.
Merk op dat er een verschil is tussen het weghalen en weggooien van iets:
iets dat je hebt weggooid kan je terugbrengen, maar iets dat je hebt
weggehaald niet. (In het engels is het verschil tussen `killing' en
`deleting' duidelijker dan tussen de nederlandse vertaling `weggooien' en
`weghalen'.) In het algemeen geldt dat de commando's die meer tekst dan
een enkel teken, Newline of spatie verwijderen deze tekst bewaren zodat ze
geyankt kan worden, terwijl dat niet geldt voor commando's die slechts een
enkel teken weghalen.
>> Zet de cursor op het begin van een regel die niet leef is.
Type C-k om de tekst op die regl weg te gooien.
>> Type C-k een tweede keer. Nu gooit dit commando het Newline teken
weggooit.
Merk op hoe een enkele C-k de inhoud van een regel weggooit, een tweede
C-k de regel zelf zodat alle volgende regels een regel omhoog komen. Het
numerieke argument is voor C-k bijzonder: het aangegeven aantal regels zal
worden weggegooid, inclusief de inhoud. Dit is meer dan simpelweg
herhaling: C-u 2 C-k gooit twee regels weg, terwijl tweemaal C-k typen dat
niet doet.
Om de laatst weggegooide tekst terug te halen naar de plaats waar de
cursor nu op staat (te yanken), type C-y.
>> Probeer het nu: type C-y om de tekst te yanken.
Het is alsof je met C-y iets uit de prullenbak haalt wat je net had
weggegooid. Merk op dat verschillende C-k's achter elkaar alle regels
die weggegooid worden bij elkaar bewaart zodat een enkele C-y die regels
in een keer terugbrengt.
>> Probeer het nu: type C-k een paar keer.
Om de weggegooide tekst terug te halen:
>> Type C-y. Beweeg de cursor wat regels naar beneden en type weer C-y.
Je ziet nu hoe je tekst kan copieren.
Wat nu te doen als je wat tekst terug wilt brengen, maar je hebt intussen
al iets anders weggegooid? C-y zou datgene terugbrengen wat je het
recentst hebt weggegooid. Gelukkig is de voorgaande tekst niet verloren
gegaan. Je kunt die tekst terughalen met M-y. Nadat je C-y hebt getypt
om de recentst weggegooide tekst terug te halen, vervangt M-y die tekst
met de tekst die je daarvoor had weggegooid. Je kunt M-y herhalen om
tekst terug te halen die je steeds langer geleden hebt weggegooid. Als je
de tekst te pakken hebt die je zocht hoe je niets te doen om die daar te
houden. Je kan gewoon verder werken en de teruggehaalde tekst met rust
laten.
Als je M-y vaak genoeg typt kom je terug waar je begon, bij de recentst
weggegooide tekst.
>> Gooi een regel weg, beweeg de cursor wat, en gooi nog een regel weg.
Type C-y om de tweede regel die je weggooide terug te halen.
Type nog een M-y en die regel wordt vervangen door de eerste regel
die je weggooide.
Type nog wat M-y's en zie wat er langs komt. Herhaal dit tot de
tweede regel weer langs komt, en dan nog een paar keer.
Je kan ook experimenteren met positieve en negatieve argumenten aan
M-y.
* HERSTELLEN
------------
Als je de tekst veranderd hebt en je daar toch niet tevreden mee bent,
dan kan je de verandering ongedaan maken met het herstel commando, C-x u.
Normaal gesproken herstelt C-x u de veranderingen die het gevolg zijn van
een enkel commando; door herhaaldelijk C-x u te typen, worden steeds
eerdere commando's hersteld.
Er zijn echter twee uitzonderingen: commando's die de tekst niet wijzigen,
zoals cursorbewegingen, worden overgeslagen, en commando's die simpelweg
de ingetypte letter aan de tekst toevoegen worden meestal gegroepeerd
in groepjes van maximaal 20 tekens, zodat je minder C-x u's hoeft te
type om het toevoegen van teksts te herstellen.
>> Gooi deze regel weg met C-k; met C-x u zou ze weer moeten verschijnen.
C-_ is een alternatief voor C-x u. Het levert exact hetzelfde resultaat
op, maar is makkelijker om een paar keer achter elkaar te typen. Een
nadeel van C-_ is dat op sommige toetsenborden het intypen ervan niet
triviaal is. Dat is ook de reden het alternatief, C-x u. Op sommige
terminals kan je C-_ typen door te doen alsof je C-/ typt.
Een numeriek argument aan C-_ of C-x u duidt het aantal herhalingen aan.
* BESTANDEN
-----------
Om een tekst die je gemaakt of veranderd hebt op te slaan moet je de
tekst in een bestand bewaren (`to save a file' in het engels). Als je
dat niet doet ben je die veranderingen kwijt op het moment dat je uit
Emacs gaat. Je kan een bestand veranderen door het bestand `bezoeken'.
(Ook wel `vinden'; `finding' of `visiting' in het engels.)
Het bezoeken van een bestand betekent dat je de inhoud van dat bestand
in Emacs ziet. Het lijkt er dan op alsof je het bestand aan het
veranderen bent. Echter, deze veranderingen zijn slechts tijdelijk
zolang je het bestand niet bewaart. Op deze manier kan je nooit per
ongeluk een half gewijzigd bestand op het systeem achterlaten. Zelfs
als je het bestand bewaart, zorgt Emacs ervoor dat het originele
bestand onder een gewijzigde naam nog steeds beschikbaar is, voor het
geval je later besluit dat de veranderingen toch niet zo'n goed plan
waren.
In de buurt van de onderkant van het scherm zie je een regel die begint en
eindigt met streepjes, met aan het begin "--:-- TUTORIAL.nl" of iets
dergelijks. Dit deel van het scherm laat normaal de naam van het bestand
zien dat je op dat moment bezoekt. Op dit moment bezoek je een bestand
dat "TUTORIAL.nl" heet; het is je eigen copie van de nederlandstalige
Emacs uitleg (`tutorial' in het engels). Als je in Emacs een bestand
bezoekt dan staat de naam van het bestand altijd op deze plaats.
De commando's om een bestand te bezoek of te bewaren zijn anders dan de
commando's die je tot nu toe geleerd hebt; ze bestaan namelijk uit twee
tekens. Beide commando's beginnen met het teken Control-x. Er zijn een
heleboel commando's die met Control-x beginnen. Veel van die commando's
hebben te maken met bestanden, buffers, en daaraan gerelateerde zaken.
Dergelijke commando's bestaan uit twee, drie of vier tekens.
Nog iets bijzonders aan het commando om een bestand te bezoeken is dat
je aan moet geven welk bestand je wilt. Dit heet dat het commando "een
argument van de gebruiker vraagt"; in dit geval de naam van het bestand.
Nadat je het commando
C-x C-f bezoek bestand (met de f van `find file')
hebt getypt vraagt Emacs om de naam van het bestand. De naam die je
intypt verschijnt op de onderste regel van het scherm. Wanneer die regel
voor dit soort invoer gebruikt wordt, heet ze de minibuffer. Je kan de
gebruikelijke Emacs commando's gebruiken om de filename in te typen.
Tijdens het invoeren van de naam van het bestand (of willekeurig wat
voor minibuffer invoer) kan je het commando afbreken met C-g.
>> Type C-x C-f gevolgd door C-g. Dit breekt de minibuffer af en
ook het C-x C-f commando dat van de minibuffer gebruik maakte.
Netto resultaat is dat je geen bestand bezoekt.
Als je de naam van een bestand hebt ingevoerd, type dan <Return> om het
af te sluiten. Hierna gaat het C-x C-f commando aan het werk en bezoekt
het bestand dat je aangegeven hebt. Als het C-x C-f commando klaar is,
verdwijnt de minibuffer.
Na korte tijd verschijnt de inhoud van het bestand op het scherm en kan
je de inhoud wijzigen. Als je de wijzigingen op wilt slaan, type dan het
commando
C-x C-s bewaar bestand (met de s van `save file')
Dit bewaart de tekst zoals Emacs die nu heeft in het bestand. De eerste
keer dat je dit doet bewaart Emacs het originele bestand onder een andere
naam zodat het nog niet verloren is. De nieuwe naam bestaat uit de oude
naam gevolgd door een "~".
Als Emacs klaar is het bestand te bewaren laat ze de naam van het bestand
zien. Het is een goede gewoonte een bestand redelijk vaak te bewaren
zodat er niet teveel werk verloren gaat als het systeem hangt of crasht.
>> Type C-x C-s, om je copie van deze uitleg te bewaren. Als het goed is
verschijnt "Wrote ...TUTORIAL" op de onderste schermregel.
OPMERKING: Op sommige systemen gebeurt er helemaal niets als je C-x C-s
typt, en daarna ook niets meer. Dit komt door een eigenschap van de
machine waarop je werkt die te maken heeft met `flow control'. Met C-s
stopt de `flow' en komt niets meer van wat je typt bij Emacs terecht. Om
deze situatie te herstellen, type C-q. Lees daarna de "Spontaneous Entry
to Incremental Search" sectie in het Emacs handboek over hoe om te gaan
met deze situatie.
Je kan een bestaand bestand bezoeken, om het te bekijken of het te
wijzigen. Je kan ook een bestand bezoeken dat nog niet bestaat. Dit is
de manier om met Emacs een nieuw bestand te maken: bezoek het bestand, dat
initieel leeg zal zijn, en voeg tekst toe. Zodra je de tekst bewaart
wordt het bestand werkelijk gecreeerd, met de tekst als inhoud. Vanaf dat
moment ben je dus bezig met een bestaand bestand.
* BUFFERS
---------
Als je een tweede bestand bezoekt met C-x C-f blijft het eerste bestand
gewoon in Emacs. Je kan naar dat bestand terug door het gewoon nog een
keer te bezoeken met C-x C-f. Op deze manier kan je een behoorlijk aantal
bestanden in Emacs krijgen.
>> Cre-eer een bestand dat "foo" heet door te typen: C-f C-f foo
<Return>. Voeg hieraan wat tekst toe, wijzig haar, en bewaar "foo"
door C-x C-s te typen. Type hierna C-x C-f TUTORIAL <Return> om
weer hier, in de uitleg, terug te komen.
Emacs bewaart intern de tekst van elk bestand in een ding dat een "buffer"
genoemd wordt. Als je een bestand bezoekt wordt er een nieuwe buffer
gemaakt. Om een lijst van de huidige buffers te zien, type
C-x C-b laat de bufferlijst zien
>> Probeer C-x C-b nu.
Zie dat elke buffer een naam heeft en mogelijk ook een bestandsnaam; dit
is de naam van het bestand waarmee de buffer overeenkomt. Sommige buffers
hebben niets met een bestand te maken. Bijvoorbeeld, de buffer die
"*Buffer List*" heet heeft geen bestand. Die buffer is de buffer die de
lijst bevat die door C-x C-b gemaakt wordt. ALLE tekst die je in een
Emacs venster ziet is altijd onderdeel van een of andere buffer.
>> Type C-x 1 om de bufferlijst te verwijderen.
Als je de tekst van het ene bestand verandert en dan een ander bestand
bezoekt dan wordt het eerste bestand niet bewaard. De wijzigingen blijven
in Emacs, in de buffer die bij het bestand hoort. Het cre-eren of
modificeren van de buffer van het tweede bestand heeft geen effect op de
eerste buffer. Dit is erg nuttig, maar betekent ook dat er een eenvoudige
manier nodig is om het eerste bestand te bewaren. Het zou erg vervelend
zijn om er eerst naar terug te moeten gaan met C-x C-f om het dan te
kunnen bewaren met C-x C-s. Dus hebben we
C-x s bewaar een paar buffers
C-x s vraagt voor elke buffer die veranderingen heeft die nog niet
opgeslagen zijn, of je de buffer wilt bewaren.
>> Voeg een wat tekst toe en type C-x s.
Emacs vraagt nu of je de buffer die TUTORIAL.nl heet wilt bewaren.
Bewantwoord deze vraag positief door een "y" in te typen (de y van
"yes", engels voor "ja").
* UITGEBREIDE COMMANDO'S
------------------------
Er zijn veel meer Emacs commando's dan er op de toetsen van het
toetsenbord passen, zelfs als we hun aantal kunnen vergroten door de
control of meta toets te gebruiken. Emacs lost dit probleem op met het X
commando (met de X van eXtensie of uitbreiding). Het X commando komt in
twee smaken:
C-x teken eXtensie; wordt gevolgd door een teken
M-x genaamd commando eXtensie; wordt gevolgd door een naam.
Deze commando's zijn in het algemeen nuttig, maar worden minder gebruikt
dan de commando's die tot nu toe uitgelegd zijn. Je hebt al twee van deze
commando's gezien: C-x C-f om een bestand te bezoeken, en C-x C-s om het
te bewaren. Een ander voorbeeld is het commando om Emacs te verlaten: dit
is C-x C-c. (Maak je geen zorgen over het verloren gaan van veranderingen
die niet bewaard zijn; C-x C-c vraagt of je veranderde buffers wilt
bewaren voordat Emacs daadwerkelijk eindigt.)
C-z is het commando om Emacs *tijdelijk* te verlaten, zodat je daarna weer
terug kan keren in dezelfde Emacs sessie.
Op systemen die deze mogelijkheid bieden, zet C-z Emacs stil: je komt weer
terug in de shell, maar Emacs is nog aanwezig. In de meeste shells kan je
Emacs weer activeren met het "fg" commando, of met "%emacs".
Op systemen die niet de mogelijkheid bieden om programma's stil te zetten
cre-eert C-z een subshell onder Emacs om je zo in de gelegenheid te
stellen andere programma's uit te voeren en daarna weer in Emacs terug te
keren; Emacs wordt dus niet werkelijk verlaten. In dit geval is het
shellcommando "exit" de normale manier om de subshell te verlaten en in
Emacs terug te keren.
Het moment om C-x C-c te gebruiken is wanneer je uit gaat loggen. Het is
ook het juiste commando om Emacs te be-eindigen wanneer Emacs opgestart
was door een mail programma of iets dergelijks, aangezien die misschien
niet met een stilgezette Emacs om kunnen gaan. Normaal gezien is het
echter beter Emacs stil te zetten met C-z dan om Emacs te verlaten,
behalve als je uit wilt loggen natuurlijk.
Er bestaan vele C-x commando's. Hier is een lijst van degene die je nu al
kent:
C-x C-f bezoek bestand
C-x C-s bewaar bestand
C-x C-b laat bufferlijst zien
C-x C-c verlaat Emacs
C-x u herstel
Genaamde uitgebreide commando's worden nog minder vaak gebruikt, of worden
alleen onder bepaalde omstandigheden gebruikt. Een voorbeeld is het
commando replace-string, dat in de hele tekst een string vervangt door een
andere string (`to replace' betekent `vervangen'). Als je M-x typt echoot
Emacs onderaan het scherm `M-x' en moet je de naam van het commando
intypen, in dit geval "replace-string". Als je gewoon "repl s<TAB>" typt
maakt Emacs de naam zelf af. Be-eindig het commando met <Return>.
Het replace-string commando heeft twee argumenten nodig: de string die
vervangen moet worden en de string waarmee die vervangen moet worden.
Je sluit elk argument af met <Return>.
>> Plaats de cursor op de lege regel twee regels onder deze.
Type dan M-x repl s<Return>gewijzigd<Return>veranderd<Return>.
Zie hoe deze regel daardoor gewijzigd is. Je hebt elk voorkomen van
het woord g-e-w-i-j-z-i-g-d vervangen door "veranderd"; beginnend op
de plek waar de cursor staat.
* AUTOMATISCH BEWAREN
---------------------
Als je een bestand veranderd hebt maar het nog niet bewaard hebt, zouden
de veranderinge verloren kunnen gaan als het systeem zou hangen of
herstarten. Om je hiertegen te beschermen bewaart Emacs om de zoveel tijd
de veranderde tekst automatisch. De naam van het bestand waarin de tekst
automatisch bewaard wordt begint en eindigt met een #. Bijvoorbeeld, als
je het bestand "hello.c" aan het bewerken bent dan wordt de tekst
automatisch bewaard in een bestand dat "#hello.c#" heet. Zodra je het
bestand werkelijk bewaart, wordt het automatisch bewaarde bestand weer
weggegooid.
Als de computer crasht kan je de automatisch bewaarde tekst terugkrijgen
door de file normal te bezoeken (de originele file, niet de automatisch
bewaarde), gevolgd door M-x recover file<Return>. Als Emacs vraagt om
bevestiging, antwoord dan yes<Return> en de automatisch bewaarde
informatie wordt teruggehaald.
* ECHO GEBIED
-------------
Als je een commando langzaam intypt echoot Emacs de tekens aan de
onderkant van het scherm, in een deel dat het "echo gebied" genoemd wordt.
Dit gebied bevat de onderste regel van het scherm.
* MODE-REGEL
------------
De regel direct boven het echo gebied heet de "mode-regel". De mode-regel
zier er ongeveer zo uit:
--**-Emacs: TUTORIAL.nl (Fundamental)--68%------------------------
Deze regel geeft interessante informatie over Emacs en de tekst die
je aan het bewerken bent.
Je weet al wat de bestandsnaam betekent: het is de naam van het bestand
dat je bezoekt. -NN%-- geeft je huidige positie in de tekst aan: NN
procent van de tekst bevindt zich boven het scherm. Als het bestand vanaf
het begin op het scherm staat, staat er --Top-- in plaats van --00%--.
Als het laatste stuk tekst op het scherm staat, zal er --Bot-- staan (van
`bottom', `onderkant' in het nederlands). Als de tekst zo klein is dat ze
volledig op het scherm past staat --All-- in de mode-regel.
De sterretjes aan het begin betekenen dat je de tekst gemodificeerd hebt.
Direct na het bezoeken of bewaren staan er gewoon streepjes.
In de mode-regel staat tussen haakjes in welke mode je aan het werken
bent. Tenzij een andere mode gewenst is, zit je in de "Fundamental" mode
zoals nu (`fundamental' is `basis' in het nederlands). Een dergelijke
mode heet een hoofdmode (`major mode' in het engels).
Emacs heeft verschillende hoofdmodes. Sommige daarvan zijn bedoelt voor
het bewerken van verschillende talen of soorten tekst, zoals bijvoorbeeld
Lisp mode, Text mode, etc. Op elk moment is er altijd precies een mode
actief, en de naam daarvan staat in de mode-regel, op de plaats waar nu
"Fundamental" staat.
Elke hoofdmode zorgt ervoor dat sommige commando's zich anders gedragen.
Zo bestaat er een commando om een commentaar in een programma te typen, en
aangezien elke programmeertaal een ander idee heeft over hoe commentaar
eruit moet zien, moet elke hoofdmode op een andere manier het commentaar
beginnen. Elke hoofdmode is de naam van een uitgebreid commando, en met
dat commando schakel je om naar die hoofdmode. Zo is bijvoorbeeld
M-x fundamental-mode het commando om naar de basismode om te schakelen.
Als je nederlandse of engelse tekst wil gaan bewerken, zoals bijvoorbeeld
dit bestand, kan je beter "text mode" gebruiken, de mode om tekst in een
gewone taal te bewerken:
>> Type M-x text-mode<Return>.
Wees gerust; geen van de commando's die je geleerd hebt zorgen voor
grondige veranderingen in Emacs. Een van de dingen die je kan merken is
bijvoorbeeld dat M-f en M-b nu apostrophes als onderdeel van een woord
beschouwen. In de vorige, Fundamental, mode behandelen M-f en M-b de
apostrophe als ruimte tussen twee woorden.
Het is gebruikelijk dat hoofdmodes dergelijke subtiele verschillen hebben.
De meeste commando's doen dus min of meer hetzelfde in elke hoofdmode.
Met het commando C-h m kan je de documentatie over de huidige hoofdmode
lezen.
>> Gebruik C-u C-v een paar keer om deze zin in de buurt van de bovenkant
van het scherm te krijgen.
>> Type C-h m om te zien hoe Text mode verschilt van Fundamental mode.
>> Type C-x 1 om de documentatie van het scherm te verwijderen.
Hoofdmodes heten hoofdmodes omdat er ook bijmodes zijn. Bijmodes zijn
geen alternatieven voor hoofdmodes; het zijn slechts kleine modificaties
daarvan. Elke bijmode kan aan- of uitgezet worden, onafhankelijk van
andere bijmodes en onafhankelijk van de hoofdmode. Je kan dus nul, een,
of willekeurig veel minor modes gebruiken.
Een nuttige bijmode voor het bewerken van tekst in een natuurlijke taal,
zoals nederlands, is Auto Fill mode (`auto fill' betekent automatisch
uitvullen). Wanneer deze mode aanstaat breekt Emacs automatisch een regel
tussen twee woorden af als de regel anders te lang zou worden.
Je kan Auto Fill mode aanzetten met M-x auto-fill-mode<Return>. Als deze
mode al aanstaat, kan je hem uitzetten met M-x auto-fill-mode<Return>.
Als de mode uitstaat zet dit commando de mode aan; als ze aanstaat zet dit
commando de mode uit. Het commando zet de mode steeds aan en uit zet (`to
toggle' in het engels).
>> Type nu M-x auto-fill-mode<Return>. Type nu vele malen asdf op een
regel zodat je kan zien dat de regel in twee-en gesplitst wordt. Er
moeten wel spaties tussen de woorden staan, omdat de Auto Fill mode
alleen op spaties de regel breekt.
De rechter kantlijn staat meestal op 70 tekens, maar die kan je veranderen
met het C-x f commando. Dit commando accepteert een numeriek argument
dat de gewenste kantlijn is.
>> Type C-x f met 20 als argument (C-u 20 C-x f).
Type wat tekst en zie dat Emacs de regels afbreekt bij 20 tekens.
Zet de kantlijn nu terug op 70, weer met C-x f.
Als je de tekst midden in een regel verandert vult Auto Fill mode
de regel niet opnieuw.
Om een paragraaf opnieuw te vullen, type M-q (Meta-q) terwijl de
cursor in de paragraaf staat.
>> Plaats de cursor in de voorgaande paragraaf en type M-q.
* ZOEKEN
--------
Emacs kan strings zoeken (een string is een rij tekens), zowel volgend op
de cursorpositie, als eraan voorafgaand. Het zoeken van een string
verplaatst de cursor naar de volgende plaats waar de gezochte string
voorkomt.
Het zoekcommando van Emacs is anders dan de zoekcommando's van de meeste
tekstverwerkers; het zoekt incrementeel. Dit betekent dat het zoeken
gebeurt tijdens het intypen van de gezochte string.
Het commando om vooruit zoeken te starten is C-s (met de `s' van `to
search', i.e. zoeken); C-r start het zoeken achteruit (met de `r' van
`reverse' of achteruit). WACHT nog even met ze te proberen.
Als je C-s typt verschijnt de string "I-search" in het echo gebied. Dit
betekent dat Emacs bezig is met een `incremental search' (incrementele
zoekopdracht) en wacht op het intypen van de zoekstring. <RET> be-eindigt
het zoeken.
>> Type nu C-s om het zoeken te start. Type nu, LANGZAAM, een letter per
keer, het woord `cursor', met een pauze na elke letter zodat je kan
zien wat er met de cursor gebeurt. Je hebt nu eenmaal naar het woord
`cursor' gezocht.
>> Type nogmaals C-s, om naar het volgende voorkomen van `cursor' te
zoeken.
>> Type nu viermaal <Delete> en let op de cursorbewegingen.
>> Type <RET> om het zoeken te be-eindigen.
Zag je wat er gebeurde? Tijdens incrementeel zoeken probeert Emacs naar
de eerste plek te gaan waar de string staat die je tot dan toe getypt
hebt. Om naar de volgende plek te gaan, type je C-s nog een keer. Als er
geen volgende plek is piept Emacs en vertelt je dat de zoekopdracht faalt
(`failing' in het engels); met C-g kan je het zoeken afbreken.
OPMERKING: Op sommige systemen gebeurt er helemaal niets als je C-x C-s
typt, en daarna ook niets meer. Dit komt door een eigenschap van de
machine waarop je werkt die te maken heeft met `flow control'. Met C-s
stopt de `flow' en komt niets meer van wat je typt bij Emacs terecht. Om
deze situatie te herstellen, type C-q. Lees daarna de "Spontaneous Entry
to Incremental Search" sectie in het Emacs handboek over hoe om te gaan
met deze situatie.
Als je tijdens incrementeel zoeken <Delete> typt, zal je zien dat het
laatste teken dat je in de zoekstring typte weggehaald wordt en dat het
zoeken teruggaat naar de voorgaande plaats. Als je bijvoorbeeld begint
met zoeken en je typt een "c" dan ga je naar het eerste voorkomen van een
"c". Type je vervolgens een "u" dan gaat de cursor naar het eerste
voorkomen van de string "cu". Als je nu <Delete> typt, dan wordt de "u"
van de zoekstring afgehaald en gaat de cursor terug naar de plaats waar
hij stond voordat je de "u" intypte, i.e. het eerste voorkomen van de "c".
Als je tijdens een zoekoperatie een control- of meta-teken intypt dan
wordt het zoeken be-eindigd. Er zijn een paar uitzonderingen, namelijk
tekens die tijdens zoeken een speciale betekenis hebben, zoals C-s en C-r.
Met C-s begin je te zoeken naar het eerste voorkomen van de zoekstring NA
de huidige cursorpositie. Als je iets wilt zoeken dat eerder in de tekst
moet voorkomen, gebruik dan C-r i.p.v. C-s. Alles wat we nu weten over
C-s geldt ook voor C-r, alleen de zoekrichting is omgedraaid.
* MEERDERE VENSTERS
-------------------
Een van Emacs' aardige eigenschappen is dat je meerdere vensters op het
scherm kan laten zien.
>> Zet de cursor op deze regel en type C-u 0 C-l.
>> Type C-x 2 om het scherm in twee vensters op te splitsen.
Beide vensters laten deze uitleg zien; de cursor blijft in het
bovenste venster.
>> Type C-M-v om de tekst in het onderste venster te verschuiven.
(Als je geen Meta toets hebt, type dan ESC C-v.)
>> Type C-x o (met de `o' van `other'; `ander' in het nederlands)
om de cursor naar het andere venster te verplaatsen.
>> Verschuif de tekst in het onderste venster, m.b.v. C-v en M-v.
Zorg ervoor dat je deze uitleg in het bovenste venster leest.
>> Type weer C-x o om de cursor weer in het bovenste venster
te zetten. De cursor staat weer precies op de plaats waar
hij stond toen je het venster verliet.
Je kan C-x o blijven gebruiken om van venster naar venster te gaan. Elk
venster heeft zijn eigen cursorpositie; de cursor is altijd maar zichtbaar
in een daarvan. Alle normale commando's hebben betrekking op het venster
waar de cursor in staat. Dit venster is het `geselecteerde venster'
(`selected window' in het engels).
Het C-M-v commando is erg nuttig wanneer je tekst aan het bewerken bent in
het ene venster, terwijl je het andere venster als referentie gebruikt.
Je kan de cursor dan altijd in het venster houden waarin je bezig bent,
terwijl je met C-M-v door de tekst in het andere venster loopt.
C-M-v is een voorbeeld van een CONTROL-META teken. Als je een echte META
toets hebt kan je C-M-v intypen door zowel CTRL als META ingedrukt te
houden terwijl je v typt. Het maakt niet uit in welke volgorde je de CTRL
en META indrukt; het gaat erom welke ingedrukt zijn terwijl je typt.
Als je geen echte META toets hebt kan je ESC gebruiken; de volgorde maakt
dan wel uit. Je moet dan ESC typen, gevolgd door CTRL-v; CTRL-ESC v zal
niet werken. Dit komt doordat ESC zelf een teken is, terwijl CTRL en META
dat niet zijn.
>> Type C-x 1 (in het bovenste venster) om het onderste venster te laten
verdwijnen.
(Als je C-x 1 typt in het onderste venster laat je het bovenste
verdwijnen. C-x 1 betekent zoveel als `ik wil maar 1 venster,
en wel dat venster waar de cursor nu in staat.')
Hier is nog een manier om twee venster te krijgen die elk een andere tekst
laten zien:
>> Type C-x 4 C-f gevolgd door de naam van een van je bestanden, gevolgd
door <Return>. Het opgegeven bestand zal in het onderste venster
verschijnen, en de cursor zal in dat venster staan.
>> Type C-x o om terug naar het bovenste venster te gaan, en C-x 1 om
het onderste venster te laten verdwijnen.
* RECURSIEVE BEWERKINGSNIVEAUS
------------------------------
Soms kom je in Emacs in een recursief bewerkingsniveau terecht (engels:
`recursive editing level'). Dit is te zien in de moderegel aan de rechte
haken om de haakjes die om naam van de hoofdmode staan. Dan staat er
bijvoorbeeld [(Fundamental)] in plaats van (Fundamental).
Type ESC ESC ESC Om uit een recursief bewerkingsniveau te komen. Dit is
een generiek `ontsnappingscommando'. Je kan het ook gebruiken om extra
vensters weg te gooien of om uit de minibuffer te komen.
>> Type M-x om in een minibuffer te komen, en type dan ESC ESC ESC
om er weer uit te komen.
C-g is niet bruikbaar om uit een recursief bewerkingsniveau te komen. De
reden hiervoor is dat C-g gebruikt wordt om commando's af te breken BINNEN
het recursieve bewerkingsniveau.
* MEER INFORMATIE
-----------------
We hebben geprobeerd je met deze uitleg precies genoeg informatie te geven
om met Emacs te beginnen. De mogelijkheden van Emacs zijn zo legio dat
het onmogelijk is nu alles uit te leggen. Emacs heeft zoveel nuttige
mogelijkheden dat je er meer over zou kunnen willen leren. Emacs heeft
commando's om documentatie te laten zien over Emacs commando's. Deze
`helpcommando's' beginnen allemaal met C-h: `het Hulpteken'.
Om hulp te krijgen, type C-h, gevolgd door een teken om aan te duiden
welke hulp je wilt. Als je het echt niet meer weet, type C-h ? en Emacs
vertelt welke hulp het allemaal te bieden heeft. Als je C-h hebt getypt
maar van gedachten veranderd bent, type je gewoon C-g om het af te breken.
(Op sommige computers is de betekenis van C-h veranderd. Dat is een
slecht plan, zeker als die verandering op alle gebruikers invloed heeft,
en is dus een geldige reden om je beklag te doen bij de systeembeheerder
of helpdesk. Als C-h intussen niet een bericht onderaan het scherm laat
zien over mogelijke hulp, probeer dan de F1 toets (functietoets 1) of
gebruik M-x help RET.)
De eenvoudigste hulp is C-h c. Type C-h, het teken `c' en een teken of
uitgebreid commando, en Emacs laat een zeer korte beschrijving van het
commando zien.
>> Type C-h c Control-p.
De beschrijving die getoond wordt zou zoiets moeten zijn als
C-p runs the command previous-line
(nederlands: C-p voert het commando previous-line uit.)
Dit commando vertelt je `de naam van de functie'. Functies worden vooral
gebruikt om Emacs uit te breiden of aan de wensen van de gebruiker aan te
passen. Aangezien functienamen gekozen zijn om aan te geven wat de
functie doet, zijn ze ook geschikt als erg korte documentatie; genoeg om
je te herinneren aan wat de commando's die je al geleerd hebt betekenen.
Uitgebreide commando's zoals C-x C-s en (als je geen META, EDIT or ALT
toets hebt) <ESC> v kunnen ook getypt worden na C-h c.
Om meer informatie over een commando te krijgen, type C-h k in plaats van
C-h c.
>> Type C-h k Control-p.
Dit laat de documentatie van de functie zien, inclusief de naam van de
functies, in een apart venster. Als je klaar bent met lezen, type C-x 1
om van dat venster af te komen. Je hoeft dat natuurlijk niet meteen te
doen. Je kan ook eerst wat anders doen voordat je C-x 1 typt.
Hier zijn nog wat nuttige mogelijkheden van C-h:
C-h f Beschrijf een functie. Je moet de naam van de functie
intypen.
>> Type C-h f previous-line<Return>
Dit laat alle informatie zien die Emacs heeft over de functie die het
C-p commando implementeert.
C-h a Commando Apropos. Type een woord in en Emacs zal een
lijst van alle commando's laten zien waarin dat woord
voorkomt. Al deze commando's kunnen aangeroepen worden
met M-x. Bij sommige commando's staat met welke tekens
dit commando direct uitgevoerd kan worden.
>> Type C-h a file<Return>.
Dit laat in een ander venster alle M-x commando's zien met `file' in hun
naam. Je zal teken-commando's zien als C-x C-f naast de overeenkomende
commandonaam zoals find-file.
>> Type C-M-v herhaaldelijk om de tekst in het hulpvenster te verschuiven.
>> Type C-x 1 om het hulpvenster weg te gooien.
* CONCLUSIE
-----------
Denk eraan dat je met C-x C-c gebruikt om Emacs te verlaten. Om tijdelijk
een shell te krijgen en daarna weer in Emacs terug te komen, type C-x.
De bedoeling van deze uitleg is dat ze begrijpelijk is voor alle nieuwe
Emacs gebruikers. Als je dus iets onduidelijks bent tegengekomen blijf
dan niet zitten en maak jezelf geen verwijten. Klaag erover!
* COPI-EREN
-----------
(De engelse versie van) deze uitleg is voorafgegaan door een lange reeks
van Emacs tutorials, die begon met de uitleg die Stuart Cracraft schreef
voor de originele Emacs. Deze nederlandse vertaling is gemaakt door
Pieter Schoenmakers <tiggr(a)ics.ele.tue.nl> op basis van de GNU Emacs 20.2
TUTORIAL.
(Wat nu volgt is een vertaling naar het nederlands van de condities voor
gebruik en verspreiding van deze uitleg. Deze vertaling is niet
gecontroleerd door een jurist. Er kunnen derhalve geen rechten aan de
vertaling worden ontleend, en de vertaling wordt gevolgd door het engelse
origineel.)
Deze versie van de uitleg valt onder copyright, net als GNU Emacs.
Je mag deze uitleg distribu-eren onder bepaalde condities:
Copyright (c) 1985, 1996, 1997 Free Software Foundation
Iedereen mag letterlijke copi-en van dit document, zoals ontvangen,
verspreiden, op elke medium, vooropgesteld dat de copyrightmelding en
toestemmingsmelding niet aangetast worden en dat de verspreider aan de
ontvanger dezelfde distributierechten verleend als aan hem verleend
door deze melding.
Toestemming wordt verleend om gemodificeerde versies van dit document,
of delen daarvan, te verspreiden, onder bovenstaande condities,
vooropgesteld dat ze ook duidelijk melding maken van degene die als
laatste modificaties doorgevoerd heeft.
De condities voor het copi-eren van Emacs zelf zijn complexer dan dit,
maar gebaseerd op dezelfde gedachte. Lees het bestand COPYING en geef
vervolgens copi-en van Emacs aan al je vrienden. Help bij het uitroeien
van softwarebeschermingspolitiek (`software eigendom') door vrije software
te gebruiken, schrijven en delen!
(Engels origineel van de copyrightmelding en condities:
This version of the tutorial, like GNU Emacs, is copyrighted, and
comes with permission to distribute copies on certain conditions:
Copyright (c) 1985, 1996 Free Software Foundation
Permission is granted to anyone to make or distribute verbatim copies
of this document as received, in any medium, provided that the
copyright notice and permission notice are preserved,
and that the distributor grants the recipient permission
for further redistribution as permitted by this notice.
Permission is granted to distribute modified versions
of this document, or of portions of it,
under the above conditions, provided also that they
carry prominent notices stating who last altered them.
The conditions for copying Emacs itself are more complex, but in the
same spirit. Please read the file COPYING and then do give copies of
GNU Emacs to your friends. Help stamp out software obstructionism
("ownership") by using, writing, and sharing free software!)
Copyright (c) 1985 Free Software Foundation, Inc; podmienky pozri na konci.
Do èe¹tiny prelo¾il Milan Zamazal <pdm(a)zamazal.org>.
Do slovenèiny prelo¾il Miroslav Va¹ko <vasko(a)debian.cz>
Máte pred sebou tútorial k Emacsu.
Príkazy Emacsu v¹eobecne vyu¾ívajú klávesu CONTROL (obèas oznaèovanú ako CTRL
alebo CTL) alebo klávesu META (obèas oznaèovanú EDIT alebo ALT). Aby sme
tieto názvy nemuseli stále písa» v plnom znení, budeme pou¾íva» nasledujúce
skratky:
C-<chr> znamená podr¾a» klávesu CONTROL a stlaèi» znak <chr>.
Teda C-f znamená: podr¾te klávesu CONTROL a stlaète f.
M-<chr> znamená podr¾a» klávesu META, EDIT alebo ALT a stlaèi» <chr>.
Ak nemáte ¾iadnu z kláves META, EDIT ani ALT, tak namiesto toho
stlaète a pustite klávesu ESC a potom <chr>. Klávesu ESC budeme
oznaèova» <ESC>.
Dôle¾itá poznámka: prácu s Emacsom ukonèíte stlaèením C-x C-c (dva znaky).
Znaky ">>" na µavom okraji oznaèujú miesta, kde si máte vyskú¹a» príkaz.
Napríklad:
<<Blank lines inserted here by startup of help-with-tutorial>>
>> Teraz stlaète C-v (view next screen) pre posun na ïal¹iu obrazovku.
(Smelo do toho, spravte to pridr¾aním klávesy control a stlaèením v.)
Od tejto chvíle by ste toto mali robi» ak doèítate zobrazenú
obrazovku.
V¹imnite si, ¾e pri posuve obrazoviek v¾dy zostávajú zobrazené dva riadky
z predchádzajúcej obrazovky; to poskytuje urèitú náväznos» pri postupnom
èítaní textu.
Prvá vec, ktorú potrebujete vedie» je, ako sa v textu pohybova»
z jedného miesta na druhé. U¾ viete, ako sa posunú» o jednu obrazovku
vpred, pomocou C-v. Na prechod o obrazovku spä» pou¾ite M-v
(podr¾te klávesu META a stlaète v alebo stlaète <ESC>v ak
nemáte klávesy META, EDIT ani ALT).
>> Skúste stlaèi» M-v a potom C-v, niekoµko krát to zopakujte.
* ZHRNUTIE
----------
Na prezeranie obrazovkových stránok sú u¾itoèné nasledujúce príkazy:
C-v posuv o obrazovku vpred
M-v Posuv o obrazovku spä»
C-l Zmazanie obrazovky a znovuzobrazenie celého textu,
pritom sa text pod kurzorom presunie k stredu obrazovky.
(Ide o control-L a nie control-1.)
>> Nájdite kurzor a zapamätajte si, aký je okolo neho text.
Potom stlaète C-l.
Nájdite kurzor znovu a v¹imnite si, ¾e je okolo neho ten istý text.
* ZÁKLADNÉ OVLÁDANIE KURZORU
----------------------------
Pohyb medzi obrazovkami je u¾itoèný, ale ako sa premiestnime na konkrétne
miesto v texte na obrazovke?
Je to mo¾né dosiahnu» niekoµkými spôsobmi. Najzákladnej¹ím spôsobom je
pou¾itie príkazov C-p, C-b, C-f a C-n. Ka¾dý z týchto príkazov presunie
kurzor na obrazovke o jeden riadok alebo ståpec v danom smere.
Tu je tabuµka znázoròujúca smer posunu kurzoru vyvolaný týmito ¹tyrmi
príkazmi:
Predchádzajúci riadok, C-p
:
:
Dozadu, C-b .... Momentálna pozícia kurzoru .... Dopredu, C-f
:
:
Nasledujúci riadok, C-n
>> Presuòte kurzor na prostredný riadok tohto diagramu pomocou
C-n alebo C-p. Potom stlaète C-l, aby ste na obrazovke videli celý
diagram vycentrovaný.
Pravdepodobne si tieto príkazy µahko zapamätáte podµa zaèiatoèných písmen
anglických názvov: P ako previous (predchádzajúci), N ako next (nasledujúci),
B ako backward (spä»), F ako forward (vpred). Sú to základné príkazy pre
pohyb kurzoru a budete ich pou¾íva» stále, tak¾e by bolo veµmi vhodné, keby
ste sa ich teraz nauèili.
>> Stlaète niekoµko krát C-n, aby ste kurzor presunuli na tento riadok.
>> Posuòte kurzor dovnútra riadku pomocou niekoµkých C-f a potom hore
stlaèením C-p. Pozorujte, èo C-p robí, keï je kurzor uprostred riadku.
Ka¾dý riadok textu konèí znakom nového riadku, ktorý ho oddeµuje od
nasledujúceho riadku. Znakom nového riadku by mal by» ukonèený aj posledný
riadok súboru (napriek tomu, ¾e to Emacs nevy¾aduje).
>> Vyskú¹ajte C-b na zaèiatku riadku. Kurzor by sa mal presunú» na koniec
predchádzajúceho riadku, preto¾e ho tým presuniete cez znak nového riadku.
C-f funguje analogicky ako C-b, tj. na konci riadku dôjde k presunu na
ïal¹í riadok.
>> Stlaète niekoµkokrát C-b, tak¾e uvidíte, kde sa nachádza kurzor.
Potom stláèajte C-f, aby ste sa vrátili na koniec riadku.
Potom stlaète e¹te raz C-f, aby ste sa presunuli na nasledujúci
riadok.
Keï kurzorom prejdete cez horný alebo dolný okraj obrazovky, posunie sa
text za príslu¹ným okrajom na obrazovku. Táto vlastnos» sa nazýva
"scrollovanie". Umo¾òuje premiestni» kurzor na µubovoµné miesto v texte,
bez toho, aby kurzor opustil obrazovku.
>> Skúste posunú» kurzor pod dolný okraj obrazovky pomocou C-n a pozorujte,
èo sa stane.
Ak je posun po znakoch príli¹ pomalý, mô¾ete sa pohybova» po
slovách. M-f (Meta-f) robí posun o slovo vpred a M-b robí posun
o slovo spä».
>> Stlaète niekoµko krát M-f a M-b.
Ak sa kurzor nachádza uprostred slova, M-f presunie kurzor na koniec
tohto slova. Ak sa nachádza kurzor v medzere medzi slovami, M-f presunie
kurzor na koniec nasledujúceho slova. M-b pracuje analogicky v opaènom
smere.
>> Stlaète niekoµko krát M-f a M-b spolu s C-f a C-b, aby ste videli
výsledky príkazov M-f a M-b vykonávaných z rôznych miest vnútri slov
a medzi nimi.
V¹imnite si analógie medzi C-f a C-b na jednej strane a M-f a M-b na
strane druhej. Meta znaky sú veµmi èasto vyu¾ívané pre operácie
vz»ahujúce sa na entity definované jazykom (slová, vety, odstavce),
naopak Control znaky pracujú na základných prvkoch nezávislých na tom,
èo práve editujete (znaky, riadky, a pod.).
Táto analógia platí tie¾ pre riadky a vety: C-a a C-e vykonáva presun
na zaèiatok a koniec riadku, M-a a M-e vykonáva presun na zaèiatok a koniec
vety.
>> Skúste niekoµko krát C-a a potom niekoµko krát C-e.
Skúste niekoµko krát M-a a potom niekoµko krát M-e.
V¹imnite si, ¾e opakované C-a nerobí niè, ale opakované M-a v¾dy
vykoná presun na ïal¹iu vetu. Princípu analógie to síce príli¹
nezodpovedá, ale napriek tomu je toto chovanie mo¾né pova¾ova» za prirodzené.
Pozícia kurzoru v texte sa tie¾ nazýva "bod" ("point"). Aby sme to
parafrázovali, kurzor je vidie» na obrazovke v mieste, kde je bod umiestnený
v texte.
Tu je prehµad jednoduchých operácií pre pohyb kurzoru vrátane príkazov pre
pohyb medzi slovami a vetami:
C-f Presun o znak vpred
C-b Presun o znak spä»
M-f Presun o slovo vpred
M-b Presun o slovo spä»
C-n Presun na nasledujúci riadok
C-p Presun na predchádzajúci riadok
C-a Presun na zaèiatok riadku
C-e Presun na koniec riadku
M-a Presun spä» na zaèiatok vety
M-e Presun vpred na koniec vety
>> Vyskú¹ajte si teraz niekoµko krát v¹etky tieto príkazy kvôli cviku.
Sú to najpou¾ívanej¹ie príkazy.
Ïal¹ie dva dôle¾ité príkazy pre pohyb kurzoru sú M-< (Meta men¹ie-ako),
ktorý vykoná presun na zaèiatok celého textu, a M-> (Meta väè¹í-ako),
ktorý vykoná presun na koniec celého textu.
Na väè¹ine terminálov je "<" nad èiarkou, tak¾e pre vyvolanie tohto znaku
musíte pou¾i» klávesu Shift. Na týchto termináloch je teda nutné pou¾i»
klávesu Shift aj v prípade príkazu M-<; bez klávesy Shift by ste stlaèili
M-èiarka.
>> Skúste teraz M-< pre presun na zaèiatok tútorialu.
Pou¾ite potom opakovane C-v, aby ste sa opä» vrátili sem.
>> Skúste teraz M-> pre presun na koniec tútorialu.
Pou¾ite potom opakovane M-v, aby ste sa opä» vrátili sem.
Kurzor mô¾ete presúva» tie¾ pomocou kurzorových kláves (klávesy
so ¹ípkami), ak ich Vá¹ terminál má. My Vám v¹ak doporuèujeme nauèi» sa
C-b, C-f, C-n a C-p, a to z troch dôvodov. Za prvé, tieto klávesy fungujú
na v¹etkých typoch terminálov. Za druhé, akonáhle raz získate cvik
v pou¾ívaní Emacsu, zistíte, ¾e pou¾ívánie týchto CTRL znakov je
rýchlej¹ie ako pou¾ívanie kurzorových kláves (preto¾e nemusíte presúva»
ruku z písacej pozície). Za tretie, ak si zvyknete pou¾íva» tieto CTRL-znak
príkazy, µahko sa nauèíte pou¾íva» iné pokroèilé príkazy pre pohyb
kurzoru.
Väè¹ina príkazov Emacsu akceptuje numerický argument; ten pre väè¹inu
príkazov slú¾i ako opakovaè. Poèet opakovaní príkazu zadáte
prostredníctvom stlaèenia C-u nasledovaného stlaèením príslu¹ných èíslic pred
vyvolaním príkazu. Ak máte META (alebo EDIT èi ALT) klávesu, existuje
alternatívna mo¾nos» zadania numerického argumentu: pridr¾te klávesu META
a stlaète príslu¹né èíslice. Doporuèujeme nauèi» sa C-u metódu,
preto¾e tá funguje na akomkoµvek terminále.
Napríklad C-u 8 C-f vykoná presun o osem znakov vpred.
Väè¹ina príkazov pou¾íva numerický argument ako opakovaè. Isté
výnimoèné príkazy ho pou¾ívajú iným spôsobom. Medzi tieto výnimky patrí
C-v a M-v. Ak dostanú numerický argument, posunú obrazovku hore
alebo dole o zodpovedajúci poèet riadkov namiesto obrazoviek. Napríklad
C-u 4 C-v posunie obrazovku o 4 riadky.
>> Skúste teraz stlaèi» C-u 8 C-v.
To by malo posunú» obrazovku o 8 riadkov hore. Pokiaµ by ste ju chceli
posunú» naspä» dole, mô¾ete da» argument príkazu M-v.
Ak pou¾ívate X Windows, mali by ste ma» na µavej strane emacsového okna
vysokú obdå¾nikovú oblas», nazvanú scrollbar. Mô¾ete potom text
posúva» klikaním my¹ou na scrollbar.
>> Skúste stlaèi» prostredné tlaèítko na vrchole zvýraznenej oblasti
vo vnútri scrollbaru. To by malo text posunú» na pozíciu danú tým, ako
vysoko alebo nízko ste klikli.
>> Skúste pri stlaèenom prostrednom tlaèidle posúva» my¹ou hore a dole.
Uvidíte, ako sa text posúva hore a dole podµa toho, ako
hýbete my¹ou.
* KEÏ EMACS NEREAGUJE
---------------------
Ak Emacs prestane reagova» na Va¹e príkazy, mô¾ete prebiehajúcu
èinnos» bezpeène zastavi» pomocou C-g. Pomocou C-g mô¾ete zastavi»
príkaz, ktorého èinnos» trvá príli¹ dlho.
C-g mô¾ete pou¾i» tie¾ pre odstránenie numerického argumentu príkazu,
ktorý nechcete dokonèi».
>> Stlaète C-u 100 pre vytvorenie numerického argumentu 100 a potom
stlaète C-g. Teraz stlaète C-f. Kurzor by sa mal posunú» iba
o jeden znak, preto¾e ste argument zru¹ili prostredníctvom
C-g.
Ak ste omylom stlaèili <ESC>, mô¾ete sa ho zbavi» pomocou C-g.
* DEAKTIVOVANÉ PRÍKAZY
----------------------
Niektoré príkazy Emacsu sú "deaktivované" ("disabled"), aby ich
zaèínajúci pou¾ívatelia nemohli vyvola» náhodne.
Ak vyvoláte niektorý z deaktivovaných príkazov, Emacs zobrazí hlásenie
oznamujúce, ktorý príkaz to bol, s otázkou, èi chcete tento príkaz
vykona».
Ak naozaj chcete príkaz vyskú¹a», stlaète medzerník ako odpoveï
na túto otázku. Zvyèajne, ak nechcete deaktivovaný príkaz
vykona», odpovedzte na túto otázku pomocou "n".
>> Stlaète <ESC> : (èo je deaktivovaný príkaz),
potom na otázku odpovedzte n.
* OKNÁ
------
Emacs mô¾e ma» niekoµko okien (windows), pritom ka¾dé z nich zobrazuje svoj
vlastný text. Ako viac okien pou¾íva», objasníme neskôr. Teraz chceme
objasni», ako sa zbavi» nadbytoèných okien a vráti» sa do základnej
jednookennej editácie. Je to jednoduché:
C-x 1 Jedno okno (tj. zru¹enie v¹etkých ostatných okien)
Teda vlo¾enie Control-x nasledované èíslicou 1. C-x 1 roz¹íri okno
obsahujúce kurzor cez celú obrazovku. Zru¹í to v¹etky ostatné okná.
>> Stlaète Control-h k Control-f.
Pozorujte, ako sa aktuálne okno zmen¹í a objaví sa nové okno
kvôli zobrazeniu dokumentácie pre príkaz Control-f.
>> Stlaète C-x 1 a pozorujte, ako okno s dokumentáciou zmizne.
* VKLADANIE A MAZANIE
---------------------
Ak chcete vlo¾i» text, proste ho napí¹te. Znaky, ktoré vidíte,
ako A, 7, *, atï., sú Emacsom chápané ako text a vkladané okam¾ite.
Pre vlo¾enie znaku nového riadku stlaète <Return> (klávesu Enter).
Posledný znak, ktorý ste napísali, mô¾ete zmaza» stlaèením <Delete>.
<Delete> je klávesa, ktorá mô¾e by» na klávesnici oznaèená "Del".
V niektorých prípadoch ako <Delete> slú¾i klávesa "Backspace", av¹ak nie
v¾dy!
V¹eobecnej¹ie, <Delete> ma¾e znak bezprostredne pred momentálnou pozíciou
kurzoru.
>> Vykonajte to teraz -- napí¹te niekoµko znakov a potom ich zma¾te
niekoµkými stlaèeniami <Delete>. Nebojte sa zmien v tomto súbore;
originálny tútorial sa nezmení. Toto je Va¹a osobná kópia.
Keï sa riadok textu zväè¹í natoµko, ¾e presiahne jeden riadok obrazovky,
je zobrazený na viacerých riadkoch obrazovky. Riadok textu, ktorý pokraèuje na
ïal¹om riadku obrazovky, je indikovaný spätným lomítkom ("\") na pravom
okraji obrazovky.
>> Vkladajte text, pokiaµ nedosiahnete pravého okraju, a pokraèujte vo
vkladaní. Objaví sa Vám pokraèovací riadok.
>> Pou¾ite <Delete> pre zmazanie textu, pokiaµ se riadok textu opä» nevojde na
jeden riadok obrazovky. Pokraèovací riadok zmizne.
Znak nového riadku mô¾ete zmaza» ako ktorýkoµvek iný znak. Zmazanie
znaku nového riadku medzi dvoma riadkami spôsobí ich spojenie do jediného
riadku. Ak je výsledný riadok príli¹ dlhý na to, aby sa vo¹iel na ¹írku
obrazovky, bude zobrazený pokraèovacím riadkom.
>> Presuòte kurzor na zaèiatok riadku a stlaète <Delete>. To tento
riadok spojí s riadkom predchádzajúcim.
>> Stlaète <Return> pre znovuvlo¾enie zmazaného znaku nového riadku.
Spomeòte si, ¾e väè¹ina príkazov Emacsu mô¾e dosta» poèet opakovaní;
vrátane textových znakov. Opakovanie textových znakov ich vlo¾í
niekoµko krát.
>> Vyskú¹ajte si to -- stlaète C-u 8 * pre vlo¾enie ********.
Teraz u¾ poznáte najzákladnej¹ie spôsoby, ako nieèo v Emacse napísa» a ako
opravova» chyby. Mô¾ete ale tie¾ maza» text po slovách alebo po riadkoch.
Tu je zhrnutie operácií pre mazanie textu:
<Delete> Zmazanie znaku bezprostredne pred kurzorom
C-d Zmazanie znaku nasledujúceho za kurzorom
M-<Delete> Zru¹enie slova bezprostredne pred kurzorom
M-d Zru¹enie slova nasledujúceho za kurzorom
C-k Zru¹enie textu od pozície kurzoru do konca riadku
M-k Zru¹enie textu do konca aktuálnej vety
V¹imnite si, ¾e <Delete> a C-d, resp. M-<Delete> a M-d, roz¹irujú
paralelu zaèatú C-f a M-f (pravda, <Delete> naozaj nie je control
znak, ale s tým sa nebudeme trápi»). C-k a M-k sú ako C-e a M-e v zmysle
vz»ahu riadkov k vetám.
¥ubovoµnú èas» buffera mô¾ete zru¹i» aj nasledujúcim spôsobom. Presuòte sa
na koniec tejto èasti a stlaète C-＠ alebo C-SPC (µubovoµnú z týchto
kombinácií). (SPC znamená medzerník.) Presuòte sa na druhý koniec tejto
èasti a stlaète C-w. Text medzi týmito pozíciami bude zru¹ený.
>> Presuòte kurzor na písmeno L na zaèiatku predchádzajúceho odstavca.
>> Stlaète C-SPC. Emacs by mal zobrazi» v spodnom riadku obrazovky správu
"Mark set".
>> Presuòte kurzor na písmeno c v slove "koniec" na druhom riadku
odstavca.
>> Stlaète C-w. Text, ktorý zaèína písmenom L a konèí pred písmenom "c"
bude zru¹ený.
Uvedomte si, ¾e rozdiel medzi "ru¹ením" ("killing") a "mazaním"
("deleting") je ten, ¾e "zru¹ené" veci mô¾u by» vhodené spä», zatiaµ èo
"zmazané" nie. V¹eobecne príkazy, ktoré mô¾u zmaza» väè¹ie mno¾stvo
textu, ukladajú text, zatiaµ èo príkazy, ktoré ma¾ú jediný znak alebo
iba prázdne riadky a medzery, mazaný text neukladajú.
>> Presuòte kurzor na zaèiatok neprázdneho riadku.
Potom stlaète C-k pre zru¹enie textu na tomto riadku.
>> Stlaète C-k druhý krát. Uvidíte, ¾e to zru¹í znak nového riadku, ktorý
je za týmto riadkom.
V¹imnite si, ¾e jedno C-k zru¹í obsah riadku a druhé C-k zru¹í riadok
samotný a posunie v¹etky ïal¹ie riadky hore. C-k spracováva numerický
argument ¹peciálne: zru¹í zodpovedajúci poèet riadkov VRÁTANE ich
obsahu. To u¾ nie je opakovanie. C-u 2 C-k zru¹í dva riadky a ich
obsah; dvojité stlaèenie C-k by toto obvykle nespravilo.
Vracanie textov spä» sa nazýva "vhadzovanie" ("yanking"). (Predstavte
si opätovné vhadzovanie, vracanie spä» textu, ktorý bol odstránený.)
Zmazaný text mô¾ete vhodi» buï na to isté miesto, odkiaµ bol zmazaný,
alebo na iné miesto v bufferi, alebo dokonca aj do iného súboru.
Text mô¾ete vhodi» aj viac krát, keï vytvárate jeho ïal¹ie kópie.
Príkazom na vhadzovanie je C-y. Tento príkaz vlo¾í posledný zmazaný
text na pozíciu, na ktorej sa nachádza kurzor.
>> Skúste to; stlaète C-y pre vhodenie textu spä».
Ak stlaèíte C-k niekoµko krát po sebe. v¹etok zmazaný text je ulo¾ený
spolu tak, aby bolo mo¾né vhodi» spä» v¹etky riadky naraz.
>> Stlaète niekoµko krát C-k.
Teraz obnovte naposledy zru¹ený text:
>> Stlaète C-y. Potom posuòte kurzor o niekoµko riadkov ni¾¹ie a stlaète
C-y znovu. Teraz vidíte, ako je mo¾né kopírova» text.
Èo keï máte nejaký text, ktorý by ste radi vhodili spä» a potom zru¹íte
nieèo iného? C-y by vlo¾ilo posledný zru¹ený text. Ale predchádzajúci
text ni je stratený. Mô¾ete ho získa» spä» pou¾itím príkazu M-y. Potom,
èo spravíte C-y pre získanie posledného zru¹eného textu, stlaèenie M-y
vymení tento vhodený text za predchádzajúci zru¹ený text. Ïal¹ími a
ïal¹ími stlaèeniami M-y dostávate predchádzajúce a predchádzajúce zru¹ené
texty. Keï dosiahnete text, ktorý hµadáte, nemusíte s ním pre jeho
uchovanie niè ïal¹ieho robi». Jednoducho vhodený text ponechajte, kde
je, a pokraèujte v editácii.
Ak opakujete M-y dostatoène dlho, dostanete se spä» k východziemu
bodu (posledne zru¹enému textu).
>> Zru¹te riadok, presuòte kurzor niekam inam a zru¹te iný riadok.
Potom vykonajte C-y pre vrátenie druhého zru¹eného riadku.
Potom stlaète M-y a vhodený riadok bude nahradený prvým zru¹eným riadkom.
Opakujte M-y a pozorujte, èo dostávate. Pokraèujte v tom, pokiaµ sa
znova neobjaví druhý zru¹ený riadok a potom niekoµko ïal¹ích.
Ak chcete, mô¾ete skúsi» preda» M-y kladné a záporné argumenty.
* UNDO
------
Ak vykonáte v texte zmenu a potom zistíte, ¾e to bol omyl, mô¾ete
zmenu vráti» príkazom undo, C-x u.
C-x u obvykle vráti zmeny vykonané jedným príkazom; pokiaµ C-x u
zopakujete niekoµko krát po sebe, ka¾dé opakovanie vráti jeden ïal¹í
príkaz.
Sú ale dve výnimky: príkazy, ktoré nemenia text, sa nepoèítajú (to
zahàòa príkazy pre pohyb kurzoru a rolovanie) a znaky vkladajúce
samy seba sú obvykle spracovávané v skupinách a¾ po 20. (To je kvôli
tomu, aby sa zredukoval poèet C-x u nutných pre vrátenie vkladaného
textu.)
>> Zru¹te tento riadok pomocou C-k, stlaète potom C-x u a riadok by sa mal
znova objavi».
Alternatívny undo príkaz je C-_; pracuje rovnako ako C-x u, je v¹ak
menej pracné ho aplikova» niekoµko krát za sebou. Nevýhodou C-_ je, ¾e
na niektorých klávesniciach nie je jasné, ako ho vyvola». To je dôvod,
preèo ponúkame aj C-x u. Na niektorých termináloch mô¾ete C-_ vyvola»
stlaèením / pri stlaèenom CTRL.
Numerický argument pre C-_ a C-x u funguje ako poèet opakovaní.
Pomocou príkazu undo mô¾ete vráti» zru¹ený aj zmazaný text. Rozdiel medzi
mazaním a ru¹ením textu ovplyvòuje mo¾nos» vhodenia tohto textu pomocou
C-y, neovplyvòuje ale mo¾nosti príkazu undo.
* SÚBORY
--------
Aby text, ktorý editujete, zostal trvale uchovaný, musíte ho ulo¾i» do
súboru. Inak by bol po ukonèení Emacsu stratený. Svoju editáciu
spojíte so súborom "vyhµadaním" ("finding") súboru. (Tie¾ sa to
nazýva "nav¹tívenie" ("visiting") súboru.)
Vyhµadanie súboru znamená, ¾e vidíte jeho obsah v Emacse. V mnohých
ohµadoch je to, ako by ste editovali priamo ten súbor. Napriek tomu zmeny,
ktoré prostredníctvom Emacsu robíte, sa nestanú trvalými, pokiaµ tieto
zmeny do súboru "neulo¾íte" ("save"). Tým sa zamedzí nechcenému ponechaniu
èiastoène zmeneného súboru v systéme. Dokonca aj keï súbor ulo¾íte,
Emacs uchová pôvodný súbor pod zmeneným názvom pre prípad, ¾e by ste
zistili, ¾e va¹e úpravy boli chybné.
Keï sa pozriete do dolnej èasti obrazovky, uvidíte riadok, ktorý zaèína a
konèí pomlèkami a na zaèiatku má "2J:-- TUTORIAL.sk" alebo nieèo podobného.
Táto èas» obrazovky obvykle obsahuje meno súboru, ktorý je práve
nav¹tívený. Akurát teraz máte nav¹tívený súbor nazvaný "TUTORIAL.sk",
ktorý je Va¹ou osobnou èmáraciou kópiou tútorialu Emacsu. Keï v Emacse
vyhµadáte súbor, jeho meno sa objaví presne na tom mieste.
Príkazy pre vyhµadávanie a ukladanie súborov sa na rozdiel od ostatných
príkazov, ktoré ste sa zatiaµ nauèili, skladajú z dvoch znakov. Oba
zaèínajú znakom Control-x. Existuje celá sada príkazov zaèínajúcich na
Control-x; veµa z nich pracuje so súbormi, buffermi a podobnými vecami.
Tieto príkazy sú dlhé dva, tri alebo ¹tyri znaky.
Ïal¹ou vecou súvisiacou s príkazom pre vyhµadanie súboru je to, ¾e musíte
poveda», ktoré meno súboru chcete. Hovoríme, ¾e príkaz "èíta argument
z terminálu" (v tomto prípade je argumentom meno súboru). Potom, èo
vyvoláte príkaz
C-x C-f Vyhµadanie súboru
Emacs sa Vás opýta na meno súboru. Meno súboru, ktoré pí¹ete, sa
objavuje v spodnom riadku obrazovky, ktorý sa v tejto situácii nazýva
minibuffer. Pre editáciu mena súboru mô¾ete pou¾íva» obvyklé editaèné
príkazy Emacsu.
Zadávanie mena súboru (v¹eobecne akýkoµvek vstup z minibuffera) mô¾ete
zru¹i» príkazom C-g.
>> Stlaète C-x C-f a potom C-g. To minibuffer zru¹í a tie¾ to zru¹í
príkaz C-x C-f, ktorý minibuffer pou¾il. Tak¾e nevyhµadáte ¾iadny
súbor.
Po napísaní mena súboru stlaète <Return>.
Príkaz C-x C-f potom zaène pracova» a vyhµadá súbor, ktorý ste zvolili.
Po skonèení príkazu C-x C-f minibuffer zmizne.
Po malej chvílke sa obsah súboru objaví na obrazovke a mô¾ete ho
editova». Keï chcete zmeny natrvalo ulo¾i», pou¾ite príkaz
C-x C-s Ulo¾enie súboru
To skopíruje text z Emacsu do súboru. Keï to spravíte prvý krát, Emacs
premenuje pôvodný súbor na súbor s novým menom, aby nebol stratený.
Nové meno je vytvorené pridaním "~" na koniec pôvodného mena súboru.
Keï je ukladanie dokonèené, Emacs zobrazí meno zapísaného súboru.
Mali by ste uklada» rozumne èasto, aby ste nestratili príli¹ veµa práce
v prípade pádu systému.
>> Stlaète C-x C-s pre ulo¾enie Va¹ej kópie tútorialu.
Malo by to zobrazi» "Wrote ...TUTORIAL.sk" v spodnom riadku obrazovky.
POZNÁMKA: Na niektorých systémoch spôsobí stlaèenie C-x C-s zatuhnutie
obrazovky a nevidíte ¾iadny ïal¹í výstup z Emacsu. To znamená, ¾e
"vlastnos»" operaèného systému nazvaná "flow control" zachytáva C-s a
nepustí ho k Emacsu. Pre odtuhnutie obrazovky stlaète C-q. Potom
v sekcii "Spontaneous Entry to Incremental Search" v manuále Emacsu
vyhµadajte radu, ako sa vysporiada» s touto "vlastnos»ou".
Existujúci súbor mô¾ete vyhµada», aby ste ho mohli prehliada» alebo
editova». Mô¾ete tie¾ vyhµada» súbor, ktorý e¹te neexistuje. To je
spôsob, akým sa dá vytvori» súbor v Emacse: vyhµadajte súbor, ktorý
bude na zaèiatku prázdny a potom zaènite vklada» text urèený pre tento
súbor. Keï po¾iadate o ulo¾enie, Emacs skutoène vytvorí súbor
s textom, ktorý ste vlo¾ili. Od tej chvíle sa potom mô¾ete cíti», ako
keby ste editovali u¾ existujúci súbor.
* BUFFERY
---------
Ak vyhµadáte pomocou C-x C-f druhý súbor, prvý súbor v Emacse
zostáva. Mô¾ete sa doò spä» prepnú» jeho opätovným vyhµadaním
pomocou C-x C-f. Týmto spôsobom mô¾ete do Emacsu dosta» pomerne veµa
súborov.
>> Vytvorte súbor pomenovaný "foo" stlaèením C-x C-f foo <Return>.
Potom vlo¾te nejaký text, zmeòte ho a ulo¾te "foo" stlaèením C-x C-s.
Nakoniec stlaète C-x C-f TUTORIAL.sk <Return>, èím sa vrátite spä» do
tútorialu.
Emacs ukladá text ka¾dého súboru do objektu nazývaného "buffer".
Vyhµadanie súboru vytvorí v Emacse nový buffer. Ak chcete vidie» zoznam
bufferov, ktoré momentálne existujú vo Va¹om procese Emacs, stlaète:
C-x C-b Zoznam bufferov
>> Skúste teraz C-x C-b.
Uvidíte, ¾e ka¾dý buffer má v zozname meno a mô¾e tam ma» tie¾ meno
súboru, ktorého text obsahuje. Niektoré buffery nezodpovedajú súborom.
Napríklad buffer pomenovaný "*Buffer List*" nemá ¾iadny súbor. Je to
buffer, ktorý obsahuje zoznam bufferov vytvorený pomocou C-x C-b.
AKÝKO¥VEK text, ktorý vidíte v emacsovom okne, je v¾dy súèas»ou
nejakého bufferu.
>> Stlaète C-x 1, aby ste sa zbavili zoznamu bufferov.
Ak zmeníte text jedného súboru a potom vyhµadáte iný súbor,
nespôsobí to ulo¾enie prvého súboru. Jeho zmeny zostávajú v Emacse
uchované v jemu zodpovedajúcom buffere. Vytvorenie a úprava druhého
súboru nemá ¾iadny vplyv na buffer prvého súboru. To je veµmi
u¾itoèné, ale tie¾ to znamená, ¾e potrebujete vhodný spôsob, ako ulo¾i»
buffer prvého súboru. Nutnos» prepnú» sa spä» pomocou C-x C-f, aby
ho bolo mo¾né ulo¾i» prostredníctvom C-x C-s, by bola nemiestne
ob»a¾ujúca. Tak¾e máme
C-x s Ulo¾enie niektorých bufferov
C-x s sa Vás spýta na ka¾dý buffer, ktorý obsahuje zmeny, ktoré ste
neulo¾ili. Pre ka¾dý taký buffer sa Vás spýta, èi ho má ulo¾i».
>> Vlo¾te riadok textu a potom stlaète C-x s.
Emacs by sa Vás mal opýta», èi má by» ulo¾ený buffer nazvaný TUTORIAL.sk.
Odpovedzte na túto otázku áno (yes) stlaèením "y".
* ROZ©IROVANIE SADY PRÍKAZOV
----------------------------
Existuje omnoho, omnoho viac príkazov Emacsu, ako tie, ktoré by vôbec mohli
by» rozmiestnené na v¹etky control a meta znaky. Emacs tento problém
obchádza prostredníctvom X (eXtend) príkazu. Ten vzniká dvoma spôsobmi:
C-x Znakový eXtend. Nasledovaný jedným znakom.
M-x Pomenovaný príkaz eXtend. Nasledovaný dlhým názvom.
To sú príkazy, ktoré sú v¹eobecne u¾itoèné, ale menej èasto pou¾ívané
ako tie, ktoré ste sa u¾ nauèili. U¾ ste videli dva z nich: súborové
príkazy C-x C-f pre vyhµadanie a C-x C-s pre ulo¾enie. Iný príklad je
príkaz pre ukonèenie Emacsu -- tj. príkaz C-x C-c. (Nemajte obavy
o stratu zmien, ktoré ste spravili; C-x C-c ponúkne ulo¾enie ka¾dého
zmeneného súboru pred tým, ne¾ sa Emacs skonèí.)
C-z je príkaz na *doèasné* opustenie Emacsu -- mô¾ete sa po òom do
spusteného Emacsu vráti».
Na systémoch, ktoré to umo¾òujú, C-z Emacs "pozastaví"; tzn. vráti Vás
do shellu, ale Emacs neskonèí. V najbe¾nej¹ích shelloch sa mô¾ete do
Emacsu vráti» príkazom `fg' alebo pomocou `%emacs'.
Na systémoch, ktoré pozastavovanie procesov nemajú implementované, C-z
vytvorí subshell be¾iaci pod Emacsom, aby Vám dal ¹ancu spusti» iné
programy a potom sa do Emacsu vráti»; nevykoná teda pravé opustenie
Emacsu. V tom prípade je obvyklou cestou návratu zo subshellu do Emacsu
shellový príkaz `exit'.
Chvíle pre pou¾itie C-x C-c nastane, keï sa chystáte odhlási» sa zo
systému. Správne je to tie¾ pri ukonèovaní Emacsu vyvolaného po¹tovým
programom a rôznymi inými utilitami, preto¾e tie nemusia vedie», ako si
poradi» s pozastavením Emacsu. Napriek tomu za normálnych okolností, pokiaµ
sa nechystáte odhlási», je lep¹ie Emacs pozastavi» pomocou C-z ako ho
ukonèi».
Existuje mnoho C-x príkazov. Tu je zoznam tých, ktoré ste sa u¾ nauèili:
C-x C-f Vyhµadanie súboru
C-x C-s Ulo¾enie súboru
C-x C-b Zoznam bufferov
C-x C-c Ukonèenie Emacsu
C-x u Undo
Pomenované eXtended príkazy sú príkazy, ktoré sú pou¾ívané e¹te
menej, alebo príkazy, ktoré sú pou¾ívané iba v istých módoch.
Príkladom je príkaz replace-string, ktorý globálne nahradí jeden re»azec
iným. Keï stlaèíte M-x, vypí¹e sa na spodnom riadku obrazovky prompt
M-x a vy by ste mali zada» meno príkazu; v tomto prípade
"replace-string". Jednoducho napí¹te "repl s<TAB>" a Emacs názov doplní.
Skonèite zadávanie mena príkazu pomocou <Return>.
Príkaz replace-string vy¾aduje dva argumenty -- re»azec, ktorý má by»
nahradený, a re»azec, ktorý ho má nahradi». Ka¾dý argument musíte
ukonèi» pomocou <Return>.
>> Presuòte kurzor na prázdny riadok dva riadky pod týmto.
Potom napí¹te M-x repl s<Return>zmenil<Return>modifikoval<Return>.
V¹imnite si, ako sa tento riadok zmenil: nahradili ste slovo
z-m-e-n-i-l slovom "modifikoval", kdekoµvek sa za aktuálnou pozíciou
kurzoru vyskytlo.
* AUTOMATICKÉ UKLADANIE
-----------------------
Ak ste spravili zmeny v súbore, ale nemáte ich e¹te ulo¾ené,
mô¾u by» v prípade páde systému stratené. Aby vás Emacs pred tým ochránil,
periodicky zapisuje "auto save" súbor pre ka¾dý súbor, ktorý
editujete. Meno auto save súboru má na zaèiatku a na konci #;
napríklad ak sa Vá¹ soubor nazýva "hello.c", jeho auto save
súbor sa nazýva "#hello.c#". Ak súbor ulo¾íte normálnym spôsobem,
Emacs auto save súbor zma¾e.
Ak nastane pád systému, mô¾ete svoje úpravy obnovi» z auto-save
súboru, a to normálnym vyhµadaním súboru (toho, ktorý ste editovali,
nie auto save súboru) a následným spustením M-x recover-file<return>.
Na ¾iados» o potvrdenie odpovedzte zadaním yes<return> pre pokraèovanie a
obnovenie auto-save dát.
* ECHO OBLAS«
-------------
Keï Emacs vidí, ¾e pí¹ete príkazy pomaly, ukazuje Vám ich v spodnej
èasti obrazovky v oblasti nazývanej "echo oblast". Echo oblas» obsahuje
dolný riadok obrazovky.
* STAVOVÝ RIADOK
----------------
Riadok bezprostredne nad echo oblas»ou sa nazýva "stavový riadok"
("mode line").
Stavový riadok vraví nieèo ako:
2J:** TUTORIAL.sk (Fundamental)--L670--58%----------------
Tento riadok podáva u¾itoènú informáciu o stave Emacsu a texte, ktorý
editujete.
U¾ viete, èo znamená meno súboru -- je to súbor, ktorý ste vyhµadali.
-NN%-- oznaèuje Va¹u aktuálnu pozíciu v texte; vraví, ¾e NN percent textu
je nad horným okrajom obrazovky. Ak je zaèiatok súboru na obrazovke, je
tu --Top-- a nie --00%--. Ak je koniec textu na obrazovke, je tu
--Bot--. Ak sa dívate na tak malý text, ¾e sa celý vojde na obrazovku,
stavový riadok vraví --All--.
Hviezdièky blízko zaèiatku znamenajú, ¾e ste text zmenili. Tesne po
vyhµadaní alebo ulo¾ení súboru v tejto èasti stavového riadku nie sú ¾iadne
hviezdièky, iba pomlèky.
Èas» stavového riadku v zátvorkách vraví, v akých editaèných módoch sa
nachádzate. Implicitný mód je Fundamental, èo je ten, ktorý momentálne
pou¾ívate. Je príkladom hlavného módu ("major mode").
Emacs má celý rad hlavných módov. Niektoré z nich sú urèené pre
editovanie rôznych programovacích jazykov a/alebo textov ako napr. Lisp mód,
Text mód, atï. V µubovoµnom okamihu je aktívny práve jeden hlavný mód a
jeho meno je mo¾né nájs» v stavovom riadku na mieste, kde je teraz
"Fundamental".
Ka¾dý hlavný mód mení chovanie niektorých príkazov. Napríklad existujú
príkazy pre vytváranie komentárov v programe, a preto¾e ka¾dý programovací
jazyk má inú predstavu o tom, ako má komentár vyzera»,
musí ka¾dý hlavný mód vklada» komentáre inak. Ka¾dý hlavný mód je
vlastne meno extended príkazu, ktorým sa do tohoto módu mô¾ete
prepnú». Napríklad M-x fundamental-mode je príkaz pre prepnutie sa do
Fundamental módu.
Ak sa chystát meni» slovenský text, ako napríklad tento súbor,
pravdepodobne by ste mali pou¾i» Text mód.
>> Napí¹te M-x text-mode<Return>.
Nebojte sa, ¾iadny z príkazov, ktoré ste sa nauèili, chovanie Emacsu nijako
významne nezmení. Mô¾ete si ale v¹imnú», ¾e M-f a M-b teraz pracujú
s apostrofmi ako so súèas»ou slova. Pred tým, vo Fundamental móde, M-f
a M-b pracovali s apostrofmi ako oddeµovaèmi slov.
Hlavné módy obyèajne robia men¹ie zmeny, ako bola táto: príkazy väè¹inou
robia "to isté", ale v ka¾dom hlavnom móde pracujú trochu inak.
Dokumentáciu k aktuálnemu hlavnému módu si mô¾ete zobrazi» stlaèením C-h m.
>> Raz alebo viac krát pou¾ite C-u C-v, aby ste tento riadok dostali
na vrchol obrazovky.
>> Stlaète C-h m, aby ste videli, ako sa Text mód lí¹i od Fundamental
módu.
>> Stlaète C-x 1 pre odstránenie dokumentácie z obrazovky.
Hlavné módy sa nazývajú hlavné preto, ¾e tie¾ existujú vedµaj¹ie módy
(minor modes). Vedµaj¹ie módy nie sú alternatívou k hlavným módom, ale
ich malé modifikácie. Ka¾dý vedµaj¹í mód mô¾e by» zapnutý alebo vypnutý
sám o sebe nezávisle na v¹etkých ostatných vedµaj¹ích módoch a nezávisle na
hlavnom móde. Tak¾e nemusíte pou¾íva» ¾iadny vedµaj¹í mód alebo mô¾ete
pou¾íva» jeden vedµaj¹í mód alebo µubovoµnú kombináciu niekoµkých
vedµaj¹ích módov.
Jedným z veµmi u¾itoèných vedµaj¹ích módov, hlavne pre úpravy slovenských
textov, je Auto Fill mód. Keï je tento mód zapnutý, Emacs zalomí riadok
medzi dvoma slovami, kedykoµvek vkladáte text a riadok sa stane príli¹
dlhým.
Auto Fill mód mô¾ete zapnú» vykonaním M-x auto-fill-mode<Return>.
Ak je tento mód zapnutý, mô¾ete ho vypnú» vykonaním M-x
auto-fill-mode<Return>. Ak je mód vypnutý, tento príkaz ho zapína,
a ak je mód zapnutý, tak ho tento príkaz vypína. Vravíme, ¾e tento
príkaz prepína ("toggles") tento mód.
>> Napí¹te teïa M-x auto-fill-mode<Return>. Potom vkladajte "asdf " stále
dookola tak dlho, pokiaµ neuvidíte, ako sa vkladaný riadok rozdelí na dva
riadky. Do textu musíte vklada» medzery preto, ¾e Auto Fill mód
zalamuje riadky iba v medzerách.
Okraj je obvykle nastavený na 70 znakov, ale mô¾ete to zmeni» príkazom
C-x f. Hodnotu okraju, ktorú si prajete, by ste mali preda» ako
numerický argument.
>> Napí¹te C-x f s argumentom 20. (C-u 2 0 C-x f).
Potom napí¹te nejaký text a pozorujte, ako Emacs vypåòa riadky po
20. znakoch. Potom nastavte okraj spä» na 70 opätovným pou¾itím
C-x f.
Ak spravíte zmeny uprostred odstavca, Auto Fill mód ho nepreformátuje.
Pre preformátovanie odstavca stlaète M-q (Meta-q) s kurzorom vnútri
odstavca.
>> Presuòte kurzor do predchádzajúceho odstavcu a stlaète M-q.
* VYH¥ADÁVANIE
--------------
Emacs vie v texte vyhµadáva» re»azce (tj. skupiny spojených znakov alebo
slov) smerom vpred alebo vzad. Hµadanie re»azca je príkaz presúvajúci
kurzor; presunie kurzor na najbli¾¹ie miesto, kde sa tento re»azec nachádza.
Vyhµadávací príkaz Emacsu sa lí¹i od vyhµadávacích príkazov väè¹iny
editorov v tom zmysle, ¾e je "inkrementálny". To znamená, ¾e vyhµadávanie
sa robí u¾ v okam¾iku, keï zadávate hµadaný re»azec.
Príkaz pre hµadanie vpred je C-s a pre hµadanie vzad C-r.
POZOR! E¹te to neskú¹ajte.
Keï stlaèíte C-s, uvidíte v echo oblasti prompt "I-search". To Vám
vraví, ¾e Emacs sa nacháza v stave, ktorý sa nazýva inkrementálne hµadanie,
a èaká, kým mu zadáte, èo chcete hµada». <RET> hµadanie ukonèí.
>> Teraz zaènite hµadanie stlaèením C-s. POMALY, písmeno po písmene, pí¹te
slovo 'kurzor'. Po ka¾dom písmene si v¹imnite, èo sa deje s kurzorom.
Teraz ste vyhµadali "kurzor" prvý krát.
>> Stlaète C-s znova, aby ste na¹li ïal¹í výskyt slova "kurzor".
>> Teraz ¹tyri krát stlaète <Delete> a pozerajte, ako sa kurzor
presúva.
>> Stlaète <RET> pre ukonèenie hµadania.
Videli ste, èo sa stalo? Emacs sa v inkrementálnom hµadaní pokú¹a
prejs» na ïal¹í výskyt re»azca, ktorý ste dosiaµ napísali. Ak chcete
prejs» na ïal¹í výskyt 'kurzor', jednoducho stlaète C-s zas.
Ak u¾ ¾iadny taký výskyt nie je, Emacs pípne a povie Vám, ¾e
hµadanie momentálne "zlyháva", C-g hµadanie ukonèí.
POZNÁMKA: Na niektorých systémoch stlaèenie C-s spôsobí zatuhnutie
obrazovky a neuvidíte ¾iadny ïal¹í výstup z Emacsu. To znamená, ¾e
"vlastnos»" operaèného systému nazvaná "flow control" zachytáva C-s a
nepustí ho k Emacsu. Pre odtuhnutie obrazovky stlaète C-q. Potom
vyhµadajte v sekcii "Spontaneous Entry to Incremental Search" v manuále
Emacsu radu, ako obís» túto "vlastnos»".
Ak uprostred inkrementálneho hµadania stlaèíte <Delete>, uvidíte,
¾e posledný znak v hµadanom re»azci zmizne a hµadanie sa vracia na posledné
miesto hµadania. Predpokladajme napríklad, ¾e ste napísali "c", aby ste
na¹li prvý výskyt "k". Ak teraz stlaèíte "u", kurzor sa presunie na
prvý výskyt "ku". Teraz stlaète <Delete>. To vyma¾e "u" z hµadaného
re»azca a kurzor sa presunie spä» na prvý výskyt "k".
Ak uprostred hµadania stlaèíte control alebo meta znak (s niekoµkými
výnimkami -- znaky, ktoré sú ¹peciálne v hµadaní, ako C-s a C-r),
hµadanie bude ukonèené.
C-s zaèína hµadanie, ktoré hµadá akýkoµvek výskyt hµadaného re»azca ZA
aktuálnu pozíciu kurzoru. Ak chcete nieèo hµada» v predchádzajúcom texte,
stlaète namiesto C-s C-r. V¹etko, èo sme povedali o C-s, platí tie¾ o C-r
okrem toho, ¾e smer hµadania je opaèný.
* VIAC OKIEN
------------
Jednou z pekných vlastností Emacsu je to, ¾e mô¾e na obrazovke zobrazi»
viac okien súèasne.
>> Presuòte kurzor na tento riadok a stlaète C-u 0 C-l.
>> Ak stlaèíte C-x 2, obrazovka sa rozdelí na dve okná.
Obidve okná zobrazujú tento tútorial. Kurzor zostáva na vrchu okna.
>> Stlaète C-M-v pre rolovanie spodného okna.
(Ak nemáte skutoènú klávesu Meta, stlaète ESC C-v.)
>> Stlaète C-x o ("o" ako "other") pre presun kurzoru do dolného okna.
>> Pou¾ite C-v a M-v v spodnom okne pre jeho rolovanie.
Pokraèujte v èítaní týchto in¹trukcií v hornom okne.
>> Znovu stlaète C-x o pre presun kurzoru spä» do horného okna.
Kurzor v hornom okne je presne na mieste, kde bol pôvodne.
Mô¾ete ïalej pou¾íva» C-x o pre prepínanie medzi oknami. Ka¾dé okno má svoju
vlastnú pozíciu kurzoru, ale kurzor zobrazuje iba jedno okno.
V¹etky obvyklé editaèné príkazy platia pre okno, v ktorom sa nachádza
kurzor. Toto okno nazývame "aktívne okno" ("selected window").
Príkaz C-M-v je veµmi u¾itoèný, ak v jednom okne editujete text a
druhé okno pou¾ívate iba pre prehµad. Mô¾ete necháva» kurzor stále
v okne, kde editujete, a postupova» po druhom okne pomocou C-M-v.
C-M-v je príkladom CONTROL-META znaku. Ak máte skutoènú META klávesu,
mô¾ete vyvola» C-M-v pridr¾aním oboch kláves CTRL a META pri stlaèení v.
Nezále¾í na tom, èi stlaèíte ako prvú klávesu CTRL alebo META, preto¾e obe
tieto klávesy fungujú ako modifikátory kláves, ktoré stlaèíte.
Ak nemáte skutoènú META klávesu, mô¾ete namiesto nej pou¾i» ESC, na
poradí zále¾í: musíte stlaèi» ESC a potom CTRL-v; CTRL-ESC v by
nefungovalo. To preto, lebo ESC je samostatný znak, a nie modifikátor.
>> Stlaète C-x 1 (v hornom okne), aby ste sa zbavili dolného okna.
(Ak by ste C-x 1 stlaèili v dolnom okne, odstránilo by to horné okno.
Chápte tento príkaz ako "ponechaj akurát jedno okno -- to, v ktorom
akurát som".)
Nemusíte v oboch oknách zobrazova» ten istý buffer. Ak pou¾ijete
C-x C-f pre vyhµadanie súboru v jednom z okien, druhé okno sa nezmení.
Mô¾ete vyhµadáva» súbory v oboch oknách nezávisle.
Tu je ïal¹í spôsob, ako vyu¾i» dve okná na zobrazenie dvoch rôznych vecí:
>> Stlaète C-x 4 C-f nasledované menom niektorého z Va¹ich súborov.
Dokonèite to pomocou <Return>. Vidíte zadaný súbor v dolnom okne.
Presunul sa tam aj kurzor.
>> Stlaète C-x o pre presun spä» do horného okna a C-x 1 pre zmazanie
dolného okna.
* REKURZÍVNE EDITAÈNÉ ÚROVNE
----------------------------
Obèas sa dostanete do nieèoho, èo sa nazýva "rekurzívna editaèná úroveò"
("recursive editing level"). To je indikované hranatými zátvorkami v
stavovom riadku obklopujúcemu zátvorky okolo mena hlavného módu.
Napríklad mô¾ete vidie» [(Fundamental)] namiesto (Fundamental).
Aby ste sa dostali z rekurzívnej editaènej úrovne, stlaète ESC ESC ESC.
To je v¹eobecný "vyskakovací" príkaz. Mô¾ete ho pou¾i» tie¾ pre odstránenie
niektorých okien a vyskoèenie z minibuffera.
>> Stlaète M-x, aby ste sa dostali do minibuffera; potom stlaète
ESC ESC ESC, aby ste sa z neho dostali von.
Z rekurzívnej editaènej úrovne nemô¾ete vyskoèi» pomocou C-g. To preto, ¾e
C-g je vyu¾ívané pre ru¹enie príkazov a argumentov VO VNÚTRI rekurzívnej
editaènej vrstvy.
* ZÍSKANIE ÏAL©EJ NÁPOVEDY
--------------------------
V tomto tútoriale sme sa pokúsili Vám poskytnú» dostatok informácií,
aby ste mohli zaèa» Emacs pou¾íva». V Emacse je toho toµko, ¾e by bolo
nemo¾né to v¹etko objasni» v tomto návode. V ka¾dom prípade sa o Emacse
mô¾ete nauèi» viac, preto¾e má veµa u¾itoèných vlastností. Emacs ponúka
príkazy pre èítanie dokumentácie svojich príkazov. V¹etky tieto "help"
príkazy zaèínajú znakom Control-h, ktorý sa nazýva "help znak".
Pre pou¾itie vlastností nápovedy stlaète znak C-h a potom znak hovoriaci,
aký druh nápovedy si ¾iadate. Ak ste NAOZAJ stratení, stlaète C-h ? a
Emacs Vám povie, aké druhy nápovedy Vám mô¾e poskytnú». Ak ste stlaèili
C-h a potom ste sa rozhodli, ¾e ¾iadnu nápovedu nechcete, jednoducho ju
zru¹te stlaèením C-g.
(Na niektorých poèítaèoch je význam znaku C-h zmenený. To by naozaj
nemalo by» v¹eobecným nastavením pre v¹etkých pou¾ívateµov, tak¾e máte právo
pos»a¾ova» sa systémovému administrátorovi. Do tej doby, ak C-h
nezobrazuje hlásenie o nápovede v dolnej èasti obrazovky, skúste namiesto
toho pou¾íva» klávesu F1 alebo M-x help RET.)
Najzákladnej¹í príkaz nápovedy je C-h c. Stlaète C-h, znak c a klávesový
príkaz; Emacs potom zobrazí veµmi struèný popis príkazu.
>> Stlaète C-h c Control-p.
Hlásenie by malo vyzera» asi takto
C-p runs the command previous-line
To vám oznamuje "meno funkcie". Mená funkcií sú pou¾ívané hlavne pre
konfiguráciu a roz¹irovanie Emacsu. Ale preto¾e mená funkcií sú volené
tak, aby naznaèovali, èo zodpovedajúci príkaz robí, mô¾u slú¾i» tie¾
ako veµmi struèná dokumentácia -- dostatoèná na to, aby Vám pripomenula
príkazy, ktoré ste sa u¾ nauèili.
Viacznakové príkazy ako C-x C-s a (ak nemáte META, EDIT ani ALT
klávesu) <ESC>v sú pre C-h c povolené tie¾.
Na získanie viac informácií o príkaze pou¾ite namiesto C-h c C-h k.
>> Stlaète C-h k Control-p.
To zobrazí dokumentáciu k funkcii a jej meno v emacsovom okne. Ak
výstup preèítate, stlaète C-x 1, aby ste sa textu nápovedy zbavili.
Nemusíte to robi» hneï. Mô¾ete chvíµu editova» a nazera» do textu
nápovedy a a¾ potom stlaèi» C-x 1.
Tu sú ïal¹ie u¾itoèné voµby C-h:
C-h f Popis funkcie. Zadáváte meno funkcie.
>> Skúste napísa» C-h f previous-line<Return>.
To vypí¹e v¹etky informácie, ktoré Emacs má o funkcii implementujúcej
príkaz C-p.
Podobný príkaz C-h v zobrazí dokumentáciu premennej, ktorej hodnotu
mô¾ete nastavi» pre ovplyvnenie chovania Emacsu. Meno premennej musíte
zada», a¾ keï sa naò Emacs spýta.
C-h a Príkazové apropos. Zadajte kµúèové slovo a Emacs vypí¹e
v¹etky príkazy, ktorých meno obsahuje toto kµúèové
slovo. V¹etky tieto príkazy mô¾u by» vyvolané pomocou
Meta-x. Pre niektoré príkazy príkazové apropos vypí¹e
tie¾ jedno alebo dvojznakové sekvencie, ktoré vykonávajú
ten istý príkaz.
>> Napí¹te C-h a file<Return>.
To zobrazí v druhom okne zoznam v¹etkých M-x príkazov obsahujúcich "file" vo
svojom názve. Znakové príkazy ako C-x C-f uvidíte vypísané vedµa
zodpovedajúcich mien príkazov ako find-file.
>> Stlaète C-M-v pre posun okna s nápovedou. Urobte to viac krát.
>> Stlaète C-x 1 pre zmazanie okna s nápovedou.
C-h i Èítanie on-line manuálov (tie¾ Info). Tento príkaz
Vás prepne do ¹peciálneho buffera s názvom `*info*',
v ktorom mô¾ete èíta» on-line manuály pre balíky
in¹talované na va¹om systéme. Ak stlaèíte m emacs <Return>,
mô¾ete si napríklad preèíta» manuál k Emacsu. Ak ste
doteraz nikdy nepou¾ívali Info, stlaète ? a Emacs vám
predstaví hlavné mo¾nosti módu pre Info. Ak toto
predstavenie absolvujete, mali by ste pou¾íva» Info
manuál Emacsu ako svoju primárnu dokumentáciu.
* ZÁVER
-------
Nezabudnite, Emacs ukonèíte vykonaním príkazu C-x C-c. Pre doèasný
odskok do shellu, z ktorého sa do Emacsu mô¾ete opä» vráti»,
pou¾ite C-z.
Zámerom tohto tútorialu je by» zrozumiteµný v¹etkým novým pou¾ívateµom, tak¾e
ak narazíte na nieèo nejasného, tak nezúfajte a nedávajte to za vinu sebe
-- s»a¾ujte sa!
KOPÍROVANIE
-----------
Tento tútorial vychádza z dllhej rady emacsových tútorialov zaèatej
tútorialom napísaným Stuartom Cracraftom pre pôvodný Emacs.
Táto verzia tútorialu je, podobne ako GNU Emacs, chránená copyrightom
a je ¹írená s povolením distribuova» kópie za istých podmienok:
Copyright (c) 1985, 1996 Free Software Foundation
Ka¾dému je zaruèené právo vytvára» a distribuova» presné kópie tohto
dokumentu tak, ako ho dostal, na akomkoµvek médiu, s tým, ¾e bude
zachovaná táto poznámka o autorstve a poznámka o povolení, a ¾e
distribútor zaruèuje príjemcovi právo na ïal¹iu redistribúciu povolenú
touto poznámkou.
Je zaruèené právo distribuova» modifikované verzie tohto dokumentu
alebo jeho èastí pod hore uvedenými podmienkami za predpokladu, ¾e
obsahuje jasné poznámky uvádzajúce, kto urobil posledné úpravy.
Podmienky pre kopírovanie Emacsu samotného sú zlo¾itej¹ie, ale
v rovnakom duchu. Preèítajte si, prosím, súbor COPYING a potom dajte kópie
GNU Emacsu svojim priateµom. Pomáhajte potlaèova» softwarovú ob¹trukciu
("vlastníctvo") pou¾ívaním, písaním a zdieµaním free softwaru!
;;; Local Variables:
;;; coding: iso-latin-2
;;; End:
Copyright (c) 1985 Free Software Foundation, Inc; podmínky viz na konci.
Do èe¹tiny pøelo¾il Milan Zamazal <pdm(a)zamazal.org>.
Máte pøed sebou tutoriál k Emacsu.
Pøíkazy Emacsu obecnì vyu¾ívají klávesu CONTROL (obèas oznaèovanou CTRL nebo
CTL) nebo klávesu META (obèas oznaèovanou EDIT nebo ALT). Abychom tyto názvy
nemuseli stále psát v plném znìní, budeme pou¾ívat následující zkratky:
C-<chr> znamená pøidr¾et klávesu CONTROL a stisknout znak <chr>.
Tedy C-f znamená: pøidr¾te klávesu CONTROL a stisknìte f.
M-<chr> znamená pøidr¾et klávesu META, EDIT nebo ALT a stisknout <chr>.
Pokud ¾ádnou z kláves META, EDIT ani ALT nemáte, tak místo toho
stisknìte a pus»te klávesu ESC a poté <chr>. Klávesu ESC budeme
znaèit <ESC>.
Dùle¾itá poznámka: práci s Emacsem ukonèíte stiskem C-x C-c (dva znaky).
Znaky ">>" na levém okraji znaèí místa, kde si máte vyzkou¹et pøíkaz.
Napøíklad:
<<Blank lines inserted here by startup of help-with-tutorial>>
>> Nyní stisknìte C-v (view next screen) pro posun na dal¹í obrazovku.
(Smìle do toho, proveïte to pøidr¾ením klávesy CONTROL a stiskem v.)
Od této chvíle byste toto mìli provádìt kdykoliv doètete zobrazenou
obrazovku.
V¹imnìte si, ¾e pøi posuvu obrazovek v¾dy zùstávají zobrazeny dva øádky
z pøedchozí obrazovky; to poskytuje urèitou návaznost pøi postupném
ètení textu.
První vìc, kterou potøebujete vìdìt, je jak se v textu pohybovat
z jednoho místa na druhé. U¾ víte, jak se posunout o jednu obrazovku
vpøed, pomocí C-v. K pøechodu o obrazovku zpìt pou¾ijte M-v
(pøidr¾te klávesu META a stisknìte v nebo stisknìte <ESC>v, jestli¾e
nemáte ¾ádnou z kláves META, EDIT nebo ALT).
>> Zkuste stisknout M-v a pak C-v, nìkolikrát to zopakujte.
* SHRNUTÍ
---------
K prohlí¾ení obrazovkových stránek jsou u¾iteèné následující pøíkazy:
C-v Posun o obrazovku vpøed
M-v Posun o obrazovku zpìt
C-l Smazání obrazovky a znovuzobrazení celého textu,
pøitom se text pod kurzorem pøesune ke støedu obrazovky.
(Jedná se o CONTROL-L a ne CONTROL-1.)
>> Najdìte kurzor a zapamatujte si, jaký text je kolem nìj.
Pak stisknìte C-l.
Najdìte kurzor znovu a v¹imnìte si, ¾e je kolem nìj tentý¾ text.
* ZÁKLADNÍ OVLÁDÁNÍ KURZORU
---------------------------
Pohyb mezi obrazovkami je u¾iteèný, ale jak se pøemístíte na konkrétní
místo v textu na obrazovce?
Je toho mo¾no dosáhnout nìkolika zpùsoby. Nejzákladnìj¹ím zpùsobem je
pou¾ití pøíkazù C-p, C-b, C-f a C-n. Ka¾dý z tìchto pøíkazù pøesune
kurzor na obrazovce o jeden øádek nebo sloupec v daném smìru.
Zde je tabulka znázoròující smìr posuvu kurzoru vyvolaný tìmito ètyømi
pøíkazy:
Pøedchozí øádek, C-p
:
:
Dozadu, C-b .... Momentální pozice kurzoru .... Dopøedu, C-f
:
:
Následující øádek, C-n
>> Pøesuòte kurzor na prostøední øádek tohoto diagramu pomocí
C-n nebo C-p. Potom stisknìte C-l, abyste na obrazovce vidìli celý
diagram vycentrován.
Pravdìpodobnì se vám budou tyto pøíkazy snadno pamatovat podle
poèáteèních písmen anglických názvù: P jako previous (pøedchozí),
N jako next (následující), B jako backward (zpìt), F jako forward (vpøed).
Jsou to základní pøíkazy pro pohyb kurzoru a budete je pou¾ívat
neustále, tak¾e by bylo velmi vhodné, kdybyste se je teï nauèili.
>> Proveïte nìkolikrát C-n, abyste kurzor pøesunuli na tento øádek.
>> Posuòte kurzor dovnitø øádku pomocí nìkolika C-f a pak nahoru stiskem C-p.
Pozorujte, co C-p dìlá, kdy¾ je kurzor uprostøed øádku.
Ka¾dý øádek textu konèí znakem nového øádku, který jej oddìluje od øádku
následujícího. Znakem nového øádku by mìl být ukonèen i poslední øádek
souboru (pøesto¾e to Emacs nevy¾aduje).
>> Vyzkou¹ejte C-b na zaèátku øádku. Kurzor by se mìl pøesunout na konec
pøedchozího øádku, nebo» jej tím pøesunete pøes znak nového øádku.
C-f funguje analogicky jako C-b, tj. na konci øádku dojde k pøesunu na
dal¹í øádek.
>> Proveïte nìkolik C-b, tak¾e uvidíte, kde se nachází kurzor.
Pak provádìjte C-f, abyste se vrátili na konec øádku.
Pak proveïte je¹tì jednou C-f, abyste se pøesunuli na následující
øádek.
Kdy¾ kurzorem pøejdete pøes horní nebo dolní okraj obrazovky, posune se
text za pøíslu¹ným okrajem na obrazovku. Tato vlastnost se nazývá
"scrollování". Umo¾òuje pøemístit kurzor na libovolné místo v textu,
ani¾ by kurzor opustil obrazovku.
>> Zkuste posunout kurzor pod dolní okraj obrazovky pomocí C-n a pozorujte,
co se stane.
Jestli¾e je posun po znacích pøíli¹ pomalý, mù¾ete se pohybovat po
slovech. M-f (META-f) provádí posun o slovo vpøed a M-b provádí posun
o slovo zpìt.
>> Stisknìte nìkolikrát M-f a M-b.
Pokud se kurzor nachází uprostøed slova, M-f provede pøesun na konec
tohoto slova. Nachází-li se kurzor v mezeøe mezi slovy, M-f provede
pøesun na konec následujícího slova. M-b pracuje analogicky v opaèném
smìru.
>> Stisknìte nìkolikrát M-f a M-b prolo¾enì s C-f a C-b, abyste vidìli
výsledky pøíkazù M-f a M-b provádìných z rùzných míst uvnitø slov a
mezi nimi.
V¹imnìte si analogie mezi C-f a C-b na jedné stranì a M-f a M-b na
stranì druhé. Znaky s klávesou META jsou velmi èasto vyu¾ívány pro operace
vztahující se k entitám definovaným jazykem (slova, vìty, odstavce),
zatímco znaky s klávesou CONTROL pracují na základních prvcích
nezávislých na tom, co zrovna editujete (znaky, øádky, apod.).
Tato analogie platí také pro øádky a vìty: C-a a C-e provádí pøesun
na zaèátek a konec øádku, M-a a M-e provádí pøesun na zaèátek a konec
vìty.
>> Zkuste nìkolikrát C-a a poté nìkolikrát C-e.
Zkuste nìkolikrát M-a a poté nìkolikrát M-e.
V¹imnìte si, ¾e opakované C-a nedìlá nic, zatímco opakované M-a v¾dy
provádí posun o dal¹í vìtu. Principu analogie to sice pøíli¹
neodpovídá, ale pøesto je toto chování mo¾no pova¾ovat za pøirozené.
Pozice kurzoru v textu se také nazývá "bod" ("point"). Abychom to
parafrázovali, kurzor je vidìt na obrazovce v místì, kde je bod umístìn
v textu.
Zde je pøehled jednoduchých operací pro pohyb kurzoru vèetnì pøíkazù pro
pohyb mezi slovy a vìtami:
C-f Pøesun o znak vpøed
C-b Pøesun o znak zpìt
M-f Pøesun o slovo vpøed
M-b Pøesun o slovo zpìt
C-n Pøesun na následující øádek
C-p Pøesun na pøedchozí øádek
C-a Pøesun na zaèátek øádku
C-e Pøesun na konec øádku
M-a Pøesun zpìt na zaèátek vìty
M-e Pøesun vpøed na konec vìty
>> Vyzkou¹ejte si teï nìkolikrát v¹echny tyto pøíkazy pro procvièení.
Jsou to nejpou¾ívanìj¹í pøíkazy.
Dal¹í dva dùle¾ité pøíkazy pro pohyb kurzoru jsou M-< (META men¹í-ne¾),
který provede pøesun na zaèátek celého textu, a M-> (META vìt¹í-ne¾),
který provede pøesun na konec celého textu.
Na vìt¹inì terminálù je "<" nad èárkou, tak¾e pro vyvolání tohoto znaku
musíte pou¾ít klávesu Shift. Na tìchto terminálech je tedy nutno pou¾ít
klávesu Shift i v pøípadì pøíkazu M-<; bez klávesy Shift byste provedli
M-èárka.
>> Zkuste teï M-< pro pøesun na zaèátek tutoriálu.
Pou¾ijte pak opakovanì C-v, abyste se opìt vrátili sem.
>> Zkuste teï M-> pro pøesun na konec tutoriálu.
Pou¾ijte pak opakovanì M-v, abyste se opìt vrátili sem.
Kurzor mù¾ete pøesouvat také pomocí kurzorových kláves (klávesy
se ¹ipkami), pokud je vá¹ terminál má. My v¹ak doporuèujeme nauèit se
C-b, C-f, C-n a C-p, a to ze tøí dùvodù. Za prvé, tyto klávesy fungují
na v¹ech typech terminálù. Za druhé, jakmile jednou získáte cvik
v pou¾ívání Emacsu, zjistíte, ¾e pou¾ívání tìchto CTRL znakù je
rychlej¹í ne¾ pou¾ívání kurzorových kláves (proto¾e nemusíte pøesouvat
ruku z psací pozice). Za tøetí, zvyknete-li si pou¾ívat tyto CTRL-znak
pøíkazy, snadno se nauèíte pou¾ívat jiné pokroèilé pøíkazy pro pohyb
kurzoru.
Vìt¹ina pøíkazù Emacsu akceptuje numerický argument; ten pro vìt¹inu
pøíkazù slou¾í jako opakovaè. Poèet opakování pøíkazu zadáte
prostøednictvím stisku C-u následovaného stiskem pøíslu¹ných èíslic pøed
vyvoláním pøíkazu. Máte-li META (nebo EDIT èi ALT) klávesu, existuje
alternativní mo¾nost zadání numerického argumentu: pøidr¾te klávesu META
a stisknìte pøíslu¹né èíslice. Doporuèujeme nauèit se C-u metodu,
proto¾e ta funguje na jakémkoliv terminálu.
Napøíklad C-u 8 C-f provede pøesun o osm znakù vpøed.
Vìt¹ina pøíkazù pou¾ívá numerický argument jako opakovaè. Jisté
výjimeèné pøíkazy jej pou¾ívají jiným zpùsobem. Mezi tyto výjimky patøí
C-v a M-v. Dostanou-li numerický argument, posunou obrazovku nahoru
nebo dolù o odpovídající poèet øádkù místo obrazovek. Napøíklad
C-u 4 C-v posune obrazovku o 4 øádky.
>> Zkuste teï stisknout C-u 8 C-v.
To by mìlo posunout obrazovku o 8 øádkù nahoru. Pokud byste ji chtìli
posunout zpìt dolù, mù¾ete dát argument pøíkazu M-v.
Pou¾íváte-li X Window, mìli byste mít na levé stranì emacsového okna
vysokou obdélníkovou oblast, nazývanou scrollbar. Mù¾ete pak text
posouvat klikáním my¹í na scrollbar.
>> Zkuste stisknout prostøední tlaèítko na vrcholu zvýraznìné oblasti
uvnitø scrollbaru. To by mìlo text posunout na pozici danou tím, jak
vysoko nebo nízko jste kliknuli.
>> Zkuste pøi stisknutém prostøedním tlaèítku posouvat my¹í nahoru a
dolù. Uvidíte, jak se text posouvá nahoru a dolù podle toho, jak
posouváte my¹í.
* KDY® EMACS NEREAGUJE
----------------------
Jestli¾e Emacs pøestane reagovat na va¹e pøíkazy, mù¾ete probíhající
èinnost bezpeènì zastavit pomocí C-g. Pomocí C-g mù¾ete zastavit
pøíkaz, jeho¾ provádìní trvá pøíli¹ dlouho.
C-g mù¾ete pou¾ít také pro odstranìní numerického argumentu pøíkazu,
který nechcete dokonèit.
>> Stisknìte C-u 100 pro vytvoøení numerického argumentu 100 a pak
stisknìte C-g. Nyní stisknìte C-f. Mìl by být proveden posun
o právì jeden znak, proto¾e jste argument zru¹ili prostøednictvím
C-g.
Pokud jste omylem stiskli <ESC>, mù¾ete se jej zbavit pomocí C-g.
* DEAKTIVOVANÉ PØÍKAZY
----------------------
Nìkteré pøíkazy Emacsu jsou "deaktivované" ("disabled"), aby je
zaèínající u¾ivatelé nemohli vyvolat náhodnì.
Pokud vyvoláte nìkterý z deaktivovaných pøíkazù, Emacs zobrazí hlá¹ení
oznamující, který pøíkaz to byl, s dotazem, zda chcete tento pøíkaz
provést.
Pokud opravdu chcete pøíkaz vyzkou¹et, stisknìte mezerník jako odpovìï
na tuto otázku. Obyèejnì, jestli¾e nechcete deaktivovaný pøíkaz
provést, odpovìzte na tuto otázku pomocí "n".
>> Stisknìte <ESC> : (co¾ je deaktivovaný pøíkaz),
pak na otázku odpovìzte n.
* OKNA
------
Emacs mù¾e mít nìkolik oken (windows), z nich¾ ka¾dé zobrazuje svùj
vlastní text. Jak více oken pou¾ívat, objasníme pozdìji. Nyní chceme
objasnit, jak se zbavit nadbyteèných oken a vrátit se do základní
jednookenní editace. Je to jednoduché:
C-x 1 Jedno okno (tj. zru¹ení v¹ech ostatních oken)
Tedy vlo¾ení CONTROL-x následované èíslicí 1. C-x 1 roz¹íøí okno
obsahující kurzor pøes celou obrazovku. Zru¹í to v¹echna ostatní okna.
>> Stisknìte C-h k C-f.
Pozorujte, jak se aktuální okno zmen¹í a objeví se nové okno za
úèelem zobrazení dokumentace k pøíkazu C-f.
>> Stisknìte C-x 1 a pozorujte, jak okno s dokumentací zmizí.
* VKLÁDÁNÍ A MAZÁNÍ
-------------------
Chcete-li vlo¾it text, prostì jej napi¹te. Znaky, které vidíte,
jako A, 7, *, atd., jsou Emacsem chápány jako text a vkládány okam¾itì.
Pro vlo¾ení znaku nového øádku stisknìte <Return> (klávesu Enter).
Poslední znak, který jste napsali, mù¾ete smazat stiskem <Delete>.
<Delete> je klávesa, která mù¾e být na klávesnici oznaèena "Del".
V nìkterých pøípadech jako <Delete> slou¾í klávesa "Backspace", av¹ak ne
v¾dy!
Obecnìji, <Delete> ma¾e znak bezprostøednì pøed momentální pozicí
kurzoru.
>> Proveïte to teï -- napi¹te nìkolik znakù a pak je sma¾te nìkolika
stisky <Delete>. Nebojte se zmìn v tomto souboru; originální
tutoriál se nezmìní. Toto je va¹e osobní kopie.
Kdy¾ se øádek textu zvìt¹í natolik, ¾e pøesáhne jeden øádek obrazovky,
je zobrazen na více øádcích obrazovky. Øádek textu, který pokraèuje na
dal¹ím øádku obrazovky, je indikován zpìtným lomítkem ("\") na pravém
okraji obrazovky.
>> Vkládejte text, a¾ dosáhnete pravého okraje, a pokraèujte ve vkládání.
Objeví se vám pokraèovací øádek.
>> Pou¾ijte <Delete> pro smazání textu, a¾ se øádek textu opìt vejde na
jeden øádek obrazovky. Pokraèovací øádek zmizí.
Znak nového øádku mù¾ete smazat jako kterýkoliv jiný znak. Smazání
znaku nového øádku mezi dvìma øádky zpùsobí jejich spojení do jediného
øádku. Je-li výsledný øádek pøíli¹ dlouhý na to, aby se ve¹el na ¹íøku
obrazovky, bude zobrazen pokraèovacím øádkem.
>> Pøesuòte kurzor na zaèátek øádku a stisknìte <Delete>. To tento
øádek spojí s øádkem pøedchozím.
>> Stisknìte <Return> pro znovuvlo¾ení smazaného znaku nového øádku.
Vzpomeòte si, ¾e vìt¹ina pøíkazù Emacsu mù¾e dostat poèet opakování;
vèetnì textových znakù. Opakování textových znakù je vlo¾í nìkolikrát.
>> Vyzkou¹ejte si to teï -- stisknìte C-u 8 * pro vlo¾ení ********.
Teï u¾ znáte nejzákladnìj¹í zpùsoby, jak nìco v Emacsu napsat a jak
opravovat chyby. Mù¾ete ov¹em také mazat po slovech nebo po øádcích.
Zde je shrnutí operací pro mazání textu:
<Delete> Smazání znaku bezprostøednì pøed kurzorem
C-d Smazání znaku následujícího za kurzorem
M-<Delete> Zru¹ení slova bezprostøednì pøed kurzorem
M-d Zru¹ení slova následujícího za kurzorem
C-k Zru¹ení textu od pozice kurzoru do konce øádku
M-k Zru¹ení textu do konce aktuální vìty
V¹imnìte si, ¾e <Delete> a C-d, resp. M-<Delete> a M-d, roz¹iøují
paralelu zapoèatou C-f a M-f (pravda, <Delete> opravdu není CONTROL
znak, ale netrapme se tím). C-k a M-k jsou jako C-e a M-e ve smyslu
vztahu øádkù k vìtám.
Libovolnou èást bufferu mù¾ete té¾ zru¹it následující metodou.
Pøesuòte se na jeden konec této èásti a stisknìte C-＠ nebo C-SPC
(libovolnou z tìchto kombinací). (SPC oznaèuje mezerník.) Pøesuòte
se na druhý konec této èásti a stisknìte C-w. Text mezi tìmito
pozicemi bude zru¹en.
>> Pøesuòte kurzor na písmeno L na zaèátku pøedchozího odstavce.
>> Stisknìte C-SPC. Emacs by mìl ve spodním øádku obrazovky
zobrazit zprávu "Mark set".
>> Pøesuòte kurzor na písmeno c ve slovì "konec" na druhém øádku
odstavce.
>> Stisknìte C-w. Text zaèínající písmenem L a konèící pøed písmenem
c bude zru¹en.
Uvìdomte si, ¾e rozdíl mezi "ru¹ením" ("killing") a "mazáním"
("deleting") je ten, ¾e "zru¹ené" vìci mohou být zpìt vhozeny, zatímco
"smazané" nikoliv. Obecnì pøíkazy, které mohou smazat vìt¹í mno¾ství
textu, ukládají text, zatímco pøíkazy, které ma¾ou jediný znak nebo
pouze prázdné øádky a mezery, mazaný text neukládají.
>> Pøesuòte kurzor na zaèátek neprázdného øádku.
Pak stisknìte C-k pro zru¹ení textu na tomto øádku.
>> Stisknìte C-k podruhé. Uvidíte, ¾e to zru¹í znak nového øádku, který
je za tímto øádkem.
V¹imnìte si, ¾e jedno C-k zru¹í obsah øádku a druhé C-k zru¹í øádek
samotný a posune v¹echny dal¹í øádky nahoru. C-k zpracovává numerický
argument speciálnì: zru¹í odpovídající poèet øádkù VÈETNÌ jejich
obsahu. To u¾ není opakování. C-u 2 C-k zru¹í dva øádky a jejich
obsah; dvojitý stisk C-k by toto obvykle neudìlal.
Vracení textu zpìt se nazývá "vhazování" ("yanking"). (Pøedstavte
si opìtovné vhazování, vracení døíve odstranìného textu zpátky.)
Zru¹ený text mù¾ete vhodit buï na stejné místo, kde byl zru¹en,
nebo na jiné místo v bufferu, nebo dokonce i do jiného souboru.
Text mù¾ete vhodit i vícekrát, vytváøíte tak jeho dal¹í kopie.
Pøíkazem pro vhazování je C-y. Tento pøíkaz vlo¾í poslední smazaný
text na pozici, na které se nachází kurzor.
>> Zkuste to; stisknìte C-y pro vhození textu zpìt.
Stisknete-li nìkolikrát C-k po sobì, v¹echen smazaný text je ulo¾en
spoleènì tak, aby bylo mo¾né vhodit zpìt v¹echny øádky najednou.
>> Stisknìte nìkolikrát C-k.
Nyní obnovte poslednì zru¹ený text:
>> Stisknìte C-y. Pak posuòte kurzor o nìkolik øádkù ní¾e a stisknìte
C-y znova. Nyní vidíte, jak lze text kopírovat.
Co kdy¾ máte nìjaký text, který byste rádi vhodili zpìt a pak zru¹íte
nìco jiného? C-y by vlo¾ilo poslední zru¹ený text. Av¹ak pøedchozí
text není ztracen. Mù¾ete jej získat zpìt pou¾itím pøíkazu M-y. Poté,
co provedete C-y pro získání posledního zru¹eného textu, stisk M-y
vymìní tento vhozený text za pøedchozí zru¹ený text. Dal¹ími a
dal¹ími stisky M-y dostáváte pøedcházející a pøedcházející zru¹ené
texty. Kdy¾ dosáhnete textu, který hledáte, nemusíte s ním pro jeho
uchování nic dal¹ího provádìt. Jednodu¹e vhozený text ponechejte, kde
je, a pokraèujte v editaci.
Pokud opakujete M-y dostateènì dlouho, dostanete se zpátky k výchozímu
bodu (poslednì zru¹enému textu).
>> Zru¹te øádek, pøesuòte kurzor nìkam jinam a zru¹te jiný øádek.
Pak proveïte C-y pro vrácení druhého zru¹eného øádku.
Pak proveïte M-y a vhozený øádek bude nahrazen prvním zru¹eným øádkem.
Opakujte M-y a pozorujte, co dostáváte. Pokraèujte v tom, dokud se
znovu neobjeví druhý zru¹ený øádek a pak nìkolik dal¹ích.
Chcete-li, mù¾ete zkusit pøedat M-y kladné a záporné argumenty.
* UNDO
------
Jestli¾e provedete v textu zmìnu a pak zjistíte, ¾e to byl omyl, mù¾ete
zmìnu vrátit pøíkazem undo, C-x u.
C-x u obvykle vrátí zmìny provedené jedním pøíkazem; pokud C-x u
zopakujete nìkolikrát za sebou, ka¾dé opakování vrátí jeden dal¹í
pøíkaz.
Jsou ale dvì výjimky: pøíkazy, které nemìní text, se nepoèítají (to
zahrnuje pøíkazy pro pohyb kurzoru a scrollování) a znaky vkládající
samy sebe jsou obvykle zpracovávány ve skupinách a¾ po 20. (To je kvùli
tomu, aby se zredukoval poèet C-x u nutných pro vrácení vkládaného
textu.)
>> Zru¹te tento øádek pomocí C-k, stisknìte pak C-x u a øádek by se mìl
znovu objevit.
Alternativní undo pøíkaz je C-_; pracuje stejnì jako C-x u, je v¹ak
ménì pracné jej aplikovat nìkolikrát za sebou. Nevýhodou C-_ je, ¾e
na nìkterých klávesnicích není zøejmé, jak jej vyvolat. To je dùvod,
proè nabízíme i C-x u. Na nìkterých terminálech mù¾ete C-_ vyvolat
stiskem / pøi stisknutém CTRL.
Numerický argument pro C-_ a C-x u funguje jako poèet opakování.
Pomocí pøíkazu undo mù¾ete vrátit zru¹ený stejnì jako smazaný text.
Rozdíl mezi mazáním a ru¹ením textu ovlivòuje mo¾nost vhození tohoto
textu pomocí C-y, neovlivòuje mo¾nosti pøíkazu undo.
* SOUBORY
---------
Aby text, který editujete, zùstal trvale uchován, musíte jej ulo¾it do
souboru. Jinak by byl po ukonèení Emacsu ztracen. Svoji editaci
spojíte se souborem "vyhledáním" ("finding") souboru. (Také se to
nazývá "nav¹tívení" ("visiting") souboru.)
Vyhledání souboru znamená, ¾e vidíte jeho obsah v Emacsu. V mnoha
ohledech je to, jako byste editovali pøímo ten soubor. Nicménì zmìny,
které prostøednictvím Emacsu èiníte, se nestanou trvalými, dokud tyto
zmìny do souboru "neulo¾íte" ("save"). Tím se zamezí nechtìnému ponechání
èásteènì zmìnìného souboru v systému. Dokonce i kdy¾ soubor ulo¾íte,
Emacs uchová pùvodní soubor pod zmìnìným názvem pro pøípad, ¾e byste
zjistili, ¾e va¹e úpravy byly chybné.
Kdy¾ se podíváte do dolní èásti obrazovky, uvidíte øádek, který zaèíná a
konèí pomlèkami a na zaèátku má "2J:-- TUTORIAL.cs" nebo nìco podobného.
Tato èást obrazovky obvykle obsahuje jméno souboru, který je právì
nav¹tíven. Zrovna teï máte nav¹tíven soubor nazvaný "TUTORIAL.cs",
který je va¹í osobní èmárací kopií tutoriálu Emacsu. Kdy¾ v Emacsu
vyhledáte soubor, jeho jméno se objeví pøesnì na tom místì.
Pøíkazy pro vyhledávání a ukládání souborù se na rozdíl od ostatních
pøíkazù, které jste se zatím nauèili, skládají ze dvou znakù. Oba
zaèínají znakem CONTROL-x. Existuje celá øada pøíkazù zaèínajících na
CONTROL-x; mnoho z nich pracuje se soubory, buffery a podobnými vìcmi.
Tyto pøíkazy jsou dlouhé dva, tøi nebo ètyøi znaky.
Dal¹í vìcí ohlednì pøíkazu pro vyhledání souboru je to, ¾e musíte øíct,
které jméno souboru chcete. Øíkáme, ¾e pøíkaz "ète argument
z terminálu" (v tomto pøípadì je argumentem jméno souboru). Poté co
vyvoláte pøíkaz
C-x C-f Vyhledání souboru
Emacs se vás zeptá na jméno souboru. Jméno souboru, které pí¹ete, se
objevuje ve spodním øádku obrazovky, který se v této situaci nazývá
minibuffer. Pro editaci jména souboru mù¾ete pou¾ívat obvyklé editaèní
pøíkazy Emacsu.
Zadávání jména souboru (obecnì kterýkoliv vstup z minibufferu) mù¾ete
zru¹it pøíkazem C-g.
>> Stisknìte C-x C-f a pak C-g. To minibuffer zru¹í a takté¾ to zru¹í
pøíkaz C-x C-f, který minibuffer pou¾il. Tak¾e nevyhledáte ¾ádný
soubor.
Po napsání jména souboru stisknìte <Return>.
Pøíkaz C-x C-f pak zaène pracovat a vyhledá soubor, který jste zvolili.
Po skonèení pøíkazu C-x C-f minibuffer zmizí.
Po malé chvilce se obsah souboru objeví na obrazovce a mù¾ete jej
editovat. Kdy¾ chcete zmìny trvale ulo¾it, pou¾ijte pøíkaz
C-x C-s Ulo¾ení souboru
To zkopíruje text z Emacsu do souboru. Kdy¾ to provedete poprvé, Emacs
pøejmenuje pùvodní soubor na soubor s novým jménem, aby nebyl ztracen.
Nové jméno je vytvoøeno pøidáním "~" na konec pùvodního jména souboru.
Kdy¾ je ukládání dokonèeno, Emacs zobrazí jméno zapsaného souboru.
Mìli byste ukládat rozumnì èasto, abyste neztratili pøíli¹ mnoho práce
v pøípadì pádu systému.
>> Stisknìte C-x C-s pro ulo¾ení va¹í kopie tutoriálu.
Mìlo by to zobrazit "Wrote ...TUTORIAL.cs" ve spodním øádku obrazovky.
POZNÁMKA: Na nìkterých systémech zpùsobí stisk C-x C-s ztuhnutí
obrazovky a nevidíte ¾ádný dal¹í výstup z Emacsu. To znamená, ¾e
"vlastnost" operaèního systému zvaná "flow control" zachycuje C-s a
nepropustí jej k Emacsu. Pro odtuhnutí obrazovky stisknìte C-q. Pak
v sekci "Spontaneous Entry to Incremental Search" v manuálu Emacsu
vyhledejte radu, jak se vypoøádat s touto "vlastností".
Existující soubor mù¾ete vyhledat, abyste jej mohli prohlí¾et nebo
editovat. Mù¾ete také vyhledat soubor, který je¹tì neexistuje. To je
zpùsob, jakým lze vytvoøit soubor v Emacsu: vyhledejte soubor, který
bude na zaèátku prázdný a pak zaènìte vkládat text urèený pro tento
soubor. Kdy¾ po¾ádáte o ulo¾ení, Emacs skuteènì vytvoøí soubor
s textem, který jste vlo¾ili. Od té chvíle se pak mù¾ete cítit, jako
kdybyste editovali ji¾ existující soubor.
* BUFFERY
---------
Jestli¾e vyhledáte pomocí C-x C-f druhý soubor, první soubor v Emacsu
zùstává. Mù¾ete se do nìj zpìt pøepnout jeho opìtovným vyhledáním
pomocí C-x C-f. Tímto zpùsobem mù¾ete do Emacsu dostat pomìrnì hodnì
souborù.
>> Vytvoøte soubor pojmenovaný "foo" stiskem C-x C-f foo <Return>.
Potom vlo¾te nìjaký text, zeditujte jej a ulo¾te "foo" stiskem C-x C-s.
Nakonec stisknìte C-x C-f TUTORIAL.cs <Return>, èím¾ se vrátíte zpìt do
tutoriálu.
Emacs ukládá text ka¾dého souboru do objektu nazývaného "buffer".
Vyhledání souboru vytvoøí v Emacsu nový buffer. Chcete-li vidìt seznam
bufferù, které momentálnì existují ve va¹em procesu Emacs, stisknìte:
C-x C-b Seznam bufferù
>> Zkuste teï C-x C-b.
Podívejte se, ¾e ka¾dý buffer má v seznamu jméno a mù¾e tam mít také jméno
souboru, jeho¾ text obsahuje. Nìkteré buffery neodpovídají souborùm.
Napøíklad buffer pojmenovaný "*Buffer List*" nemá ¾ádný soubor. Je to
buffer, který obsahuje seznam bufferù vytvoøený pomocí C-x C-b.
JAKÝKOLIV text, který vidíte v emacsovém oknì, je v¾dy souèástí
nìjakého bufferu.
>> Stisknìte C-x 1, abyste se zbavili seznamu bufferù.
Pokud provedete zmìny textu jednoho souboru a pak vyhledáte jiný soubor,
nezpùsobí to ulo¾ení prvního souboru. Jeho zmìny zùstávají v Emacsu
uchovány v jemu odpovídajícím bufferu. Vytvoøení a editace druhého
souboru nemá ¾ádný vliv na buffer prvního souboru. To je velmi
u¾iteèné, ale také to znamená, ¾e potøebujete vhodný zpùsob, jak ulo¾it
buffer prvního souboru. Nutnost pøepnout se zpátky pomocí C-x C-f, aby
jej bylo mo¾no ulo¾it prostøednictvím C-x C-s, by byla nemístnì
obtì¾ující. Tak¾e máme
C-x s Ulo¾ení nìkterých bufferù
C-x s se vás zeptá na ka¾dý buffer, který obsahuje zmìny, které jste
neulo¾ili. Pro ka¾dý takový buffer se vás zeptá, zda jej má ulo¾it.
>> Vlo¾te øádek textu a pak stisknìte C-x s.
Mìli byste být dotázáni, zda má být ulo¾en buffer nazvaný TUTORIAL.cs.
Odpovìzte na tuto otázku ano (yes) stiskem "y".
* ROZ©IØOVÁNÍ SADY PØÍKAZÙ
--------------------------
Existuje mnohem, mnohem více pøíkazù Emacsu, ne¾ které by vùbec mohly
být rozmístìny na v¹echny CONTROL a META znaky. Emacs tento problém
obchází prostøednictvím X (eXtend) pøíkazu. Ten vzniká dvìma zpùsoby:
C-x Znakový eXtend. Následován jedním znakem.
M-x Pojmenovaný pøíkaz eXtend. Následován dlouhým názvem.
To jsou pøíkazy, které jsou obecnì u¾iteèné, av¹ak ménì èasto pou¾ívané
ne¾ ty, které jste se ji¾ nauèili. U¾ jste vidìli dva z nich: souborové
pøíkazy C-x C-f pro vyhledání a C-x C-s pro ulo¾ení. Jiný pøíklad je
pøíkaz pro ukonèení Emacsu -- tj. pøíkaz C-x C-c. (Nemìjte obavy
o ztrátu zmìn, které jste provedli; C-x C-c nabídne ulo¾ení ka¾dého
zmìnìného souboru, ne¾ Emacs ukonèí.)
C-z je pøíkaz na *doèasné* opu¹tìní Emacsu -- mù¾ete se po nìm do
spu¹tìného Emacsu vrátit.
Na systémech, které to umo¾òují, C-z Emacs "pozastaví"; tzn. vrátí vás
do shellu, av¹ak Emacs neukonèí. V nejbì¾nìj¹ích shellech se mù¾ete do
Emacsu vrátit pøíkazem `fg' nebo pomocí `%emacs'.
Na systémech, které pozastavování procesù nemají implementováno, C-z
vytvoøí subshell bì¾ící pod Emacsem, aby vám dal ¹anci spustit jiné
programy a pak se do Emacsu vrátit; neprovede tedy pravé opu¹tìní
Emacsu. V tom pøípadì je obvyklou cestou návratu ze subshellu do Emacsu
shellovský pøíkaz `exit'.
Chvíle pro pou¾ití C-x C-c nastane, kdy¾ se chystáte odhlásit ze
systému. Správné je to také pøi ukonèování Emacsu vyvolaného po¹tovním
programem a rùznými jinými utilitami, proto¾e ty nemusí vìdìt, jak si
poradit s pozastavením Emacsu. Nicménì za normálních okolností, pokud
se nechystáte odlogovat, je lépe Emacs pozastavit pomocí C-z ne¾ jej
ukonèit.
Existuje mnoho C-x pøíkazù. Zde je seznam tìch, které jste se ji¾ nauèili:
C-x C-f Vyhledání souboru
C-x C-s Ulo¾ení soubor
C-x C-b Seznam bufferù
C-x C-c Ukonèení Emacsu
C-x u Undo
Pojmenované eXtended pøíkazy jsou pøíkazy, které jsou pou¾ívány je¹tì
ménì, nebo pøíkazy, které jsou pou¾ívány jenom v jistých módech.
Pøíkladem je pøíkaz replace-string, který globálnì nahradí jeden øetìzec
jiným. Kdy¾ stisknete M-x, vypí¹e se na spodním øádku obrazovky prompt
M-x a vy byste mìli zadat jméno pøíkazu; v tomto pøípadì
"replace-string". Jednodu¹e napi¹te "repl s<TAB>" a Emacs název doplní.
Dokonèete zadávání jména pøíkazu pomocí <Return>.
Pøíkaz replace-string vy¾aduje dva argumenty -- øetìzec, který má být
nahrazen, a øetìzec, který jej má nahradit. Ka¾dý argument musíte
ukonèit pomocí <Return>.
>> Pøesuòte kurzor na prázdný øádek dva øádky pod tímto.
Pak napi¹te M-x repl s<Return>zmìnil<Return>modifikoval<Return>.
V¹imnìte si, jak se tento øádek zmìnil: nahradili jste slovo
z-m-ì-n-i-l slovem "modifikoval", kdekoliv se za aktuální pozicí
kurzoru vyskytlo.
* AUTOMATICKÉ UKLÁDÁNÍ
----------------------
Jestli¾e jste provedli zmìny v souboru, ale nemáte je je¹tì ulo¾eny,
mohou být v pøípadì pádu systému ztraceny. Aby vás Emacs od toho
uchránil, periodicky zapisuje "auto save" soubor pro ka¾dý soubor, který
editujete. Jméno auto save souboru má na zaèátku a na konci #;
napøíklad jestli¾e se vá¹ soubor jmenuje "hello.c", jeho auto save
soubor se jmenuje "#hello.c#". Kdy¾ soubor ulo¾íte normálním zpùsobem,
Emacs auto save soubor sma¾e.
Jestli¾e dojde k pádu systému, mù¾ete svoji editaci obnovit z auto-save
souboru, a to normálním vyhledáním souboru (toho, který jste editovali,
ne auto save souboru) a následnou aplikací M-x recover file<return>.
Na ¾ádost o potvrzení odpovìzte zadáním yes<return> pro pokraèování a
obnovení auto-save dat.
* ECHO OBLAST
-------------
Kdy¾ Emacs vidí, ¾e pí¹ete pøíkazy pomalu, ukazuje vám je ve spodní
èásti obrazovky v oblasti nazývané "echo oblast". Echo oblast obsahuje
dolní øádek obrazovky.
* STAVOVÝ ØÁDEK
---------------
Øádek bezprostøednì nad echo oblastí se nazývá "stavový øádek" ("mode line").
Stavový øádek øíká nìco jako:
2J:** TUTORIAL.cs (Fundamental)--L670--58%----------------
Tento øádek podává u¾iteènou informaci o stavu Emacsu a textu, který
editujete.
U¾ víte, co znamená jméno souboru -- je to soubor, který jste vyhledali.
-NN%-- oznaèuje va¹i aktuální pozici v textu; øíká, ¾e NN procent textu
je nad horním okrajem obrazovky. Je-li zaèátek souboru na obrazovce, je
zde --Top-- a ne --00%--. Je-li konec textu na obrazovce, je zde
--Bot--. Jestli¾e se díváte na tak malý text, ¾e se celý vejde na
obrazovku, stavový øádek øíká --All--.
Hvìzdièky poblí¾ zaèátku znamenají, ¾e jste text zmìnili. Tìsnì po
vyhledání nebo ulo¾ení souboru v této èásti stavového øádku nejsou ¾ádné
hvìzdièky, pouze pomlèky.
Èást stavového øádku v závorkách øíká, v jakých editaèních módech se
nacházíte. Implicitní mód je Fundamental, co¾ je ten, který momentálnì
pou¾íváte. Je pøíkladem hlavního módu ("major mode").
Emacs má celou øadu hlavních módù. Nìkteré z nich jsou urèeny pro
editaci rùzných programovacích jazykù a/nebo textù jako tøeba Lisp mód,
Text mód, atd. V libovolném okam¾iku je aktivní právì jeden hlavní mód a
jeho jméno lze nalézt ve stavovém øádku na místì, kde je teï
"Fundamental".
Ka¾dý hlavní mód mìní chování nìkterých pøíkazù. Napøíklad existují
pøíkazy pro vytváøení komentáøù v programu, a proto¾e ka¾dý programovací
programovací jazyk má jinou pøedstavu o tom, jak má komentáø vypadat,
musí ka¾dý hlavní mód vkládat komentáøe jinak. Ka¾dý hlavní mód je
vlastnì jméno extended pøíkazu, kterým se do tohoto módu mù¾ete
pøepnout. Napøíklad M-x fundamental-mode je pøíkaz pro pøepnutí se do
Fundamental módu.
Chystáte-li se editovat èeský text, jako tøeba tento soubor,
pravdìpodobnì byste mìli pou¾ít Text mód.
>> Napi¹te M-x text-mode<Return>.
Nebojte se, ¾ádný z pøíkazù, které jste se nauèili, chování Emacsu nijak
významnì nezmìní. Mù¾ete si ale v¹imnout, ¾e M-f a M-b nyní pracují
s apostrofy jako se souèástmi slov. Pøedtím, ve Fundamental módu, M-f a
M-b pracovaly s apostrofy coby oddìlovaèi slov.
Hlavní módy obvykle dìlají men¹í zmìny, jako byla tato: pøíkazy vìt¹inou
dìlají "toté¾", ale v ka¾dém hlavním módu pracují tro¹ku jinak.
Dokumentaci k aktuálnímu hlavnímu módu si mù¾ete zobrazit stiskem C-h m.
>> Jednou nebo nìkolikrát pou¾ijte C-u C-v, abyste tento øádek dostali
k vrcholu obrazovky.
>> Stisknìte C-h m, abyste vidìli, jak se Text mód li¹í od Fundamental
módu.
>> Stisknìte C-x 1 pro odstranìní dokumentace z obrazovky.
Hlavní módy se nazývají hlavní proto, ¾e také existují vedlej¹í módy
(minor modes). Vedlej¹í módy nejsou alternativou k hlavním módùm, nýbr¾
jejich malé modifikace. Ka¾dý vedlej¹í mód mù¾e být zapnut nebo vypnut
sám o sobì nezávisle na v¹ech ostatních vedlej¹ích módech a nezávisle na
hlavním módu. Tak¾e nemusíte pou¾ívat ¾ádný vedlej¹í mód nebo mù¾ete
pou¾ívat jeden vedlej¹í mód nebo libovolnou kombinaci nìkolika
vedlej¹ích módù.
Jedním z velmi u¾iteèných vedlej¹ích módù, zejména pro editaci èeských
textù, je Auto Fill mód. Kdy¾ je tento mód zapnut, Emacs zalomí øádek
mezi dvìma slovy, kdykoliv vkládáte text a øádek se stane pøíli¹
dlouhým.
Auto Fill mód mù¾ete zapnout provedením M-x auto-fill-mode<Return>.
Je-li tento mód zapnut, mù¾ete jej vypnout provedením M-x
auto-fill-mode<Return>. Je-li mód vypnut, tento pøíkaz jej zapíná,
a je-li mód zapnut, tak jej tento pøíkaz vypíná. Øíkáme, ¾e tento
pøíkaz pøepíná ("toggles") tento mód.
>> Napi¹te teï M-x auto-fill-mode<Return>. Pak vkládejte "asdf " stále
dokola tak dlouho, a¾ uvidíte, jak se vkládaný øádek rozdìlí na dva
øádky. Do textu musíte vkládat mezery proto, ¾e Auto Fill mód
zalamuje øádky pouze v mezerách.
Okraj je obvykle nastaven na 70 znakù, ale mù¾ete to zmìnit pøíkazem
C-x f. Hodnotu okraje, kterou si pøejete, byste mìli pøedat jako
numerický argument.
>> Napi¹te C-x f s argumentem 20. (C-u 2 0 C-x f).
Pak pi¹te nìjaký text a pozorujte, jak Emacs vyplòuje øádky po
20 znacích. Pak nastavte okraj zpátky na 70 opìtovným pou¾itím
C-x f.
Jestli¾e provedete zmìny uprostøed odstavce, Auto Fill mód jej
nepøeformátuje.
Pro pøeformátování odstavce stisknìte M-q (META-q) s kurzorem uvnitø
odstavce.
>> Pøesuòte kurzor do pøedchozího odstavce a stisknìte M-q.
* VYHLEDÁVÁNÍ
-------------
Emacs umí v textu vyhledávat øetìzce (tj. skupiny spojených znakù nebo
slov) smìrem vpøed nebo vzad. Hledání øetìzce je pøíkaz pøesunující
kurzor; pøesune kurzor na nejbli¾¹í místo, kde se tento øetìzec nachází.
Vyhledávací pøíkaz Emacsu se li¹í od vyhledávacích pøíkazù vìt¹iny
editorù v tom smyslu, ¾e je "inkrementální". To znamená, ¾e vyhledávání
se provádí u¾ v okam¾iku, kdy zadáváte vyhledávací øetìzec.
Pøíkaz pro zahájení hledání vpøed je C-s a pro hledání vzad C-r.
ALE POZOR! Nezkou¹ejte to je¹tì.
Kdy¾ stisknete C-s, uvidíte v echo oblasti prompt "I-search". To vám
øíká, ¾e Emacs se nachází ve stavu, který se nazývá inkrementální hledání,
a èeká, a¾ mu zadáte, co chcete hledat. <RET> hledání ukonèí.
>> Nyní zahajte hledání stiskem C-s. POMALU, písmeno po písmenu, pi¹te
slovo 'kurzor'. Po ka¾dém písmenu si v¹imnìte, co se dìje s kurzorem.
Teï jste vyhledali "kurzor" poprvé.
>> Stisknìte C-s znovu, abyste nalezli dal¹í výskyt "kurzor".
>> Nyní ètyøikrát stisknìte <Delete> a pozorujte, jak se kurzor
pøesunuje.
>> Stisknìte <RET> pro ukonèení hledání.
Vidìli jste, co se stalo? Emacs se v inkrementálním hledání pokou¹í
pøejít na dal¹í výskyt øetìzce, který jste dosud napsali. Chcete-li
pøejít na dal¹í výskyt 'kurzor', jednodu¹e stisknìte C-s znovu.
Jestli¾e u¾ ¾ádný takový výskyt není, Emacs pípne a øekne vám, ¾e
hledání momentálnì "selhává", C-g hledání ukonèí.
POZNÁMKA: Na nìkterých systémech stisk C-s zpùsobí ztuhnutí
obrazovky a nevidíte ¾ádný dal¹í výstup z Emacsu. To znamená, ¾e
"vlastnost" operaèního systému zvaná "flow control" zachycuje C-s a
nepropustí jej k Emacsu. Pro odtuhnutí obrazovky stisknìte C-q. Pak
v sekci "Spontaneous Entry to Incremental Search" v manuálu Emacsu
vyhledejte radu, jak se vypoøádat s touto "vlastností".
Jestli¾e uprostøed inkrementálního hledání stisknete <Delete>, uvidíte,
¾e poslední znak v hledaném øetìzci zmizí a hledání se vrací na poslední
místo hledání. Pøedpokládejme napøíklad, ¾e jste napsali "c", abyste
na¹li první výskyt "k". Jestli¾e nyní stisknete "u", kurzor se pøesune na
první výskyt "ku". Teï stisknìte <Delete>. To vyma¾e "u" z hledaného
øetìzce a kurzor se pøesune zpìt na první výskyt "k".
Jestli¾e uprostøed hledání stisknete CONTROL nebo META znak (s nìkolika
výjimkami -- znaky, které jsou speciální v hledání, jako C-s a C-r),
hledání se ukonèí.
C-s zahajuje hledání, které hledá jakýkoliv výskyt hledaného øetìzce ZA
aktuální pozicí kurzoru. Chcete-li nìco hledat v pøedcházejícím textu,
stisknìte C-r místo C-s. V¹e, co jsme øekli o C-s, platí také o C-r
kromì toho, ¾e smìr hledání je opaèný.
* VÍCE OKEN
-----------
Jednou z pìkných vlastností Emacsu je to, ¾e mù¾e na obrazovce zobrazit
více oken souèasnì.
>> Pøesuòte kurzor na tento øádek a stisknìte C-u 0 C-l.
>> Teï stisknìte C-x 2, co¾ rozdìlí obrazovku na dvì okna.
Obì okna zobrazují tento tutoriál. Kurzor zùstává navrchu okna.
>> Tisknìte C-M-v pro scrollování spodního okna.
(Nemáte-li skuteènou klávesu META, stisknìte ESC C-v.)
>> Stisknìte C-x o ("o" jako "other") pro pøesun kurzoru do dolního okna.
>> Pou¾ijte C-v a M-v ve spodním oknì pro jeho scrollování.
Pokraèujte ve ètení tìchto instrukcí v horním oknì.
>> Znovu stisknìte C-x o pro pøesun kurzoru zpìt do horního okna.
Kurzor v horním oknì je pøesnì na místì, kde byl pùvodnì.
Mù¾ete dále pou¾ívat C-x o pro pøepínání mezi okny. Ka¾dé okno má svoji
vlastní pozici kurzoru, ale jenom jedno okno kurzor skuteènì zobrazuje.
V¹echny obvyklé editaèní pøíkazy platí pro okno, ve kterém se nachází
kurzor. Toto okno nazýváme "aktivní okno" ("selected window").
Pøíkaz C-M-v je velmi u¾iteèný, jestli¾e v jednom oknì editujete text a
druhé okno pou¾íváte pouze pro pøehled. Mù¾ete kurzor nechávat stále
v oknì, kde editujete, a postupovat po druhém oknì pomocí C-M-v.
C-M-v je pøíkladem CONTROL-META znaku. Máte-li skuteènou META klávesu,
mù¾ete vyvolat C-M-v pøidr¾ením obou kláves CTRL a META pøi stisku v.
Nezále¾í na tom, zda je prvnì stisknuta CTRL nebo META, proto¾e obì tyto
klávesy fungují jako modifikátory kláves, které tisknete.
Pokud nemáte skuteènou META klávesu, mù¾ete místo ní pou¾ít ESC, na
poøadí zále¾í: musíte stisknout ESC a následnì CTRL-v; CTRL-ESC v by
nefungovalo. To proto, ¾e ESC je samostatný znak, nikoliv modifikátor.
>> Stisknìte C-x 1 (v horním oknì), abyste se zbavili dolního okna.
(Kdybyste C-x 1 stiskli v dolním oknì, odstranilo by to horní okno.
Chápejte tento pøíkaz jako "ponechej právì jedno okno -- to, ve kterém
zrovna jsem".)
Nemusíte v obou oknech zobrazovat tentý¾ buffer. Jestli¾e pou¾ijete
C-x C-f pro vyhledání souboru v jednom z oken, druhé okno se nezmìní.
Mù¾ete vyhledávat soubory v obou oknech nezávisle.
Zde je dal¹í zpùsob, jak vyu¾ít dvì okna ke zobrazení dvou rùzných vìcí:
>> Stisknìte C-x 4 C-f následované jménem nìkterého z va¹ich souborù.
Dokonèete to pomocí <Return>. Vidíte zadaný soubor v dolním oknì.
Pøesunul se tam i kurzor.
>> Stisknìte C-x o pro pøesun zpìt do horního okna a C-x 1 pro smazání
dolního okna.
* REKURZIVNÍ EDITAÈNÍ ÚROVNÌ
----------------------------
Obèas se dostanete do nìèeho, co se nazývá "rekurzivní editaèní úroveò"
("recursive editing level"). To je indikováno hranatými závorkami ve
stavovém øádku obklopujícími závorky okolo jména hlavního módu.
Napøíklad mù¾ete vidìt [(Fundamental)] místo (Fundamental).
Abyste se dostali z rekurzivní editaèní úrovnì, stisknìte ESC ESC ESC.
To je obecný "vyskakovací" pøíkaz. Mù¾ete jej pou¾ít té¾ pro odstranìní
nìkterých oken a vyskoèení z minibufferu.
>> Stisknìte M-x, abyste se dostali do minibufferu; pak stisknìte
ESC ESC ESC, abyste se z nìj dostali ven.
Z rekurzivní editaèní úrovnì nemù¾ete vyskoèit pomocí C-g. To proto, ¾e
C-g je vyu¾íváno pro ru¹ení pøíkazù a argumentù UVNITØ rekurzivní
editaèní vrstvy.
* ZÍSKÁNÍ DAL©Í NÁPOVÌDY
------------------------
V tomto tutoriálu jsme se pokusili poskytnout vám dostatek informací,
abyste mohli zaèít Emacs pou¾ívat. V Emacsu je toho tolik, ¾e by bylo
nemo¾né to zde v¹echno objasnit. Nicménì se o Emacsu mù¾ete nauèit
více, proto¾e má mnoho u¾iteèných vlastností. Emacs nabízí pøíkazy pro
ètení dokumentace svých pøíkazù. V¹echny tyto "help" pøíkazy
zaèínají znakem CONTROL-h, který se nazývá "help znak".
Pro pou¾ití vlastností nápovìdy stisknìte znak C-h a pak znak øíkající,
jaký druh nápovìdy ¾ádáte. Jste-li OPRAVDU ztraceni, stisknìte C-h ? a
Emacs vám sdìlí, jaké druhy nápovìdy vám mù¾e poskytnout. Jestli¾e
jste stiskli C-h a pak jste se rozhodli, ¾e ¾ádnou nápovìdu nechcete,
jednodu¹e to zru¹te stiskem C-g.
(Na nìkterých poèítaèích je význam znaku C-h zmìnìn. To by opravdu
nemìlo být obecným nastavením pro v¹echny u¾ivatele, tak¾e máte právo
stì¾ovat si systémovému administrátorovi. Do té doby, jestli¾e C-h
nezobrazuje hlá¹ení o nápovìdì v dolní èásti obrazovky, zkuste místo
toho pou¾ívat klávesu F1 nebo M-x help RET.)
Nejzákladnìj¹í help pøíkaz je C-h c. Stisknìte C-h, znak c a klávesový
pøíkaz; Emacs pak zobrazí velmi struèný popis pøíkazu.
>> Stisknìte C-h c C-p.
Hlá¹ení by mìlo vypadat asi takto
C-p runs the command previous-line
To vám sdìluje "jméno funkce". Jména funkcí jsou pou¾ívána zejména pro
konfiguraci a roz¹iøování Emacsu. Ale proto¾e jména funkcí jsou volena
tak, aby naznaèovala, co odpovídající pøíkaz dìlá, mohou slou¾it také
jako velmi struèná dokumentace -- dostateèná k tomu, aby vám pøipomenula
pøíkazy, které jste se ji¾ nauèili.
Víceznakové pøíkazy jako C-x C-s a (pokud nemáte META, EDIT ani ALT
klávesu) <ESC>v jsou po C-h c povoleny také.
K získání více informací o pøíkazu místo C-h c pou¾ijte C-h k.
>> Stisknìte C-h k C-p.
To zobrazí dokumentaci k funkci a její jméno v emacsovém oknì. A¾
výstup pøeètete, stisknìte C-x 1, abyste se textu nápovìdy zbavili.
Nemusíte to dìlat hned. Mù¾ete chvíli editovat a nahlí¾et do textu
nápovìdy a teprve pak stisknout C-x 1.
Zde jsou dal¹í u¾iteèné C-h volby:
C-h f Popis funkce. Zadáváte jméno funkce.
>> Zkuste napsat C-h f previous-line<Return>.
To vypí¹e ve¹keré informace, které Emacs má o funkci implementující
pøíkaz C-p.
Podobný pøíkaz C-h v zobrazí dokumentaci promìnné, její¾ hodnotu
mù¾ete nastavit a zmìnit tím chování Emacsu. Jméno promìnné zadáte, a¾
se na nì Emacs zeptá.
C-h a Pøíkazové apropos. Zadejte klíèové slovo a Emacs vypí¹e
v¹echny pøíkazy, jejich¾ jména obsahují toto klíèové
slovo. V¹echny tyto pøíkazy mohou být vyvolány pomocí
META-x. Pro nìkteré pøíkazy pøíkazové apropos vypí¹e
také jedno nebo dvouznakové sekvence, které provádìjí
tentý¾ pøíkaz.
>> Napi¹te C-h a file<Return>.
To zobrazí v druhém oknì seznam v¹ech M-x pøíkazù obsahujících "file" ve
svém názvu. Znakové pøíkazy jako C-x C-f uvidíte vypsané vedle
odpovídajících jmen pøíkazù jako find-file.
>> Stisknìte C-M-v pro posun okna s nápovìdou. Proveïte to nìkolikrát.
>> Stisknìte C-x 1 pro smazání okna s nápovìdou.
C-h i Ètení on-line manuálù (té¾ Info). Tento pøíkaz
vás pøepne do speciálního bufferu s názvem `*info*',
ve kterém mù¾ete èíst on-line manuály pro balíky
nainstalované na va¹em systému. Pokud stisknete
m emacs <Return> mù¾ete si napøíklad pøeèíst manuál
k Emacsu. Pokud jste dosud nikdy nepou¾ívali Info,
stisknìte ? a Emacs vám pøedstaví hlavní mo¾nosti
módu pro Info. A¾ si tyto mo¾nosti prostudujete,
mìli byste pou¾ívat Info manuál Emacsu jako svoji
primární dokumentaci.
* ZÁVÌR
-------
Nezapomeòte, Emacs ukonèíte provedením pøíkazu C-x C-c. Pro doèasný
odskok do shellu, ze kterého se do Emacsu mù¾ete opìt vrátit,
pou¾ijte C-z.
Zámìrem tohoto tutoriálu je být srozumitelný v¹em novým u¾ivatelùm, tak¾e
narazíte-li na nìco nejasného, tak neusedejte a neklaïte to za vinu sobì
-- stì¾ujte si!
KOPÍROVÁNÍ
----------
Tento tutoriál vychází z dlouhé øady emacsových tutoriálù zahájené
tutoriálem napsaným Stuartem Cracraftem pro pùvodní Emacs.
Tato verze tutoriálu je, podobnì jako GNU Emacs, chránìna copyrightem a
je ¹íøena se svolením distribuovat kopie za jistých podmínek:
Copyright (c) 1985, 1996 Free Software Foundation
Ka¾dému je zaruèeno právo vytváøet a distribuovat pøesné kopie tohoto
dokumentu tak, jak jej obdr¾el, na jakémkoliv médiu, s tím, ¾e bude
zachována tato poznámka o autorství a poznámka o svolení a ¾e
distributor zaruèuje pøíjemci právo na dal¹í redistribuci povolenou
touto poznámkou.
Je zaruèeno právo distribuovat modifikované verze tohoto dokumentu
nebo jeho èástí pod vý¹e uvedenými podmínkami za pøedpokladu, ¾e
obsahuje jasné poznámky uvádìjící, kdo provedl poslední modifikace.
Podmínky pro kopírování Emacsu samotného jsou slo¾itìj¹í, av¹ak ve
stejném duchu. Pøeètìte si prosím soubor COPYING a pak pøedávejte kopie
GNU Emacsu svým pøátelùm. Pomáhejte potírat softwarovou obstrukci
("vlastnictví") pou¾íváním, psaním a sdílením free softwaru!
;;; Local Variables:
;;; coding: iso-latin-2
;;; End:
- 3 participants
- 6 comments
[comp.emacs.xemacs] core dump on SunOS 5.7 sun4u
24 years
Adrian Aichner
Adrian Aichner
Hi Carl,
please install the latest version of the net-utils package (1.23) and
then use Help/Send Bug Report ... or
M-x report-emacs-bug
to provide a better bug report with lots of information automatically
included for you (you can review it all before sending).
If you could compile XEmacs with debug information, the C Backtrace
would be even more valuable.
Best regards,
Adrian
--
Adrian Aichner
mailto:adrian＠xemacs.org
http://www.xemacs.org/
- 1 participants
- 0 comments
displaying directory
24 years
James Bryant
James Bryant
Does anyone know how to display the path a particular file is located in
when it is open in emacs (either within a title bar or anyot? IF YOU DO
PLEAESE RESPOND TO ME AT:
jcbryant(a)cisco.com
Sorry for the trivial question if it is on. I am not that experienced in
configuring xemacs.
THANKS!!!
_______________________________
James Bryant
Software Engineer
Cisco Systems
Bradenton, FL
941-708-4734
- 4 participants
- 3 comments
Re: Xemacs 21.4.3 generating .#Filename file when editing
24 years
Adrian Aichner
Adrian Aichner
The following message is a courtesy copy of an article
that has been posted to comp.emacs.xemacs as well.
>>>>> "Jonathan" == Jonathan Albrecht <albrecht(a)algorithmics.com> writes:
Jonathan> Sorry, I don't see how this could be a cvs interation. I
Jonathan> am not using cvs. The .# files are created by xemacs
Jonathan> 21.4.3 when I make changes in a buffer corresponding to
Jonathan> a visited file. Here is the description of the behaviour
Jonathan> I see:
Jonathan> If I am editing a file on a NT filesystem the .# file
Jonathan> only exists while the buffer for the file has unsaved
Jonathan> changes. On NT, as soon as I save the file, the
Jonathan> corresponding .# file is deleted. If the file being
Jonathan> edited is on a samba filesystem, the .#file is not
Jonathan> deleted.
Jonathan> It seems to me that the .# file is just there to show
Jonathan> that the buffer and its corresponding file are out of
Jonathan> sync. I see that the .# filename format is the same
Jonathan> format as for files in which merge collisions have
Jonathan> occured in cvs, but I think that is just a coincidence
Jonathan> in this case. Unless PCL-CVS is doing something wacky to
Jonathan> every file being edited.
Hi Jonathan,
what do you use PCL-CVS for, when you are not using cvs?
Anyway, I think Eli is right. These are probably interlocking files.
See:
http://cvs.xemacs.org/cgi-bin/cvswebxe/xemacs/src/filelock.c?rev=1.11
I don't have file-locking in my native Windows 2000 XEmacs.
All I can suggest is this:
(setq inhibit-clash-detection nil)
Hope this helps,
Adrian
Jonathan> Thanks,
Jonathan> Jon
Jonathan> Adrian Aichner wrote:
>>>>>>> "Jonathan" == Jonathan Albrecht <albrecht(a)algorithmics.com> writes:
>>>>>>>
Jonathan> I just tried XEmacs 21.1.13 and it does not create the
Jonathan> .# files. Anyone know what they are for?
>> For an answer to your question see the CVS manuals.
>> If you have cvs Info files installed following sexp should beam you
>> there:
>> (Info-goto-node "(cvs)update output")
>> Best regards,
>> Adrian
Jonathan> Jon
Jonathan> Jonathan Albrecht wrote:
>> >> No the .# files do not go away when I exit XEmacs. If I am
>> >> editing a
>> >> file on a NT filesystem the .# file only exists while the buffer for
>> >> the file has unsaved changes. On NT, as soon as I save the file, the
>> >> corresponding .# file is deleted. If the file being edited is on a
>> >> samba filesystem, the .#file is not deleted. I don't know if this is
>> >> an XEmacs or cygwin problem.
>> >> Jon
>> >> David Masterson wrote:
>> >> >>> IIRC, the '.#' files don't have anything to do with
>> >> >>> CVS (or the Emacs
>> >>> interface to CVS) -- I believe its created by auto-save-mode, but I
>> >>> could be wrong (auto-save files are '#file#'?). This facility is
>> >>> (mostly?) built-in, so it wouldn't show up in the .el files (unless
>> >>> you really know what you're looking for). Also, although I said the
>> >>> '!<symlink>' is a Cygwin symlink, I'm not sure what it's a symlink to.
>> >>> >>> Does the .# file go away when you exit Emacs? If
>> >>> >>> so, don't worry
>> >>> about it -- Emacs is handling it.
>> >>> >>> What I haven't figured out is how to handle the
>> >>> >>> '.saves-*' files that
>> >>> (X)Emacs generates on all platforms I use it on. They don't seem to
>> >>> go away unless I specifically delete them.
>> >>> >>> >>>>>>>> Jonathan Albrecht writes:
>> >>>>>>>> >>> >>>> Thanks for the info. So it seems that
>> >>>>>>>> >>> >>>> xemacs is trying to make a
>> >>>> symlink of the form:
>> >>>> >>> >>>> .#filename
>> >>>> >>> >>>> to the file:
>> >>>> >>> >>>> filename
>> >>>> >>> >>>> for some reason. I've been grepping
>> >>>> >>> >>>> through the .el files for .# but
>> >>>> the only thing I've found is some cvs related stuff. I'm not using
>> >>>> cvs. Does anyone know what else .# prefixed files are used for? I
>> >>>> don't think it's auto-save, those filenames are of the form #filename#
>> >>>> I believe. I'll look into it some more though.
>> >>>> >>> >>>> Jon
>> >>>> >>> >>>> David Masterson wrote:
>> >>>> >>> >>>>>>>>>> Jonathan Albrecht writes:
>> >>>>>>>>>> >>>>>>>>>>
>>>>>>> I am using Xemacs 21.4.3 on cygwin. I am finding that when I edit file
>>>>>>> there is another file generated with the same filename but prefixed
>>>>>>> with '.#'. The contents of the file are:
>>>>>>>
>> >>>>>> >>>>>>
>>>>>>> !<symlink>albrecht(a)toralbrecht.myhost.com.328^＠
>>>>>>>
>> >>>>>> >>>>>>
>>>>>>> anyone know what is generating these files?
>>>>>>>
>> >>>>>> >>>>>> >>>>> Not off-hand. The ".#" files are
>> >>>>>> >>>>>> >>>>> temporary Emacs (autosave?) files
>> >>>>> for the file you're currently editing and should go away when you save
>> >>>>> the file. The "!<symlink>" file is a symbolic link in Cygwin.
>> >>>>> >>>>> >>> >>> >>
--
Adrian Aichner
mailto:adrian＠xemacs.org
http://www.xemacs.org/
- 1 participants
- 0 comments
Re: XEmacs FAQ
24 years
Adrian Aichner
Adrian Aichner
>>>>> "Mohamed" == Mohamed Ghanem <Mohamed.Ghanem(a)peregrine.com> writes:
Mohamed> Hi,
Mohamed> I have a question which I tried to find an answer for in
Mohamed> the online FAQ and elsewhere. I just downloaded
Mohamed> xemacs-21.4.4 and compiled it for Solaris 2.6. I
Mohamed> discovered that the right shif key on my keyboard types
Mohamed> an asterisk '*' every time I press it. For example, if I
Mohamed> type on the Shift-4 to insert '$' in my buffer, I get
Mohamed> '*$'. Would you happen to know why this is happening? I
Hi Mohamed,
does this only happen in XEmacs 21.4.4?
Does it also happen when you start XEmacs as follows?
xemacs -vanilla
If not, then you have to check your init files (~/.emacs,
~/.xemacs/init.el, ~/.xemacs/custom.el, site-start.el) for the reason.
Do you have an older XEmacs, or even GNU Emacs, that you could try
this in?
Does this happen in shell windows too?
Does it happen in vi, if you ever use that one?
Best regards,
Adrian
Mohamed> have always used XEmacs (since version 19 to be exact)
Mohamed> and never got this. Is there any key mapping that are
Mohamed> assumed in 21.4.4? I had 21.1 before that and was working
Mohamed> perfectly fine.
Mohamed> Sincerely,
Mohamed> M. Ezz
--
Adrian Aichner
mailto:adrian＠xemacs.org
http://www.xemacs.org/
- 1 participants
- 0 comments
[ANNOUNCE] Updated Packages Released - Oct 5
24 years
Steve Youngs
Steve Youngs
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
Hello.
The following XEmacs packages have just been released.
Updated or New Packages:
=======================
ediff-1.33-pkg.tar.gz
edit-utils-1.70-pkg.tar.gz
net-utils-1.23-pkg.tar.gz
prog-modes-1.42-pkg.tar.gz
viper-1.28-pkg.tar.gz
xemacs-devel-1.38-pkg.tar.gz
Detailed Changes:
================
ediff-1.33-pkg.tar.gz:
- ---------------------
2001-09-27 Michael Kifer <kifer(a)cs.sunysb.edu>
* ediff-mult.el (ediff-get-meta-info): Installed Gerd's changes.
Added comments.
2001-09-09 Michael Kifer <kifer(a)cs.sunysb.edu>
* ediff-init.el (ediff-highest-priority): bug fix.
* ediff-mult.el (ediff-get-meta-info): replace and with or.
edit-utils-1.70-pkg.tar.gz:
- --------------------------
2001-09-29 Jeff Mincy <jeff(a)delphioutpost.com>
* recent-files.el (recent-files-entry-to-menu-entry): Don't
prepend "*" if in a submenu.
net-utils-1.23-pkg.tar.gz:
- -------------------------
2001-09-28 Stephen J. Turnbull <stepheen(a)xemacs.org>
* xemacsbug.el (report-emacs-bug): Missing autoload.
prog-modes-1.42-pkg.tar.gz:
- --------------------------
2001-06-19 Barry Warsaw <barry(a)xemacs.org>
* python-mode.el (python-font-lock-keywords):
Add "yield" as a keyword to support the new "simple
generators" feature of 2.2. See PEP 255.
2001-06-18 Barry Warsaw <barry(a)xemacs.org>
* python-mode.el (py-continuation-offset):
New variable which controls how much to indent continuation
lines, defined as lines following those that end in backslash
continuing a block opening statement.
2001-09-10 Raymond Toy <toy(a)rtp.ericsson.se>
* fortran.el (fortran-mode-map): Keep M-BS as backward-kill-word
and make C-M-h 'mark-fortran-subprogram.
viper-1.28-pkg.tar.gz:
- ---------------------
2001-09-13 Michael Kifer <kifer(a)cs.sunysb.edu>
* viper-cmd.el (viper-replace-char-subr, viper-envelop-ESC-key):
inhibit quit.
2001-09-09 Michael Kifer <kifer(a)cs.sunysb.edu>
* viper-cmd.el (viper-special-read-and-insert-char): new function
that reads a character and uses the current input method or
iso-accents when appropriate.
* viper.el and all others: corrections to the comment blocks at
the top.
xemacs-devel-1.38-pkg.tar.gz:
- ----------------------------
2001-09-08 Adrian Aichner <adrian(a)xemacs.org>
* bench.el (bench-large-lisp-file): Use expand-file-name instead
of concat to build path.
* bench.el (bench-small-lisp-file): Ditto.
2001-09-04 Jeff Mincy <jeff(a)delphioutpost.com>
* hide-copyleft.el (hide-copyleft-region): Make it interactive.
Installing These:
================
Manually:
- --------
1) Download the packages that you want to install from: [1]
/ftp.xemacs.org:/pub/xemacs/packages/
2) Unpack them to: [2]
/usr/local/lib/xemacs/xemacs-packages/
3) Re-start XEmacs.
Using XEmacs Package Tools (XEmacs 21.[245].x):
- ----------------------------------------------
1) Tools -> Packages -> Add Download Site -> choose site
2) Tools -> Packages -> List and Install
3) Select the packages you wish to install (there are brief
instructions at the bottom of the packages buffer).
4) Packages -> Install/Remove Selected
5) Re-start XEmacs.
Using XEmacs Package Tools (XEmacs 21.1.14):
- -------------------------------------------
1) Options -> Manage Packages -> Add Download Site -> choose site
2) Options -> Manage Packages -> List and Install
3 - 5) As per XEmacs 21.[245].x.
Footnotes:
[1] Or from a mirror near you.
[2] Note: Mule packages should be installed into:
/usr/local/lib/xemacs/mule-packages/
- --
|---<Steve Youngs>---------------<GnuPG KeyID: 9E7E2820>---|
| XEmacs - It's not just an editor. |
| It's a way of life. |
|------------------------------------<youngs(a)xemacs.org>---|
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.0.6 (GNU/Linux)
Comment: The XEmacs Development Team.
iD8DBQE7vNoNY2VD3p5+KCARAlzMAJ9L9i/EhbxcNm8l+J/TGpnvl6eJSwCgohpO
f5fmAa9wAeiIL+k1R6PpMOI=
=8FoD
-----END PGP SIGNATURE-----
- 2 participants
- 3 comments
[ANNOUNCE] New Sumo Packages Released.
24 years
Steve Youngs
Steve Youngs
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
Hi Folks!
I've just uploaded new Sumo's to ftp.xemacs.org. They are in the
normal place (/pub/xemacs/packages/).
Updated Packages in this Sumo Release:
- -------------------------------------
auctex-1.25-pkg.tar.gz
bbdb-1.16-pkg.tar.gz
calc-1.17-pkg.tar.gz
cc-mode-1.26-pkg.tar.gz
edebug-1.14-pkg.tar.gz
ediff-1.33-pkg.tar.gz
edit-utils-1.70-pkg.tar.gz
edt-1.12-pkg.tar.gz
eudc-1.34-pkg.tar.gz
gnus-1.57-pkg.tar.gz
ispell-1.23-pkg.tar.gz
net-utils-1.23-pkg.tar.gz
pcl-cvs-1.55-pkg.tar.gz
prog-modes-1.42-pkg.tar.gz
semantic-1.10-pkg.tar.gz
speedbar-1.21-pkg.tar.gz
supercite-1.18-pkg.tar.gz
text-modes-1.32-pkg.tar.gz
tm-1.29-pkg.tar.gz
vc-1.28-pkg.tar.gz
viper-1.28-pkg.tar.gz
vm-6.96-pkg.tar.gz
xemacs-devel-1.38-pkg.tar.gz
xslt-process-1.05-pkg.tar.gz
zenirc-1.11-pkg.tar.gz
The following packages are NOT in the Sumo:
- ------------------------------------------
Sun-1.13-pkg.tar.gz
- Right now I can't remember the reason this package was left
out. If you think that you need it you can easily grab it
using the normal XEmacs package tools.
eicq-1.05-pkg.tar.gz
- This package will only run on GNU/Linux x86 systems.
jde-1.30-pkg.tar.gz
- This package has some tar related issues that hopefully will
be resolved in the next release.
dictionary-1.00-pkg.tar.gz
- The truth of the matter here is that this is a new package
and I simply forgot to include it in the Sumo. It'll
definitely be in the next Sumo.
All of those packages are available using the normal XEmacs package
tools.
- --
|---<Steve Youngs>---------------<GnuPG KeyID: 9E7E2820>---|
| XEmacs - It's not just an editor. |
| It's a way of life. |
|------------------------------------<youngs(a)xemacs.org>---|
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.0.6 (GNU/Linux)
Comment: The XEmacs Development Team.
iD8DBQE7vOUuY2VD3p5+KCARAuINAKCPnD5fK/lY1FlfcxbCy5uSG1aWHgCgyPbn
UI+/nPYAMmxr4biokEl4F8E=
=XfnN
-----END PGP SIGNATURE-----
- 1 participants
- 0 comments
xemacs XmProcessTraversal crash on HPUX
24 years
Steven_Gillard.AMAWORLD＠amadeus.net
Steven_Gillard.AMAWORLD＠amadeus.net
I've seen this crash in two different cases:
- when exiting xemacs without saving changes to a file
- when attempting to update packages
I'm certain this problem will occur any time xemacs attempts to create a
simple question dialog box. It crashes during a call to XmProcessTraversal
made in the make_dialog function of lwlib-Xm.c.
I did some further digging into the core with gdb and found that the
'value' variable which is passed to XmProcessTraversal as the widget id is
0, hence the crash. This will occur if the text_input_slot, radio_box and
list are all false. I've hacked around the problem by making the following
change to the make_dialog function in lwlib/lwlib-Xm.c:
# diff lwlib-Xm.c lwlib-Xm.c.orig
1272c1272
< else if (value != 0)
---
> else
It now displays a somewhat strange looking yet functional question dialog
box, but it doesn't crash.
Platform: HP L2000 running HPUX 11.0
Here's the stack trace:
(gdb) bt
#0 0xc01f45a0 in kill () from /usr/lib/libc.2
#1 0x94fdc in fatal_error_signal (sig=2138629244) at emacs.c:264
#2 <signal handler called>
#3 0xc32a14c0 in XtWidgetToApplicationContext () from
/usr/lib/X11R6/libXt.3
#4 0xc3976ac0 in XmProcessTraversal () from /usr/lib/libXm.4
#5 0x1a8b38 in make_dialog (name=0x0, parent=0x7f7076d5, pop_up_p=80 'P',
shell_title=0x40309200 "＠0\222", icon_name=0x1cbc2c "dbox-question",
text_input_slot=0 '\000', radio_box=0 '\000', list=0 '\000',
left_buttons=6, right_buttons=0) at lwlib-Xm.c:1275
#6 0x1a91f4 in xm_create_dialog (instance=0x40305f80) at lwlib-Xm.c:1482
#7 0x1a04a0 in instantiate_widget_instance (instance=0x40305f80) at
lwlib.c:866
#8 0x1a05dc in lw_make_widget (id=0, parent=0x40274e00, pop_up_p=1 '\001')
at lwlib.c:345
#9 0x1a10c0 in lw_create_widget (type=0x400b9280 "Q6BR0", name=0x1bc298
"dialog", id=65540, val=0x40286f40, parent=0x40274e00, pop_up_p=1,
pre_activate_cb=0, selection_cb=0x400b5772 <dbox_selection_callback>,
post_activate_cb=0) at lwlib.c:918
#10 0xb9634 in x_popup_dialog_box (f=0x40274e00, dbox_desc=0) at
dialog-x.c:228
#11 0xb20a0 in Fpopup_dialog_box (dbox_desc=1075093796) at dialog.c:77
#12 0x9a408 in funcall_recording_as (recorded_as=0, nargs=1,
args=0x7f7f3980) at eval.c:3197
#13 0x9f8a0 in Ffuncall (nargs=0, args=0x7f717d50) at eval.c:3238
#14 0x6ed78 in Fbyte_code (bytestr=2139044040, vector=2139044088,
maxdepth=1) at bytecode.c:416
#15 0x7f7f3980 in ?? ()
#16 0x94fdc in fatal_error_signal (sig=1074498056) at emacs.c:264
If you need any further info, let me know.
Regards,
Steve
UNIX Systems Administrator
Amadeus Services Ltd, UK
- 1 participants
- 0 comments