GNU/Emacs –

GNU/Emacs –

powerful developing tool

Disclaimer: cio' che vedrete in questo Geek Evening e' il  frutto dei tentativi notturni di scrivere del codice leggibile 

da parte di un NON programmatore...

Don't try this at /home ! 

(...if you're not sure about it)

GNU/Emacs –

powerful developing tool

Premesse: in questo Geek Evening verra' utilizzata la terminologia  standard di Emacs, quindi faremo riferimento ai frame intendendo quelle 

che nel linguaggio comune vengono chiamate finestre e viceversa.

Nel corso del G.E. verra' effettuata soltanto una panoramica dei tool per  lo sviluppo piu' famosi per GNU Emacs, non verranno affrontati nel 

dettaglio in quanto ognuno di essi richiederebbe un geek evening  apposito. Faremo uso di GNU Emacs 22.3.1, quindi quanto indicato in  queste slides potrebbe differire leggermente in caso di versioni differenti. 

Lo scopo come detto e' quello di presentare i tool piu' interessanti quindi  per approfondimenti vi consiglio di visitare i loro siti ufficiali, o le loro 

pagine su emacswiki per maggiori informazioni.

Iswitchb

Iswitchb  e'  un'alternativa  alla  piu'  famosa  funzione  switch­to­buffer  (chiamata  di  default da C­x b per cambiare buffer). 

Con iswitchb possiamo digitare il nome del buffer usufruendo del completamento.  

Man mano che digitiamo il nome del buffer che ci interessa, si restringe il campo  delle possibili alternative. 

Con iswichb non e' necessario scrivere il nome del buffer dall'inizio. Esempio: se  volessimo switchare al buffer *Message*, potremmo semplicemente digitare age e  vedremmo *Message* fra le alternative proposte nel minibuffer.

Per cominciare ad utilizzare la funzione iswitch­buffer, possiamo inserire nel nostro  .emacs la seguente stringa:

(iswitchb­mode 1)

Ido-mode

Spesso  chi  vuole  le  features  proposte  da  iswitchb  desidera  anche  utilizzarle  per  l'apertura  di  nuovi  files...  Quello  di  cui  abbiamo  bisogno  e'  quindi  Ido­Mode,  non  piu' Iswitchb. Ecco come farlo caricare in automatico da Emacs:

(require 'ido­mode) (ido­mode t)

Adesso proviamo ad aprire un file (C­x f). Notato nulla? Adesso per scegliere il  file desiderato non abbiamo solo a disposizione il semplice tab­completamento, ma  addirittura possiamo usare C­s e C­r per ciclare fra le alternative. Lo stesso vale 

per il switching fra i buffer (C­x b).  Se vogliamo disabilitare 

temporaneamente  ido  basta  un  C­f  o  un  C­b.  Inizialmente  potreste  trovarvi male, soprattutto se provate ad avviare dired in questo modo... 

Bhe, basta un C­d per aprire la cartella corrente in dired.

Per chi poi vuole di piu' rimando a Icycle.

Numeri di riga e colonna

Per  far  si  che  Emacs  visualizzi  automaticamente  il  numero  di  riga  e  di  colonna,  basta  aggiungere  nel  file  di  configurazione  (~/.emacs)    le  seguenti righe:

(setq line­number­mode t) (setq column­number­mode t)

In realta' la prima riga non e' necessaria in quanto abilitata di 

default. I numeri di riga e di colonna vengono rappresentati nella  mode­line.

Numeri di riga e colonna

Line­number ha una limitazione, cioe' mostra il numero di linea soltanto  se la dimensione del buffer in byte non supera il valore contenuto nella  variabile line­number­display­limit. 

In realta' non credo sia un grosso problema... 

Numeri di riga e colonna

Tuttavia  ognuno  di  noi  credo  che  trovi  piu'  comodo  avere  ogni  riga  numerata  a  lato...  Per  questo  nel  mio  emacs  carico  all'avvio  linum,    una  piccola  estensione  scaricabile da EmacsWiki...

Ecco poi come farla caricare ad Emacs:

(load­file "/path/to/linum.el")

Non  voglio  che  in  ogni  major­mode  venga  visualizzato  il  numero  di  riga,  mi  puo'  interessare ad esempio quando edito listati ruby e quindi:

(add­hook 'find­file­hook 'linum­mode)

Se pero' volessi vedere in ogni file che apro, qualunque sia il major mode,  il numero di riga, allora aggiungerei questo secondo hook:

(add­hook 'ruby­mode­hook 'linum­mode)

Numeri di riga e colonna

Per saltare ad una particolare riga:

 M­x goto­line. 

Questo comando e' bindato alla combinazione M­g (come si puo' vedere  con un C­h b) ed e' gia' presente in GNU Emacs.

Syntax Highlighting

font­lock­mode  e'  il  modo  standard  utilizzato  da  Emacs  per  il  syntax  highlighting  nel  codice.  Anche  in  questo  caso  ricorriamo  agli  hook  per  fare in modo che venga abilitato solo in particolari major mode:

 (add­hook 'c­mode­hook 'turn­on­font­lock) 

Invece  per  abilitare  il  syntax  highlighting  per  ogni  buffer,  indipendentemente dal major mode:

 (setq global­font­mode­lock t)

Syntax Highlighting

Il  livello  di  decorazione  che  font­lock  utilizzera'  e'  specificato  nella  variabile font­lock­maximum­decoration

Come al solito vi incoraggio a dare un C­h v font­lock­maximum­

decoration <Invio> per leggere la documentazione relativa a quella  variabile.

Syntax Highlighting

Da  font­lock  potremmo  pero'  desiderare  di  piu',  ad  esempio  potremmo  voler evidenziare anche altre parole chiave che invece vengono ignorate. 

Come fare?

(font­lock­add­keywords 'emacs­lisp­mode   '(("foo" . font­lock­keyword­face)))  

Syntax check...

Abbiamo  parlato  di  evidenziare  la  sintassi,  ma  perche'  non  utilizzare  anche un tool che la controlli per segnalarci eventuali errori?

Questo tool e' flymake! Si tratta di un minor­mode che lancia al volo dei  controlli  sulla  sintassi  utilizzando  gli  strumenti  propri  di ogni  linguaggio. 

Ad esempio per il syntax­check dei file c/cpp viene utilizzato gcc, per perl  viene richiamato l'interprete perl ecc...

Flymake evidenzia i warning (in blu) e gli errori (in rosso).

Syntax check...

L'idea  che  sta  dietro  flymake  e'  quella  di  creare  un  syntax­checker  universale,  quindi  chiunque  puo'  contribuire  seguendo  i  consigli  dello  sviluppatore a far si che dei determinati linguaggi/tool siano supportati.

Ecco dunque con quali linguaggi e' attualmente possibile usare flymake:

C, C++, PHP, Ruby, Fortran, JavaScript, ActionScript 3, Haskell, Erlang,  Lua, Bash, Java, Perl.

Syntax check...

Come attivare lo spell check per il ruby­mode ?

Innanzitutto ci servono alcune righe di codice... Le troviamo su:

http://www.emacswiki.org/cgi­bin/wiki/FlymakeRuby

Magari  anziche'  inserirle  nel  .emacs  mettiamole  in  un  apposito  file  flymake­ruby.el  e  richiamiamo  questo  dal  .emacs.  In  questo  modo  evitiamo di sporcarlo...

Leggendo quel codice e' facile intuire che ogni volta che 

apriremo un file .rb verra' automaticamente performato lo spell  check, quindi non saranno necessarie altre righe...

Paren Match Highlighting

Quando  si  parla  di  “paren”  si  intendono  tutti  i  delimitatori  classici,  parentesi  tonde, quadre, graffe, virgolette, apici, parentesi angolari...

M­x  check­paren  lo  utilizziamo  per  controllare  se  nel  codice  scritto  fino  a  questo  momento  ci  sono  parentesi  non  accoppiate.  Con  il  paren­matching  abilitato, ogni qualvolta chiudiamo una parentesi, il cursore si sposta per pochi  istanti al punto in cui l'avevamo aperta. Se il punto di apertura non e' nella parte  di  buffer  attualmente  visualizzata  sullo  schermo,  Emacs  mostra  un  pezzo  di  quella riga nel minibuffer. Se proviamo a chiudere con una graffa una parentesi 

quadra, riceveremo un messaggio d'errore nel minibuffer.

Tre variabili sono interessate dal paren­matching: (C­h v <variabile> 

per la doc): blink­matching­paren, blink­matching­delay,  blink­ matching­paren­distance.

Commentare il codice!!!

Commentare  il  codice  e'  molto  importante,  ecco  perche'  in  Emacs  non  possono mancare funzioni apposite:

comment­box comment­dwim comment­indent

comment­indent­new­line comment­kill     comment­line

comment­or­uncomment­region     comment­region

comment­set­column

Commentare il codice!!!

Ovviamente il codice viene commentato seguendo la sintassi corretta del  linguaggio di programmazione che stiamo utilizzando. Come fa Emacs a  sapere in che linguaggio stiamo scrivendo? Il major­mode che utilizziamo  dice tutto... 

Major Modes

Ogni "major mode" condiziona il comportamento di alcuni comandi oltre a fornire  anche  comandi appositi.   Ogni  "major mode" è anche  il nome di  un comando  esteso con nome che serve per attivare quel major mode.  Per esempio M­x c­

mode è il comando per attivare il modo "C" che utilizziamo per scrivere codice  in C, ruby­mode e' quello che utilizziamo per scrivere codice ruby, text­mode per  il testo semplice e cosi' via... 

Emacs stabilisce quasi sempre quale major mode avviare leggendo l'estensione  del file. E quando cio' non funziona cosa facciamo?

Nel  mio  caso  e'  stato  necessario  istruire  l'Editor  (ricordate  sempre  la  e  maiuscola quando parlate di Emacs)  per aprire i files ruby:

(load "~/.emacs.d/ruby­mode.el")

(add­to­list 'auto­mode­alist '("\\.rb" . ruby­mode))

Minor Modes

I minor mode sono invece delle caratteristiche che si possono attivare o disattivare  a seconda delle nostre esigenze. Ad esempio un minor mode e' l'Auto­fill che serve  ad allineare automaticamente il testo. Questo minor mode puo' risultare molto utile  nella modalita' text­mode ma puo' non esserlo ad esempio nella ruby­mode.

Di  minor  mode  ne  possiamo  avere  attivi  contemporaneamente  quanti  ne  desideriamo.  Alcuni  minor  modes  possono  essere  globali,  altri  attivabili  solo  in  determinati  buffers.  Per  sapere  se  un  minor  mode  e'  globale  basta  leggere  la  documentazione della funzione che ne effettua il toggling; 

Es.: per il minor mode relativo alle scroll­bar basta un C­h f scroll­bar­mode.

Commentare e documentare

Ritorniamo ai commenti... Esistono alcune applicazioni che, partendo da  alcuni commenti presenti nel codice, redigono la documentazione relativa  ai nostri sorgenti. 

Parliamo ad esempio di doxygen o gtk­doc (ma ne esistono altri ancora).

Questi  tool  non  prendono  tutti  i  nostri  commenti,  ma  solo  quelli  che  seguono  determinate  regole  di  formattazione  (che  in  linea  di  massima  sono molto simili fra i vari sistemi). 

Per  utilizzare  doxymacs  (il  supporto  a  doxygen  in  Emacs),  abbiamo  bisogno di: W3, tempo, e libxml2 (versione >= 2.6.13).

Commentare e documentare

Insegnare  ad  utilizzare  doxygen  non  rientra  negli  scopi  di  questo  geek  evening  (magari  di  un  prossimo  ...),  ma  vediamo  velocemente  come  utilizzare doxymacs (supporremo di voler utilizzare doxymacs in c­mode).

Nel nostro .emacs inseriamo:

(load­file “~/.emacs.d/doxymacs.el”) (add­hook 'c­mode­hook 'doxymacs­mode)

A questo punto aprendo un file .c avremo il minor­mode doxymacs attivo.

Con M­x doxy<tab><tab> possiamo vedere quali funzioni ci fornisce  (con C­h b le sue scorciatoie, con C­h m la sua 

documentazione). In generale le funzioni piu' utili sono  doxymacs­insert­*

Kill ring

Il kill ring e' cio' che contiene tutto il testo che abbiamo tagliato, e' unico e  condiviso fra tutti i buffers (con conseguenti evidenti vantaggi).

C­y (yank) serve ad incollare l'ultimo frammento di testo tagliato, mentre  per copiare del testo nel kill ring usiamo M­w o C­w (il primo copia, l'altro  taglia). Con M­y possiamo invece muovere il puntatore nel kill­ring. M­y e' disponibile solo se e' stato precedentemente lanciato uno yank o uno  yank­pop. 

