Cercando di costruire una grammatica C# per bisonti/bisognosi

Question

Non ho mai fatto prima Bison o Wisent.
come posso iniziare?

Il mio vero obiettivo è quello di produrre una grammatica di Wisent/Semantic funzionante per C#, per consentire a C# di essere modificato in emacs con il completamento del codice, e tutti gli altri articoli CEDET. (Per chi non lo sapesse, Wisent è una porta emacs-lisp di GNU Bison, che è inclusa in CEDET. The Wisent apparentemente è un bisonte europeo e Bison, lo prendo, è un gioco di parole derivante dallo YACC. E CEDET è una raccolta di strumenti di sviluppo di Emacs. Tutto ciò che viene raggiunto? Non cercherò di definire emacs.

Microsoft fornisce la grammatica BNF per C#, incluse tutte le estensioni LINQ, nel numero language reference document. Sono stato in grado di tradurlo in un file .wy che viene compilato correttamente con semantic-grammar-create-package.

Ma la grammatica compilata non "funziona". In alcuni casi la grammatica "trova" le dichiarazioni enum, ma non le dichiarazioni class. Perché? Non lo so. Non sono stato in grado di farlo riconoscere gli attributi. Non sto trovando il "debugging" della grammatica per essere molto facile.

Ho pensato di fare un passo indietro e provare a produrre una grammatica saggia per un linguaggio molto più semplice, una lingua giocattolo con poche parole chiave. Solo per ottenere qualche esperienza. Anche quello sta dimostrando una sfida.

Ho visto i documenti .info sulla grammatica fw e saggia, ma ... comunque quelle cose non mi stanno davvero chiarendo, come funzionano davvero le cose.

Così

Q1: qualche consiglio su debug di una grammatica bisonte in emacs? C'è un modo per eseguire una cosa simile a un pelucchi sulla grammatica per scoprire se ci sono regole inutilizzate, cose senza fine come quelle? Che ne dici di essere in grado di osservare il parser in azione? Qualcosa del genere?

Q2: Qualche consiglio su come arrivare in velocità su bisonte/bisognoso in generale? Quello che sto pensando è uno strumento che mi permetterà di avere un'idea di come funzionano le regole. Qualcosa che fornisce una certa trasparenza, invece dell'esperienza "non ha funzionato", sto ottenendo ora con Wisent.

Q3: Piuttosto che continuare a combattere questo, dovrei rinunciare e diventare un agricoltore biologico?

---

ps: conosco la grammatica C# esistente nella directory contrib di CEDET/semantic. Questa cosa funziona, ma ... Non supporta l'ultima specifica C#, incluso LINQ, classi e metodi parziali, resa, metodi anonimi, inizializzatori di oggetti e così via. Inoltre si occupa principalmente di analizzare un po 'del codice C#. Annusa le classi e i metodi e poi bails. Anche i cicli foreach non sono fatti bene. Va bene fino in fondo, ma mi piacerebbe vederlo essere migliore. Quello che sto cercando di fare è renderlo attuale e anche estenderlo per analizzare più del codice C#.

Answer 1

Si consiglia di esaminare l'esempio di calcolo nella directory semantica/wisent. È abbastanza semplice e mostra anche come utilizzare le funzioni% sinistra e% destra. "Eseguirà" il codice anziché convertirlo in tag. Alcune altre grammatiche semplici includono il parser 'punto' in cogre e il parser srecode in srecode.

Per il debug di debug, nel menu è presente un indicatore di verbosità, anche se a dire il vero non l'ho provato. C'è anche wisent-debug-on-entry che ti permette di selezionare un'azione che farà sì che il debugger Emacs si fermi in quella azione in modo da poter vedere quali sono i valori.

Il parser "bovino" più vecchio ha una modalità di debug che consente di scorrere le regole, ma non è mai stato convertito in wisent. Questa è una caratteristica che mi è mancata molto mentre scrivo i parser saggia.

Answer 2

Per quanto riguarda Q1: prima assicurarsi che il parser bisonte è effettivamente utilizzato:

(fetch-overload 'semantic-parse-stream) 

dovrebbe restituire wisent-parse-stream.

Eseguire il seguente elisp-frammento:

(easy-menu-add-item semantic-mode-map '(menu-bar cedet-menu) ["Wisent-Debug" wisent-debug-toggle :style toggle :selected (wisent-debug-active)]) 
(defun wisent-debug-active() 
    "Return non-nil if wisent debugging is active." 
    (assoc 'wisent-parse-action-debug (ad-get-advice-info-field 'wisent-parse-action 'after))) 
(defun wisent-debug-toggle() 
    "Install debugging of wisent-parser" 
    (interactive) 
    (if (wisent-debug-active) 
     (ad-unadvise 'wisent-parse-action) 
    (defadvice wisent-parse-action (after wisent-parse-action-debug activate) 
     (princ (format "\ntoken:%S;\nactionList:%S;\nreturn:%S\n" 
      (eval i) 
      (eval al) 
      (eval ad-return-value)) (get-buffer-create "*wisent-debug*")))) 
    (let ((fileName (locate-file "semantic/wisent/wisent" load-path '(".el" ".el.gz"))) 
    fct found) 
    (if fileName 
    (with-current-buffer (find-file-noselect fileName) 
     (goto-char (point-max)) 
     (while (progn 
      (backward-list) 
      (setq fct (sexp-at-point)) 
      (null 
      (or 
      (bobp) 
      (and 
       (listp fct) 
       (eq 'defun (car fct)) 
       (setq found (eq 'wisent-parse (cadr fct)))))))) 
     (if found 
      (eval fct) 
     (error "Did not find wisent-parse."))) 
     (error "Source file for semantic/wisent/wisent not found.") 
    ))) 

Si crea una nuova voce Bisonte-debug nel Sviluppo-menu. Facendo clic su questa voce si attiva il debug del parser wisent. La prossima volta che si esegue il reparse di un buffer con il parser-wisent, esso invia le informazioni di debug al buffer * debug debug *. Il buffer * wisent debug * non viene mostrato automaticamente ma lo si trova tramite il menu del buffer. Per evitare un flooding di * debug debug *, disabilitare "Reparse when idle". Di tanto in tanto si cancella il buffer * wisent debug * con il buffer di cancellazione.