Essayer de construire une grammaire C# pour bison/wisent

Question

Je n'ai jamais fait Bison ou Wisent auparavant.
comment puis-je commencer?

Mon but réel est de produire une grammaire Wisent/Semantic fonctionnelle pour C#, pour permettre à C# d'être édité dans emacs avec l'achèvement de code, et tous les autres goodies CEDET. (Pour ceux qui ne connaissent pas, Wisent est un port emacs-lisp de GNU Bison, qui est inclus dans CEDET The Wisent est apparemment un bison européen.Et Bison, je suppose, est un jeu de mots dérivant de YACC. Et CEDET est une collection d'outils de développement Emacs, tous rattrapés, je ne vais pas essayer de définir emacs.)

Microsoft fournit la grammaire BNF pour C#, y compris toutes les extensions LINQ, dans le language reference document. J'ai été en mesure de traduire cela dans un fichier .wy qui compile avec succès avec semantic-grammar-create-package.

Mais la grammaire compilée ne "fonctionne" pas. Dans certains cas, la grammaire "trouve" les déclarations enum, mais pas les déclarations class. Pourquoi? Je ne sais pas. Je n'ai pas réussi à l'obtenir pour reconnaître les attributs. Je ne trouve pas le "débogage" de la grammaire très facile.

Je pensais prendre un peu de recul et essayer de produire une grammaire Wisent pour un langage beaucoup plus simple, un langage de jouets avec seulement quelques mots clés. Juste pour acquérir de l'expérience. Même cela s'avère un défi.

J'ai vu les documents .info sur la grammaire fw, et wisent, mais ... encore ces choses ne sont pas vraiment claires pour moi, comment le truc fonctionne vraiment.

Alors

Q1: des conseils sur la mise au point d'une grammaire wisent dans emacs? Y a-t-il un moyen d'exécuter une chose semblable à une peluche sur la grammaire pour savoir s'il y a des règles inutilisées, des choses sans issue comme ça? Qu'en est-il de pouvoir regarder l'analyseur en action? Quelque chose comme ça?

Q2: Avez-vous des conseils pour vous familiariser avec le bison/le bison en général? Ce que je pense est un outil qui me permettra d'avoir un aperçu de la façon dont les règles fonctionnent. Quelque chose qui offre une certaine transparence, au lieu de l'expérience "ça n'a pas fonctionné", je reçois maintenant avec Wisent.

Q3: Plutôt que de continuer à lutter contre cela, devrais-je abandonner et devenir un agriculteur biologique? Ps: Je connais la grammaire C# existante dans le répertoire contrib de CEDET/sémantique. Cela fonctionne, mais ... Il ne supporte pas la dernière spécification C#, y compris LINQ, les classes partielles et les méthodes, le rendement, les méthodes anonymes, les initialiseurs d'objets, etc. En outre, il pique surtout sur l'analyse d'un tas de code C#. Il renifle les classes et les méthodes, puis se retire. Même les boucles foreach ne sont pas faites correctement. C'est bon, mais j'aimerais que ce soit meilleur. Ce que j'essaie de faire est de le rendre actuel, et aussi l'étendre pour analyser plus de code C#.

Answer 1

Vous pouvez regarder l'exemple calc dans le répertoire sémantique/wisent. C'est assez simple, et montre également comment utiliser les fonctions% left et% right. Il va "exécuter" le code au lieu de le convertir en tags. D'autres grammaires simples incluent l'analyseur 'point' dans cogre, et l'analyseur srecode dans srecode.

Pour wisent le débogage, il y a un drapeau de verbosité dans le menu, bien que pour être honnête je ne l'avais pas essayé. Il y a aussi wisent-debug-on-entry qui vous permet de sélectionner une action qui provoquera l'arrêt du débogueur Emacs dans cette action afin que vous puissiez voir quelles sont les valeurs. L'ancien analyseur "bovin" dispose d'un mode de débogage qui vous permet de parcourir les règles, mais il n'a jamais été porté vers Wise. C'est une caractéristique que j'ai beaucoup manqué en écrivant des analyseurs.

Answer 2

En ce qui concerne Q1: 1er assurez-vous que l'analyseur wisent est en fait utilisé:

(fetch-overload 'semantic-parse-stream) 

devrait revenir wisent-parse-stream.

Exécutez le elisp-extrait suivant:

(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.") 
    ))) 

Il crée une nouvelle Wisent-Debug entrée dans le menu Développement. Cliquez sur cette entrée pour basculer le débogage de l'analyseur wisent. La prochaine fois que vous analyserez un tampon avec le wisent-parser, il affichera les informations de débogage dans le tampon * wisent debug *. Le buffer * wisent debug * n'est pas affiché automatiquement mais vous le trouvez via le menu buffer. Pour éviter un débordement de * wisent debug * vous devez désactiver "Reparse when idle". De temps en temps vous effacez le tampon * wisent debug * avec erase-buffer.