Per vedere il contenuto del kill­ring basta vedere il contenuto  dell'omonima variabile, ovviamente con C­h v.

Selezioni rettangolari

GNU  Emacs,  come  anche  vi  (o  forse  dovremmo  dire  vi  come  Emacs),  riesce  a  gestire  le  selezioni  rettangolari.  Dopo  aver  selezionato  normalmente  una  porzione  di  testo,  il  rettangolo  e'  individuato  dall'area  compresa  fra  l'estremo  iniziale  e  quello  finale...  beh  le  descrizioni  geometriche non sono il mio forte... (comunque non mi sono mai servite  a niente, ma e' bene sapere che esistono...) :P

Scorciatoia Effetto

C-x r k “Killa” il rettangolo

C-x r y “Yanka” il rettangolo :P

Indentare il codice!!!

Altrettanto  importante,  oltre  a  commentare  il  codice  che  scriviamo,  e'  indentarlo!  Aiuta  la  leggibilita'  ed  in  alcuni  casi,  vedi  python,  e'  fondamentale  se  vogliamo  che  il  programma  che  andiamo  a  scrivere  funzioni...

Per  far  si  che  Emacs  sistemi  l'indentazione  del  codice  che  abbiamo  scritto basta selezionarlo ed eseguire M­x indent­region

