Mercurial > hg > xemacs-beta
view etc/TUTORIAL.sl @ 5353:38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
lisp/ChangeLog addition:
2011-02-07 Aidan Kehoe <kehoea@parhasard.net>
* bytecomp.el:
* bytecomp.el (byte-compile-initial-macro-environment):
Shadow `block', `return-from' here, we implement them differently
when byte-compiling.
* bytecomp.el (byte-compile-active-blocks): New.
* bytecomp.el (byte-compile-block-1): New.
* bytecomp.el (byte-compile-return-from-1): New.
* bytecomp.el (return-from-1): New.
* bytecomp.el (block-1): New.
These are two aliases that exist to have their own associated
byte-compile functions, which functions implement `block' and
`return-from'.
* cl-extra.el (cl-macroexpand-all):
Fix a bug here when macros in the environment have been compiled.
* cl-macs.el (block):
* cl-macs.el (return):
* cl-macs.el (return-from):
Be more careful about lexical scope in these macros.
* cl.el:
* cl.el ('cl-block-wrapper): Removed.
* cl.el ('cl-block-throw): Removed.
These aren't needed in code generated by this XEmacs. They
shouldn't be needed in code generated by XEmacs 21.4, but if it
turns out the packages do need them, we can put them back.
2011-01-30 Mike Sperber <mike@xemacs.org>
* font-lock.el (font-lock-fontify-pending-extents): Don't fail if
`font-lock-mode' is unset, which can happen in the middle of
`revert-buffer'.
2011-01-23 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (delete):
* cl-macs.el (delq):
* cl-macs.el (remove):
* cl-macs.el (remq):
Don't use the compiler macro if these functions were given the
wrong number of arguments, as happens in lisp-tests.el.
* cl-seq.el (remove, remq): Removed.
I added these to subr.el, and forgot to remove them from here.
2011-01-22 Aidan Kehoe <kehoea@parhasard.net>
* bytecomp.el (byte-compile-setq, byte-compile-set):
Remove kludge allowing keywords' values to be set, all the code
that does that is gone.
* cl-compat.el (elt-satisfies-test-p):
* faces.el (set-face-parent):
* faces.el (face-doc-string):
* gtk-font-menu.el:
* gtk-font-menu.el (gtk-reset-device-font-menus):
* msw-font-menu.el:
* msw-font-menu.el (mswindows-reset-device-font-menus):
* package-get.el (package-get-installedp):
* select.el (select-convert-from-image-data):
* sound.el:
* sound.el (load-sound-file):
* x-font-menu.el (x-reset-device-font-menus-core):
Don't quote keywords, they're self-quoting, and the
win from backward-compatibility is sufficiently small now that the
style problem overrides it.
2011-01-22 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (block, return-from): Require that NAME be a symbol
in these macros, as always documented in the #'block docstring and
as required by Common Lisp.
* descr-text.el (unidata-initialize-unihan-database):
Correct the use of non-symbols in #'block and #'return-from in
this function.
2011-01-15 Aidan Kehoe <kehoea@parhasard.net>
* cl-extra.el (concatenate): Accept more complicated TYPEs in this
function, handing the sequences over to #'coerce if we don't
understand them here.
* cl-macs.el (inline): Don't proclaim #'concatenate as inline, its
compiler macro is more useful than doing that.
2011-01-11 Aidan Kehoe <kehoea@parhasard.net>
* subr.el (delete, delq, remove, remq): Move #'remove, #'remq
here, they don't belong in cl-seq.el; move #'delete, #'delq here
from fns.c, implement them in terms of #'delete*, allowing support
for sequences generally.
* update-elc.el (do-autoload-commands): Use #'delete*, not #'delq
here, now the latter's no longer dumped.
* cl-macs.el (delete, delq): Add compiler macros transforming
#'delete and #'delq to #'delete* calls.
2011-01-10 Aidan Kehoe <kehoea@parhasard.net>
* dialog.el (make-dialog-box): Correct a misplaced parenthesis
here, thank you Mats Lidell in 87zkr9gqrh.fsf@mail.contactor.se !
2011-01-02 Aidan Kehoe <kehoea@parhasard.net>
* dialog.el (make-dialog-box):
* list-mode.el (display-completion-list):
These functions used to use cl-parsing-keywords; change them to
use defun* instead, fixing the build. (Not sure what led to me
not including this change in d1b17a33450b!)
2011-01-02 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (define-star-compiler-macros):
Make sure the form has ITEM and LIST specified before attempting
to change to calls with explicit tests; necessary for some tests
in lisp-tests.el to compile correctly.
(stable-union, stable-intersection): Add compiler macros for these
functions, in the same way we do for most of the other functions
in cl-seq.el.
2011-01-01 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (dolist, dotimes, do-symbols, macrolet)
(symbol-macrolet):
Define these macros with defmacro* instead of parsing the argument
list by hand, for the sake of style and readability; use backquote
where appropriate, instead of calling #'list and and friends, for
the same reason.
2010-12-30 Aidan Kehoe <kehoea@parhasard.net>
* x-misc.el (device-x-display):
Provide this function, documented in the Lispref for years, but
not existing previously. Thank you Julian Bradfield, thank you
Jeff Mincy.
2010-12-30 Aidan Kehoe <kehoea@parhasard.net>
* cl-seq.el:
Move the heavy lifting from this file to C. Dump the
cl-parsing-keywords macro, but don't use defun* for the functions
we define that do take keywords, dynamic scope lossage makes that
not practical.
* subr.el (sort, fillarray): Move these aliases here.
(map-plist): #'nsublis is now built-in, but at this point #'eql
isn't necessarily available as a test; use #'eq.
* obsolete.el (cl-delete-duplicates): Make this available for old
compiler macros and old code.
(memql): Document that this is equivalent to #'member*, and worse.
* cl.el (adjoin, subst): Removed. These are in C.
2010-12-30 Aidan Kehoe <kehoea@parhasard.net>
* simple.el (assoc-ignore-case): Remove a duplicate definition of
this function (it's already in subr.el).
* iso8859-1.el (char-width):
On non-Mule, make this function equivalent to that produced by
(constantly 1), but preserve its docstring.
* subr.el (subst-char-in-string): Define this in terms of
#'substitute, #'nsubstitute.
(string-width): Define this using #'reduce and #'char-width.
(char-width): Give this a simpler definition, it makes far more
sense to check for mule at load time and redefine, as we do in
iso8859-1.el.
(store-substring): Implement this in terms of #'replace, now
#'replace is cheap.
2010-12-30 Aidan Kehoe <kehoea@parhasard.net>
* update-elc.el (lisp-files-needed-for-byte-compilation)
(lisp-files-needing-early-byte-compilation):
cl-macs belongs in the former, not the latter, it is as
fundamental as bytecomp.el.
2010-12-30 Aidan Kehoe <kehoea@parhasard.net>
* cl.el:
Provde the Common Lisp program-error, type-error as error
symbols. This doesn't nearly go far enough for anyone using the
Common Lisp errors.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (delete-duplicates):
If the form has an incorrect number of arguments, don't attempt a
compiler macroexpansion.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (cl-safe-expr-p):
Forms that start with the symbol lambda are also safe.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (= < > <= >=):
For these functions' compiler macros, the optimisation is safe
even if the first and the last arguments have side effects, since
they're only used the once.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (inline-side-effect-free-compiler-macros):
Unroll a loop here at macro-expansion time, so these compiler
macros are compiled. Use #'eql instead of #'eq in a couple of
places for better style.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* cl-extra.el (notany, notevery): Avoid some dynamic scope
stupidity with local variable names in these functions, when they
weren't prefixed with cl-; go into some more detail in the doc
strings.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* byte-optimize.el (side-effect-free-fns): #'remove, #'remq are
free of side-effects.
(side-effect-and-error-free-fns):
Drop dot, dot-marker from the list.
2010-11-17 Aidan Kehoe <kehoea@parhasard.net>
* cl-extra.el (coerce):
In the argument list, name the first argument OBJECT, not X; the
former name was always used in the doc string and is clearer.
Handle vector type specifications which include the length of the
target sequence, error if there's a mismatch.
* cl-macs.el (cl-make-type-test): Handle type specifications
starting with the symbol 'eql.
2010-11-14 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (eql): Don't remove the byte-compile property of this
symbol. That was necessary to override a bug in bytecomp.el where
#'eql was confused with #'eq, which bug we no longer have.
If neither expression is constant, don't attempt to handle the
expression in this compiler macro, leave it to byte-compile-eql,
which produces better code anyway.
* bytecomp.el (eq): #'eql is not the function associated with the
byte-eq byte code.
(byte-compile-eql): Add an explicit compile method for this
function, for cases where the cl-macs compiler macro hasn't
reduced it to #'eq or #'equal.
2010-10-25 Aidan Kehoe <kehoea@parhasard.net>
Add compiler macros and compilation sanity-checking for various
functions that take keywords.
* byte-optimize.el (side-effect-free-fns): #'symbol-value is
side-effect free and not error free.
* bytecomp.el (byte-compile-normal-call): Check keyword argument
lists for sanity; store information about the positions where
keyword arguments start using the new byte-compile-keyword-start
property.
* cl-macs.el (cl-const-expr-val): Take a new optional argument,
cl-not-constant, defaulting to nil, in this function; return it if
the expression is not constant.
(cl-non-fixnum-number-p): Make this into a separate function, we
want to pass it to #'every.
(eql): Use it.
(define-star-compiler-macros): Use the same code to generate the
member*, assoc* and rassoc* compiler macros; special-case some
code in #'add-to-list in subr.el.
(remove, remq): Add compiler macros for these two functions, in
preparation for #'remove being in C.
(define-foo-if-compiler-macros): Transform (remove-if-not ...) calls to
(remove ... :if-not) at compile time, which will be a real win
once the latter is in C.
(define-substitute-if-compiler-macros)
(define-subst-if-compiler-macros): Similarly for these functions.
(delete-duplicates): Change this compiler macro to use
#'plists-equal; if we don't have information about the type of
SEQUENCE at compile time, don't bother attempting to inline the
call, the function will be in C soon enough.
(equalp): Remove an old commented-out compiler macro for this, if
we want to see it it's in version control.
(subst-char-in-string): Transform this to a call to nsubstitute or
nsubstitute, if that is appropriate.
* cl.el (ldiff): Don't call setf here, this makes for a load-time
dependency problem in cl-macs.el
2010-06-14 Stephen J. Turnbull <stephen@xemacs.org>
* term/vt100.el:
Refer to XEmacs, not GNU Emacs, in permissions.
* term/bg-mouse.el:
* term/sup-mouse.el:
Put copyright notice in canonical "Copyright DATE AUTHOR" form.
Refer to XEmacs, not GNU Emacs, in permissions.
* site-load.el:
Add permission boilerplate.
* mule/canna-leim.el:
* alist.el:
Refer to XEmacs, not APEL/this program, in permissions.
* mule/canna-leim.el:
Remove my copyright, I've assigned it to the FSF.
2010-06-14 Stephen J. Turnbull <stephen@xemacs.org>
* gtk.el:
* gtk-widget-accessors.el:
* gtk-package.el:
* gtk-marshal.el:
* gtk-compose.el:
* gnome.el:
Add copyright notice based on internal evidence.
2010-06-14 Stephen J. Turnbull <stephen@xemacs.org>
* easymenu.el: Add reference to COPYING to permission notice.
* gutter.el:
* gutter-items.el:
* menubar-items.el:
Fix typo "Xmacs" in permissions notice.
2010-06-14 Stephen J. Turnbull <stephen@xemacs.org>
* auto-save.el:
* font.el:
* fontconfig.el:
* mule/kinsoku.el:
Add "part of XEmacs" text to permission notice.
2010-10-14 Aidan Kehoe <kehoea@parhasard.net>
* byte-optimize.el (side-effect-free-fns):
* cl-macs.el (remf, getf):
* cl-extra.el (tailp, cl-set-getf, cl-do-remf):
* cl.el (ldiff, endp):
Tighten up Common Lisp compatibility for #'ldiff, #'endp, #'tailp;
add circularity checking for the first two.
#'cl-set-getf and #'cl-do-remf were Lisp implementations of
#'plist-put and #'plist-remprop; change the names to aliases,
changes the macros that use them to using #'plist-put and
#'plist-remprop directly.
2010-10-12 Aidan Kehoe <kehoea@parhasard.net>
* abbrev.el (fundamental-mode-abbrev-table, global-abbrev-table):
Create both these abbrev tables using the usual
#'define-abbrev-table calls, rather than attempting to
special-case them.
* cl-extra.el: Force cl-macs to be loaded here, if cl-extra.el is
being loaded interpreted. Previously other, later files would
redundantly call (load "cl-macs") when interpreted, it's more
reasonable to do it here, once.
* cmdloop.el (read-quoted-char-radix): Use defcustom here, we
don't have any dump-order dependencies that would prevent that.
* custom.el (eval-when-compile): Don't load cl-macs when
interpreted or when byte-compiling, rely on cl-extra.el in the
former case and the appropriate entry in bytecomp-load-hook in the
latter. Get rid of custom-declare-variable-list, we have no
dump-time dependencies that would require it.
* faces.el (eval-when-compile): Don't load cl-macs when
interpreted or when byte-compiling.
* packages.el: Remove some inaccurate comments.
* post-gc.el (cleanup-simple-finalizers): Use #'delete-if-not
here, now the order of preloaded-file-list has been changed to
make it available.
* subr.el (custom-declare-variable-list): Remove. No need for it.
Also remove a stub define-abbrev-table from this file, given the
current order of preloaded-file-list there's no need for it.
2010-10-10 Aidan Kehoe <kehoea@parhasard.net>
* bytecomp.el (byte-compile-constp) Forms quoted with FUNCTION are
also constant.
(byte-compile-initial-macro-environment): In #'the, if FORM is
constant and does not match TYPE, warn at byte-compile time.
2010-10-10 Aidan Kehoe <kehoea@parhasard.net>
* backquote.el (bq-vector-contents, bq-list*): Remove; the former
is equivalent to (append VECTOR nil), the latter to (list* ...).
(bq-process-2): Use (append VECTOR nil) instead of using
#'bq-vector-contents to convert to a list.
(bq-process-1): Now we use list* instead of bq-list
* subr.el (list*): Moved from cl.el, since it is now required to
be available the first time a backquoted form is encountered.
* cl.el (list*): Move to subr.el.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* test-harness.el (Check-Message):
Add an omitted comma here, thank you the buildbot.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* hash-table.el (hash-table-key-list, hash-table-value-list)
(hash-table-key-value-alist, hash-table-key-value-plist):
Remove some useless #'nreverse calls in these files; our hash
tables have no order, it's not helpful to pretend they do.
* behavior.el (read-behavior):
Do the same in this file, in some code evidently copied from
hash-table.el.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* info.el (Info-insert-dir):
* format.el (format-deannotate-region):
* files.el (cd, save-buffers-kill-emacs):
Use #'some, #'every and related functions for applying boolean
operations to lists, instead of rolling our own ones that cons and
don't short-circuit.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* bytecomp.el (byte-compile-initial-macro-environment):
* cl-macs.el (the):
Rephrase the docstring, make its implementation when compiling
files a little nicer.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* descr-text.el (unidata-initialize-unicodedata-database)
(unidata-initialize-unihan-database, describe-char-unicode-data)
(describe-char-unicode-data):
Wrap calls to the database functions with (with-fboundp ...),
avoiding byte compile warnings on builds without support for the
database functions.
(describe-char): (reduce #'max ...), not (apply #'max ...), no
need to cons needlessly.
(describe-char): Remove a redundant lambda wrapping
#'extent-properties.
(describe-char-unicode-data): Call #'nsubst when replacing "" with
nil in the result of #'split-string, instead of consing inside
mapcar.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* x-faces.el (x-available-font-sizes):
* specifier.el (let-specifier):
* package-ui.el (pui-add-required-packages):
* msw-faces.el (mswindows-available-font-sizes):
* modeline.el (modeline-minor-mode-menu):
* minibuf.el (minibuf-directory-files):
Replace the O2N (delq nil (mapcar (lambda (W) (and X Y)) Z)) with
the ON (mapcan (lambda (W) (and X (list Y))) Z) in these files.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (= < > <= >=):
When these functions are handed more than two arguments, and those
arguments have no side effects, transform to a series of two
argument calls, avoiding funcall in the byte-compiled code.
* mule/mule-cmds.el (finish-set-language-environment):
Take advantage of this change in a function called 256 times at
startup.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* bytecomp.el (byte-compile-function-form, byte-compile-quote)
(byte-compile-quote-form):
Warn at compile time, and error at runtime, if a (quote ...) or a
(function ...) form attempts to quote more than one object.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* byte-optimize.el (byte-optimize-apply): Transform (apply 'nconc
(mapcar ...)) to (mapcan ...); warn about use of the first idiom.
* update-elc.el (do-autoload-commands):
* packages.el (packages-find-package-library-path):
* frame.el (frame-list):
* extents.el (extent-descendants):
* etags.el (buffer-tag-table-files):
* dumped-lisp.el (preloaded-file-list):
* device.el (device-list):
* bytecomp-runtime.el (proclaim-inline, proclaim-notinline)
Use #'mapcan, not (apply #'nconc (mapcar ...) in all these files.
* bytecomp-runtime.el (eval-when-compile, eval-and-compile):
In passing, mention that these macros also evaluate the body when
interpreted.
tests/ChangeLog addition:
2011-02-07 Aidan Kehoe <kehoea@parhasard.net>
* automated/lisp-tests.el:
Test lexical scope for `block', `return-from'; add a
Known-Bug-Expect-Failure for a contorted example that fails when
byte-compiled.
author | Aidan Kehoe <kehoea@parhasard.net> |
---|---|
date | Mon, 07 Feb 2011 12:01:24 +0000 |
parents | 943eaba38521 |
children |
line wrap: on
line source
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: