Emacs/Elisp

Wprowadzenie do Emacsa Lispa

Emacs Lisp jest językiem rozszerzeń edytora tekstu Emacsa i jest potężnym narzędziem do dostosowywania i rozszerzania Emacsa. Oto kroki, aby rozpocząć pracę z Emacs Lisp:

• Otwórz Emacsa i utwórz nowy bufor, naciskając C-x b (to jest Control-x, a następnie b), a następnie wprowadź nazwę swojego bufora.
• Upewnij się, że bufor jest w trybie Lisp, wpisując M-x emacs-lisp-mode. Umożliwi to podświetlanie i wcięcia składni Emacs Lisp.
• Aby oszacować wyrażenie Emacs Lisp, umieść kursor za nawiasem zamykającym wyrażenia i naciśnij C-x C-e (to jest Control-x, a następnie Control-e). Spowoduje to ocenę wyrażenia i wyświetlenie wyniku w minibuforze.
• Możesz zdefiniować funkcję, wpisując (defun nazwa-funkcji (argumenty) treść) w buforze. Na przykład, aby zdefiniować funkcję dodającą dwie liczby, możesz wpisać:

(defun add (a b)
  (+ a b))

Po zdefiniowaniu funkcji możesz ją wywołać, wpisując (dodaj 1 2) i oceniając wyrażenie.

Emacs Lisp zapewnia wiele wbudowanych funkcji i zmiennych, których możesz użyć. Dokumentację tych funkcji można znaleźć, wpisując C-h f, aby uzyskać pomoc dotyczącą funkcji, lub C-h v, aby uzyskać pomoc dotyczącą zmiennej.

Otóż ​​to! Dzięki tym podstawowym krokom powinieneś być w stanie zacząć pisać i oceniać wyrażenia Emacs Lisp. Jest o wiele więcej do nauczenia się o Emacs Lisp, ale to powinno dać ci dobry punkt wyjścia..

a oto wprowadzenie do niektórych kluczowych funkcji Emacs Lisp:

Typy danych: Emacs Lisp obsługuje wiele typów danych, w tym liczby, ciągi znaków, symbole, listy i tablice. Obsługuje również wyrażenia regularne i obiekty buforowe reprezentujące tekst.

Funkcje: Funkcje są budulcem programów Emacs Lisp. Możesz zdefiniować własne funkcje za pomocą makra defun. Funkcje mogą przyjmować argumenty i zwracać wartości, tak jak w innych językach programowania.

Zmienne: Emacs Lisp ma dwa rodzaje zmiennych: globalne i lokalne. Dostęp do zmiennych globalnych można uzyskać i modyfikować z dowolnej części programu, podczas gdy zmienne lokalne są widoczne tylko w określonej funkcji lub bloku kodu.

Struktury kontrolne: Emacs Lisp zapewnia kilka struktur kontrolnych dla rozgałęzień i pętli, w tym if, cond, while i dolist.

Makra: Makra to potężna funkcja Emacs Lisp, która pozwala definiować nowe konstrukcje językowe. Makra służą do przekształcania kodu w czasie kompilacji, dzięki czemu można ich używać do implementowania nowych struktur kontrolnych lub innych funkcji językowych.

Emacs API: Emacs Lisp zapewnia rozbudowany interfejs API do interakcji z samym Emacsem. Obejmuje to funkcje manipulowania buforami, oknami i ramkami, a także funkcje wyszukiwania i zastępowania tekstu, wykonywania poleceń powłoki i nie tylko.

Programowanie interaktywne: Emacs Lisp obsługuje programowanie interaktywne poprzez wbudowany debugger, który umożliwia przeglądanie kodu i sprawdzanie zmiennych. Możesz także użyć funkcji eval-buffer, aby szybko przetestować zmiany w swoim kodzie.

Ogólnie rzecz biorąc, Emacs Lisp to potężny i elastyczny język, który umożliwia dostosowywanie i rozszerzanie Emacsa na wiele sposobów. Posiada bogaty zestaw funkcji i zapewnia głęboką integrację z samym Emacsem, co czyni go idealnym językiem do pisania rozszerzeń i dostosowań Emacsa.

Emacs Lisp (w skrócie elisp) jest to dialekt języka Lisp bardzo podobny do Common Lispa.

Lisp jest drugim, po Fortranie, najstarszym językiem programowania w użyciu. Chociaż społeczność Lispa jest aktywna, to obecnie jest bardzo mała.

Pisanie prostych programów Emacs Lisp

Jest na to kilka sposobów :

M-:

Wprowadź skrót :

M-:

za pomocą 3 klawiszy. Naciśnij i trzymaj :

• 'Alt'
• 'Shift'
• ':'

Otwiera to w minibuforze miejsce na wprowadzenie jednego wyrażenia :

Eval : 

Teraz możesz wprowadzić wyrażenie Lispa :

(+ 1 2)

i nacisnąć enter. Wynik otrzymasz w minibuforze :