Tuttavia e' bene indentare il codice mentre lo scriviamo, quindi  a volte anziche' Invio e' consigliabile un C­j, che e' bindato a  newline­and­indent.

Code Folding

HideShow (o hs) e' un minor mode di Emacs che permette di nascondere  temporaneamente  blocchi  di  testo.  Hideshow  opera  su  blocchi  di  testo,  espressioni ben bilanciate e commenti multi linea.

L'utilizzo  e'  molto  semplice.  Innanzitutto  richiamiamo  hs­minor­mode  nel  buffer in cui lo vogliamo utilizzare (o impostiamo un hook). Nel primo caso: 

M­x hs­minor­mode

A questo punto possiamo vedere la descrizione del minor­mode (C­h m).

Da qui notiamo che le principali funzioni sono: hs­hide­all,  hs­show­all, hs­hide­block, hs­show­block.

Per vedere le scorciatoie associate a questo minor mode: C­h b

Code Folding - folding.el

folding.el e' un'alternativa a hs… (lo troviamo su emacswiki.org) (load­file “~/.emacs.d/folding.el”)

Adesso configuriamolo per adoperarlo in buffer elisp:

(add­hook 'emacs­lisp­mode­hook 'folding­mod)

Le  scorciatoie  di  folding.el  sono  pressoche'  impossibili  da  ricordare,  quindi ne ho settate, nel mio .emacs, alcune personalizzate:

(add­hook 'folding­mode­hook '(lambda ()

         (define­key folding­mode­map "\C­co"

       'folding­hide­current­entry)          (define­key folding­mode­map "\C­ca"

       'folding­show­current­entry)))

Code Folding

Fa uso di particolari commenti per individuare i blocchi su cui effettuare il  folding/unfolding  (i  simboli  in  questione  sono  {{{  e  }}}  racchiusi  fra  dei  commenti).

Esempio:

 ;;{{{ 

(message “Hello World”)  ;;}}}

A  questo  punto,  utilizzando  delle  scorciatoie  (assolutamente  impossibili  da  ricordare  a  meno  che  non  le  personalizziamo)  o  richiamando  le  funzioni folding­show­current­entry e folding­hide­

current­entry dal minibuffer, e' possibile  mostrare/nascondere il blocco in questione. 

Code Folding

Esistono anche funzioni che permettono di nascondere/mostrare TUTTI I  blocchi che presentano quei particolari commenti, ma per la descrizione  completa del minor mode c'e' sempre C­h m

L'installazione di folding.el e' semplice e intuitiva:

(load­file "~/.emacs.d/folding.el")

(add­hook 'emacs­lisp­mode­hook 'folding­mode)

Io ho settato queste scorciatoie nel mio .emacs:

(add­hook 'folding­mode­hook '(lambda ()

       (define­key folding­mode­map "\C­co"

       'folding­hide­current­entry)        (define­key folding­mode­map "\C­ca"

       'folding­show­current­entry)))

Snippet please!!!

Definiamo  snippet  dei  piccoli  pezzi  di  codice  riusabile.  Inserire  degli  snippet  in  un  nostro  buffer  ci  semplifica  la  vita  aiutandoci  a  scrivere  codice  piu'  rapidamente  ripetendo  quelli  che  sono  ormai  algoritmi  consolidati.

Una  delle  estensioni  piu'  popolari  per  la  gestione  degli  snippet  e'  YASnippet (al solito YA sta per Yet Another... che fantasia...)

L'installazione  di  yasnippet  puo'  essere  effettuata  o  con  un  singolo  file  yasnippet­bundle.el  o  proseguendo  con  la  via  classica del tar.bz2 . Sul  sito ufficiale consiglia di utilizzare il bundle se si devono utilizzare 

template gia' esistenti, l'archivio se si necessita di creare altri  template. In realta' io ho creato in tutta tranquillita' altri 

template pur utilizzando il bundle, quindi ci semplificheremo la 

Tabba tabba!!!

Ancora  una  volta  vediamo  cosa  fare  per  avere  questa  feature  in  ruby­

mode:

(require 'yasnippet­bundle)

(add­hook 'ruby­mode­hook 'yas/minor­mode­on)

La prima riga e' necessaria per richiamare il file (ovviamente se  non si  trova  ne  load­path  non  possiamo  utilizzare  require,  ma  dobbiamo  affidarci a load). La seconda riga aggiunge un hook... Ormai sappiamo a 

che serve... Ora bisogna testarla... TAB TAB TAB!!!

To snippet: I snippet, you snippet...

Scrivere codice in Pascal non e' la mia passione, ma purtroppo mi trovo a  doverlo fare, quindi ecco come ho definito un template da utilizzare con  yasnippet per questo obsoleto linguaggio: 

(il template completo e' su www.salug.it/~fabioviola/yapascal.el)

(yas/define­snippets 'pascal­mode  '(

  ("prog" "PROGRAM ${nome};

BEGIN

${istr}

END." "prog" nil)

  ("wln" "WRITELN(${arg});" "writeln" nil)   ("rln" "READLN();" "readln" nil)

… CUT … 

  ("if" "IF ${cond}

THEN

${istruzione};" "if" nil)   ("case" "CASE ${espr} OF

${valore} : ${istruzione}${istruzioni};

END;" "func" nil) )

snippet.el

E'  un'alternativa  un  po'  macchinosa  a  yasnippet.  Configurare  snippet.el  consiste  nel  creare  i  propri  snippet  nel  file  di  configurazione  seguendo  queste semplici regole:

$${default} : crea un campo con un valore di default che l'utente puo'  cambiare  o  lasciare  cosi'.  Per  ciclare  fra  i  campi  dichiarati  con  questa  direttiva e' possibile tabbare

$> : richiama, nel punto in cui e' inserito, indent­according­to­mode

$. : specifica la fine dello snippet

snippet.el

Esempio:

    (define­abbrev­table 'javascript­mode­abbrev­table ())     (snippet­with­abbrev­table

     'javascript­mode­abbrev­table

     ("forin" . "$>for (var $${i} in $${var}){\n$>$$;\n}$.$>")      ("if"  .  "$>if ($${cond}){$>\n$>$.;\n}$>")

     ("ifel" . "$>if ($${cond}){$>\n$>$$;\n} else {$>\n$>$$;\n}$.$>")      ("var" . "var $${variable} = $${value};")

     ("fun" . "$>function $${name}($${args}){\n$>$.\n}$>")      ("lambda" . "$>function ($${args}){\n$>$.\n}$>")

     ("df" . "document.forms['$${formname}']")

     ("cl" . "console.log('$${message}');")) ;Firebug logging 

Per il sorgente completo vedere 

http://www.emacswiki.org/emacs/SnippetMode

snippet.el

Una volta definito lo snippet sara' necessario aggiungere un hook:

    (add­hook 'javascript­mode­hook       (lambda ()

      (abbrev­mode 1)

      (setq local­abbrev­table javascript­mode­abbrev­table)))

Completamento - AutoComplete

Si  tratta  di  un  plugin  leggero  e  facile  da  configurare/estendere  per  il  completamento di cio' che scriviamo. 

Per l'utilizzo normale e' sufficiente:

(load­file "~/.emacs.d/auto­complete.el") (global­auto­complete­mode t)

Tuttavia  questo  potrebbe  non  essere  sufficiente  con  major  mode  particolari, ad esempio mancano alcune parole chiave che utilzziamo con  ruby... Ecco la soluzione ­>

Completamento - AutoComplete

    (defconst ruby­keywords        (sort 

       (list

"ADDITIONAL_LOAD_PATHS""ARGF" "ARGV" "ActionController" "ActionView" "ActiveRecord" 

"ArgumentError" "Array" "BasicSocket" "Benchmark" "Bignum" "Binding" "CGI" "CGIMethods" 

"CROSS_COMPILING" "Class" "ClassInheritableAttributes" "Comparable" "ConditionVariable" 

"Config" "Continuation" "DRb" "DRbIdConv" "DRbObject" "DRbUndumped" "Data" "Date" 

"DateTime" "Delegater" "Delegator" "Digest" "Dir" "ENV" "EOFError" "ERB" "Enumerable" 

"Errno" "Exception" "FALSE"  "UNIXserver" "UNIXsocket" "UnboundMethod" "Url" "VERSION" 

"Verbose" "YAML" "ZeroDivisionError" "alias" "and" "BEGIN" "begin" "break" "case" "class" 

"def"

­­­ CUT ­­­ 

"defined""do""else""elsif""END""end""ensure""false""for""if""in""module""next""nil""not""or

""redo""rescue""retry""return""self""super""then""true""undef""unless""until""when""while""

yield"

) #'(lambda (a b) (> (length a) (length b)))))     (defvar ac­source­ruby

      '((candidates          . (lambda ()

       (all­completions ac­target ruby­keywords))))       "Source for ruby keywords.")

    (add­hook 'ruby­mode­hook       (lambda ()

Completamento - Semantic

Semantic e' uno degli strumenti forniti da Cedet. Una delle sue particolarita'  che lo rende molto utile e' la possibilita', ad esempio, di completare la lista  parametri di una funzione che stiamo chiamando, o di mostrarci quali sono i  parametri che la funzione aspetta.

In particolare, le funzioni piu' utili sono:

semantic­analyze­possible­completions  e  semantic­ia­

complete­symbols, ma per una spiegazione piu' esaustiva rimando a:

http://www.emacswiki.org/emacs/SemanticBovinator

Compilare il codice: Mode compile

Mode compile e' un pacchetto (fornito di default da Emacs) che permette  di compilare files a seconda del major mode. I comandi di compilazione  sono presenti per moltissime modalita', fra cui C­mode, Cplusplus­mode,  Makefile­mode,  Dired­mode,  Ada­Mode,  Sh­mode,  Python­Mode,  Tcl­

mode e bla bla bla...

Inseriamo questo codice nel nostro .emacs:

(autoload 'mode­compile "mode­compile"

      "Command to compile current buffer file based on the major     mode" t)

(global­set­key "\C­cc" 'mode­compile)

(autoload 'mode­compile­kill "mode­compile"

      "Command to kill a compilation launched by `mode­compile'" t) (global­set­key "\C­ck" 'mode­compile­kill)

Compilare il codice: Mode compile

A  questo  punto  apriamo  un  sorgente,  ad  esempio  C,  e  proviamo  a  compilare lanciando C­c c, scorciatoia che abbiamo creato poco fa.

L'output della compilazione ci viene mostrato nella stessa finestra (frame  in  linguaggio  emacsiano),  in  un  altro  frame  (finestra  nel  linguaggio  emacsiano) :­P

Per  modificare  le  impostazioni  relative  alla  compilazione  con  mode  compile ed il linguaggio in questione (in questo caso C) possiamo 

lanciare M­x customize­group compile­c <Invio>

Debuggare - gdb

Gdb, il GNU  Debugger e' uno  degli  strumenti  piu' utili per debuggare il  codice. Possiamo lanciarlo all'interno di Emacs con M­x gdb.

L'uso di gdb in Emacs non e' niente di diverso di quello che faremmo in  un terminale... A meno che... Settiamo la variabile gdb­many­windows a true (consiglio di farlo nel .emacs in modo da non doverlo ripetere ogni  volta) e... MAGIA!

L'attuale  frame  di  Emacs  viene  suddiviso  in  piu'  finestre  e  addirittura  anche la speedbar puo' essere utilizzata con gdb.

Debuggare - gdb

Debuggare elisp

Il buffer *Backtrace* e' quello che Emacs utilizza per mostrarci gli errori  nell'esecuzione di codice Elisp. 

Per uscire da questo buffer e' sufficiente la pressione di q.

Il  buffer  di  backtrace  si  apre  ad  esempio  quando,  all'avvio  di  Emacs,  vengono rilevati errori nell'init file. 

Alcune importanti variabili possono essere settate per migliorare l'utilizzo  del debugger in elisp e sono: 

debug­on­quit, debug­on­error e stack­trace­

on­error (ma  data la scarsita' di programmatori elisp 

Bookmarks

I segnalibri (o bookmarks) non servono soltanto a chi scrive codice, ma  possono  tranquillamente  essere  utilizzati  da  chiunque,  anche  per  semplici file di testo.

L'utilizzo dei bookmark e' abbastanza intuitivo e tutto cio' che ci serve e'  ricordare alcune scorciatoie (come sempre):

Combinazione Descrizione

C-x r l Lista tutti I segnalibri

C-x r m Crea un nuovo segnalibro C-x r b Salta ad un segnalibro

Bookmarks

Quando visitiamo la lista dei bookmarks possiamo effettuare le seguenti  operazioni:

* Aggiungere  annotazioni (premendo e)

* Vedere annotazioni per un determinato segnalibro (premendo a)

* Vedere tutte le annotazioni di tutti i bookmarks (premendo A)

* Rinominare un segnalibro (r) 

* Marcare vari segnalibri per l'eliminazione (k)

* Mostrare il bookmark selezionato in un'altra finestra (o)

Per scorrere fra i bookmarks in maniera piu' comoda  possiamo  adoperare: doremi­bookmarks, icycles 

Sistemi di revisione

Emacs e' fornito di una generica interfaccia verso I sistemi di revisione,   chiamata  VC.  Supporta  ConcurrentVersionsSystem  (CVS),  RevisionControlSystem  (RCS),  SCCS,  Arch,  Git,  Mercurial,  Bzr,  Monotone, MetaCVS? e SubVersion (SVN). 

Combinazione Descrizione

C-x v i Aggiunge un nuovo file al branch C-x v ~ Mostra le altre revisioni

C-x v = Fa il diff con altre revisioni C-x v u Annulla il checkout

C-x v c Cancella l'ultima revisione

C-x v d Mostra I file che non sono aggiornati C-x v a Aggiorna il changelog

C-x v s Tagga tutti i file con un nome simbolico

C-x v r Annnulla i checkout fino a ritornare ad uno snapshot C-x v l Mostra il log

Sistemi di revisione

In generale, oltre a vc, altre estensioni permettono la gestione di branch  sotto sistema di revisione. I sistemi di revisione supportati sono

DISTRIBUTED

Git (attraverso vc­git.el – git.el – magit ­ egg – egit – gitsum – git­emacs) Bazaar aka bzr (vc­bzr.el ­ bazaar.el)

Mercurial aka hg (con mercurial.el – ahg.el) DaRcs (VcDarcs – darcs.el – darcsum.el –) MonoTone (monotone.el)

ClearCase (DVC ?)

CENTRALIZED

Subversion aka svn (con SVK – svnmisc) CVS (con PclCVS – CVSAdminMode) RCS

Sistemi di revisione - bazaar.el

Vediamo ora nella pratica una delle estensioni elencate prima: bazaar.el. 

Con vc avevamo gia' abbastanza per gestire un sistema di revisione, ma  con bazaar.el possiamo accedere a funzioni particolari e tipiche di questo  sistema di revisione.

Come  sempre  andiamo  nel  .emacs  (dopo  aver  scaricato  l'estensione  bazaar.el da EmacsWiki) e scriviamo:

(load­file “/path/to/bazaar.el”)

C­M­x per eseguire subito l'istruzione senza dover riavviare  (inutilmente) GNU Emacs.

Sistemi di revisione - bazaar.el

Adesso  M­x  bazaar!  Cosa  succede?  Ci  viene  chiesto  il  nome  del  branch...Ok,  ma  per  farci  che?  Verra'  eseguito  un  bzr  status  in  quella  cartella.

Altre funzioni interessanti? M­x bazaar­<tab><tab>

bazaar.el e' solo un esempio... Io utilizzo bazaar, ma non questo minor  mode... Per la maggior parte delle funzioni di interesse mi e' sufficiente  vc, per i commit e quelle poche altre operazioni che vc non supporta mi  basta un M­x ansi­term :P

RegExp

Emacs fornisce un ottimo tool per la creazione di espressioni regolari e  per  il  loro  test  al  volo.  Si  tratta  del  re­builder.  Purtroppo  funziona  unicamente per listati lisp, ma vale davvero la pena di provarlo!

M­x re­builder <Enter>

Emacs Code Browser

Emacs Code Browser e' un'utilissima estensione (e' un minor mode) che  aggiunge  al  nostro  frame  delle  finestre  per  navigare  nel  nostro  codice  con mouse e tastiera. Queste speciali finestre sono chiamate interactors.

Installazione di ECB:

Emacs  Code  Browser  richiede  CEDET  (Collection  of  Emacs  Development Environment Tools). Scarichiamo e installiamo la versione  pre1.0.

(add­to­list 'load­path "/home/val/.emacs.d/cedet/common") (require 'cedet)

A questo punto e' ora di installare ecb

Emacs Code Browser

Dopo aver decompresso l'archivio di ecb settiamo il nostro .emacs:

(add­to­list 'load­path "/home/val/.emacs.d/ecb") (require 'ecb­autoloads)

Per una guida esasutiva all'utilizzo di ecb:

http://ecb.sourceforge.net

Per muovere i primi passi invece: apriamo un sorgente e diamo un:

M­x ecb­minor­mode <Invio>

(consiglio di disattivare il tip of the day... e' antipatico... :P ) (setq ecb­tip­of­the­day nil)

Piccola parentesi... CEDET-semantic

CEDET e' una suite di strumenti creati allo scopo di trasformare Emacs  in un potente ambiente di sviluppo. Le utility di CEDET richieste da ECB  sono:

* Semantic (vedere pagina apposita)

Piccola parentesi... CEDET-eieio

* EIEIO (Enanched Implementation of Emacs Interpreted Objects): “nu se  capisce nu furmine”... http://cedet.sourceforge.net/eieio.shtml

Scherzi  a  parte,  implementa  una  metodologia  di  sviluppo  orientata  agli  oggetti  controllata,  seguendo  lo  standard  CLOS.  EIEIO  fornisce  funzionalita' di browsing del codice e dei custom widgets.

Lo standard CLOS(Common Lisp Object System) permette di aggiungere  il supporto agli oggetti a dialetti del Lisp che ne sono 

sprovvisti, ad esempio Elisp.

Piccola parentesi... CEDET-speedbar

* Speedbar (in realta' fa gia' parte di Emacs): si tratta di un Everything­

Browser. Lanciando  la speedbar viene creato un nuovo frame che puo'  effettivamente essere utilizzato per browsare tutto, dal codice agli utenti  presenti su un canale di chat IRC.

Per  richiamare  la  speedbar  basta  un  M­x  speedbar,  mentre  per  attivarla permanentemente:

(speedbar t)

Sebbene l'apertura in un nuovo frame sia il comportamento di  default, e' ovviamente modificabile.

Aprire un terminale

Per avere un terminale all'interno di Emacs abbiamo varie possibilita':

* Eshell: si tratta di una shell scritta interamente in emacs lisp, disponibile  in  ogni  distribuzione  di  Emacs.  E'  veramente  utilissima,  soprattutto  su  sistemi  operativi  privi  di  un  reale  interprete  dei  comandi...  Fa  parte  di  Emacs dalla versione 21 dell'editor.

* AnsiTerm: emulatore di terminale scritto in emacs lisp.

* Term: molto simile ad AnsiTerm

* ShellMode: un'utility esterna che puo' usufruire anche  delle comodita' fornite da icicle.

DIFF

DiffMode  e'  un  major  mode  standard  di  Emacs  per  evidenziare  e  navigare il contenuto dei diff file. 

Per migliorare il comportamento di DiffMode possiamo utilizzare:

­ Diff2Ediff

­ DiffEnanchements

­ DiffSaveBuffer

(non e' un major mode che ho utilizzato molto, quindi vi rimando alla doc  ufficiale)

Editare file remoti...

TRAMP (Transparent Remote Access, Multiple Protocols) e' un pacchetto  per editare file remoti. 

Configurare velocemente:  (setq tramp­default­method "ssh") A questo punto possiamo aprire il file con:

C­x C­f /remotehost:filename <Enter> (or C­x C­f /method:

user@remotehost:filename) .

Per problemi di performance e' consigliabile utilizzare shfs.

Editare archivi...

Archive­mode  e'  un  major  mode  che  consente  di  effettuare  alcune  operazioni su archivi, tipicamente listarne il contenuto, estrarre un file e,  se  possibile,  memorizzarlo  o  cancellarlo  nell'archivio  stesso.  Archive­

mode  non  fa  uso  soltanto  di  funzioni  elisp,  ma  si  appoggia  ad  utility  esterne. I tipi di archivi che vengono gestiti attualmente sono:

tar  non  compressi,  tar  compressi  con  gzip,  bzip2  e  compress.  (vi  serve lo script tgz se volete anche poterli modificare), zip, lha e lzh, zoo,  cpio,    arc  (vi  serve  il  programma  arc),  arj  (in  sola  lettura  e  vi  serve  il  programma unarj), deb (in sola lettura e vi serve lo script debarc), rpm 

(in sola lettura e vi serve lo script rpmarc), sit (in sola  lettura; è roba Apple quindi non ce ne sbatte niente...)

Editare archivi...

L'installazione di achive­mode e' ancora una volta data da:

(load­file “~/.emacs.d/archive­mode.el”)

Il file archive­mode.el contiene del codice comune in grado di gestire qualsiasi tipo di  archivio utilizzando gli appositi handler e gli handler specifici per ogni archivio.

Ciascun handler definisce per ogni tipo di archivio Le varie estensioni dei files con cui  è  possibile  identificare  il  tipo  di  archivio,  un  comando  per  listare  il  contenuto  dell'archivio,  un  comando  per  estrarre  un  singolo  file  dall'archivio,  un  comando  per  memorizzare  un  singolo  file  nell'archivio,  un  comando  per  cancellare  un  singolo  file  dall'archivio, un'espressione regolare per poter cercare l'inizio dei nomi dei files nella 

lista, oppure una funzione lisp in grado di estrarre direttamente il  nome, una funzione opzionale per settare il major­mode in base  all'estensione del file, se non specificata viene usata la funzione  archive­mode  che  determina  automaticamente  l'handler 

Artist-mode

Puo' essere utile disegnare in ASCII art nei nostri sorgenti per far capire all'utente cio'  che intendiamo... Ad esempio nel plugin dell'aereoplano di Compiz, Carlo ha inserito  un disegno per far capire come la finestra si piega per dare vita ad un aereo...

Questi  disegni  possono  essere  fatti  con  Artist­Mode,  un  major­mode  che  trasforma  temporaneamente il nostro ambiente in un programma di grafica... ASCII... :P

http://www.cinsk.org/emacs/emacs­artist.html

Script-fu

Chi  lavora  con  la  grafica,  e  in  particolare  con  TheGimp,  puo'  sentire  l'esigenza  di  estendere l'applicazione con nuovi script.

Cio' si puo' fare con vari linguaggi: Perl, Python, Ruby, ma il linguaggio piu' utilizzato, e  quello che troviamo sicuramente in ogni installazione di TheGimp e' SIOD. 

SIOD?????????? E' un altro dialetto del Lisp, anzi, per la precisione di Scheme, che  e' un dialetto di Lisp. Script­fu e' in realta' solo un altro nome per chiamare SIOD.

Per  lavorare  con  gli  script­fu  e'  utile  Gimp­Mode.  Fornisce  autocompletamento  del  codice,  interazione  con  Gimp  come  client  o  subprocess,  echoing  della  documentazione e tanto altro...

E' una delle modalita' che approfondiro' di piu' in questa primavera 

In futuro...

Ecco  le  estensioni  (major  o  minor  modes)  che  indendo  provare  nel  medio/lungo  periodo:

(se qualcuno le ha gia' provate mi faccia sapere che sono curioso )

GimpMode:  http://www.emacswiki.org/emacs­en/GimpMode  (per  lo  sviluppo  degli  script­fu)

MozRepl: http://wiki.github.com/bard/mozrepl

Ctags: http://www.emacswiki.org/emacs/ExuberantCtags

GNU/Emacs –

powerful developing tool

Strumenti citati/utilizzati: 

Iswitchb: http://www.emacswiki.org/emacs/IswitchBuffers Ido: http://www.emacswiki.org/emacs/InteractivelyDoThings Icicle: http://www.emacswiki.org/emacs/Icicles

Linum: http://stud4.tuwien.ac.at/~e0225855/linum/linum.html Flymake: http://flymake.sourceforge.net/

Flymake­ruby: http://www.emacswiki.org/cgi­bin/wiki/FlymakeRuby Doxymacs: http://doxymacs.sourceforge.net/

Hideshow: http://www.emacswiki.org/emacs/HideShow

folding.el: http://www.emacswiki.org/cgi­bin/wiki/FoldingMode Yasnippet: http://code.google.com/p/yasnippet/

snippet.el: http://www.emacswiki.org/emacs/SnippetMode

Mode­compile: http://www.emacswiki.org/emacs/ModeCompile

GNU/Emacs –

powerful developing tool

Gdb: http://www.emacswiki.org/emacs/GrandUnifiedDebugger#toc1 Vc: http://www.emacswiki.org/emacs/VersionControl

Re­builder: http://www.emacswiki.org/cgi­bin/wiki/ReBuilder Ecb: http://ecb.sourceforge.net/

Cedet: http://cedet.sourceforge.net/

Semantic: http://cedet.sourceforge.net/semantic.shtml Eieio: http://cedet.sourceforge.net/eieio.shtml

Speedbar: http://cedet.sourceforge.net/speedbar.shtml Tramp: http://www.emacswiki.org/emacs/TrampMode

Archive­mode: http://www.pluto.it/files/journal/pj9806/archive­mode.html Gimp­mode: http://niels.kicks­ass.org/public/GimpMode/index.html

Artist­mode: http://www.cinsk.org/emacs/emacs­artist.html  Doremi­bookmarks: http://www.emacswiki.org/emacs/DoReMi

Bookmark­iterator: http://www.emacswiki.org/emacs/BookMarkIteratorPackage

GNU/Emacs –

powerful developing tool

DiffMode: http://www.emacswiki.org/emacs/DiffMode Diff2Ediff: http://www.emacswiki.org/emacs/Diff2Ediff

DiffEnanchements: http://www.emacswiki.org/emacs/DiffEnhancements DiffSaveBuffer: http://www.emacswiki.org/emacs/DiffSaveBuffer

EdiffMode: http://www.emacswiki.org/emacs/EdiffMode

Eshell: http://www.emacswiki.org/emacs/?action=browse;oldid=EmacsShell;id=CategoryEshell ShellMode: http://www.emacswiki.org/emacs/ShellMode

AnsiTerm: http://www.emacswiki.org/emacs/AnsiTerm 

Saluti e licenza...

Per questo breve appuntamento con la customizzazione di GNU/Emacs  per lo sviluppo e' tutto, spero di aver soddisfatto le vostre curiosita' e di  avervi convinti ad avvicinarvi a questo fantastico mondo!

Queste slides sono rilasciate con 

LICENZA CREATIVE COMMONS 3.0

ATTRIBUTION, SHARE ALIKE, NON COMMERCIAL

valvo <fabioviola@salug.it>