3 (#o3, #x3)

*scratch*

Otwórz bufor *scratch*.

Wpisz komendę :

(+ 1 2 )

Umieść kursor wyrażeniem i wprowadź skrót :

C-j

Wynik będzie poniżej :

3

eval-expression

Wprowadź skrót Emacsa

M-x

Wpisz polecenie elispa

eval-expression

i naciśnij enter

W tym samym buforze wpisz wyrażenie lispa, które chcesz wykonać :

(+ 1 2)

i naciśnij enter . Otrzymasz wynik

3 

w tym samym buforze ( i w *messeges*)

C-x C-e

W dowolnym buforze wprowadź wyrażenie Lispa ( oznaczające dodanie 1 i 2 )

(+ 1 2)

Umieść kursor za zamykającym nawiasem i wprowadź polecenie Emacsa : eval-last-sexp za pomocą skrótu :

C-x C-e 

(naciśnij klawisz "Ctrl" i nie puszczaj, naciśnij drugi klawisz "x", następnie Ctrl i e).

Wynik zobaczysz w minibuforze  :

3

Gratulacje ! Wykonałeś pierwszy program w Lispie !

eval-region

Zaznacz cały tekst.

Wprowadź polecenie

M+x eval-region

Zobaczysz rezultat :

3

Notacja

Kod Elisp-a (tak jak innych Lisp-ów) składa się z S-Wyrażeń (które składają się z list elementów oddzielonych spacją ujętych w nawiasy) np:

(+ 1 2 3 (* 8 91 (/ 2 10)))

Lisp używa notacji prefiksowej tzn. powyższe wyrażenie obliczy 1 + 2 + 3 + (8 * 91 * (2 / 10)) W lisp-ie pierwszy element listy jest to funkcja lu makro które zostanie wywołane z pozostałymi elementami listy jako parametrami. Jeśli jakiś element tej listy jest także listą to to wyrażenie zostanie najpierw obliczone. Wyjątkiem są makra. Jeśli pierwszym elementem wyrażenia jest makro, wyrażenia nie są obliczane tylko przekazane do makra jako dane, które zostaną przez nie przetworzone. Obliczony zostanie wynikowy kod zwrócony przez makro.

Funkcje

Za pomocą elisp-a możemy łatwo rozszerzyć Emacs-a o nowe funkcje. Jeśli chcemy aby dana funkcja była dostępna w Emacs-sie należy otworzyć bufor w trybie emacs-lisp-mode, który możemy uruchomić za pomocą klawiszy `M-x emacs-lisp-mode'. Bufor *scrach*, początkowy bufor jest uruchomiony w tym trybie. Komenda `M-:' oblicza wyrażenie w buforze.

Jeśli chcemy aby dane funkcje były uruchamiane przy starcie Emacs-a należy umieścieć je w pliku .emacs.

Aby zdefiniować funkcje należy użyć wyrażenia defun.

(defun add-20 (x)
  (+ x 20))

(defun square (x)
  (* x x))

W powyższym przykładzie zdefiniowano dwie funkcje add-20 i square.

Skróty klawiszowe

Skróty klawiszowe Emacsa pozwalają wywołać funkcję za pomocą klawiszy , np.

`M-x' 

Dynamiczne=

W definicji funkcji należy jako pierwsze wyrażenie wywołać funkcję interactive.

(defun hello ()
  (interactive)
  (message "hello world!"))

Po obliczeniu powyższego wyrażenia możemy wywołać funkcję za pomocą `M-x hello'

=Globalne

Jeśli chcemy aby jakaś funkcja była wywoływana za pomocą jakiejś kombinacji klawiszy należy użyć poniższego wyrażenia.

(global-set-key (kdb "C-c C-h") 'hello)

Haki

Jeśli chcemy aby dany skrót klawiszowy był uruchamiany tylko w danym trybie emacs-a należy się posłużyć tzw. hakami (jest to kod który zostanie wywołany kiedy uruchamiany jest jakiś tryb emacs-a).

(add-hook 'text-mode-hook
    (lambda ()
        (define-key text-mode-map (kbd "<F5>") 'nazwa-funkcji)))

Debugowanie programów Emacs Lisp

Debugowanie programów Emacs Lisp jest ważną częścią procesu programowania. Oto kilka technik, których możesz użyć do debugowania programów Emacs Lisp:

Drukuj instrukcje: Jednym z najprostszych sposobów debugowania kodu Emacs Lisp jest użycie instrukcji drukowania do wyświetlania wartości zmiennych lub wyrażeń. Możesz użyć funkcji wiadomości, aby wydrukować wiadomości do bufora *Wiadomości*.

Debuger: Emacs Lisp ma wbudowany debuger, który może pomóc w identyfikacji i naprawie błędów w kodzie. Aby użyć debugera, możesz wywołać funkcję debugowania z wyrażeniem, które chcesz debugować. Spowoduje to otwarcie nowego bufora, który umożliwia przeglądanie kodu, sprawdzanie zmiennych i ocenianie wyrażeń.

Śledzenie: Śledzenie to kolejna przydatna technika debugowania kodu Emacs Lisp. Możesz użyć funkcji śledzenia, aby dodać ślad do określonej funkcji. Spowoduje to, że Emacs wyświetli komunikat za każdym razem, gdy funkcja zostanie wywołana, co może pomóc w zidentyfikowaniu miejsca wystąpienia błędu.

Punkty przerwania: Możesz ustawić punkty przerwania w kodzie Emacsa Lispa za pomocą funkcji debug-on-entry. Spowoduje to, że Emacs otworzy debugger za każdym razem, gdy zostanie wywołana określona funkcja.

Checkdoc: Checkdoc to wbudowane narzędzie Emacs Lisp, które sprawdza błędy składniowe i inne typowe błędy w kodzie Emacs Lisp. Może pomóc w wyłapywaniu błędów na wczesnym etapie procesu programowania.

Automatyczne testowanie: Wreszcie możesz użyć zautomatyzowanych platform testowych do testowania kodu Emacs Lisp. Wbudowany pakiet ert zapewnia platformę do testowania funkcji i makr Emacs Lisp.

Ogólnie rzecz biorąc, debugowanie programów Emacs Lisp wymaga kombinacji technik i narzędzi. Używając instrukcji print, debuggera, śledzenia, punktów przerwania, dokumentów kontrolnych i testów automatycznych, możesz szybko identyfikować i naprawiać błędy w swoim kodzie.