Comment utiliser l'indentation comme des délimiteurs de blocs avec Bison et Flex

Ce que vous devez faire est de compter sur la flexion comptant la quantité de blancheurs au début de chaque ligne et d'insérer un nombre approprié de jetons indentés / indéfinissants pour l'analyseur à utiliser pour collecter des choses. Une question est de savoir ce que vous voulez faire à propos des onglets VS espaces - Voulez-vous simplement les avoir équivalents avec des arrêts à tabulation fixe ou souhaitez-vous avoir besoin d'indenter pour être cohérent (donc si une ligne commence par un onglet et la suivante Avec un espace, vous signalez une erreur, qui est probablement un peu plus difficile).

En supposant que vous souhaitiez que vous voulez des tablatures à 8 colonnes fixes, vous pouvez utiliser quelque chose comme P>

%{
/* globals to track current indentation */
int current_line_indent = 0;   /* indentation of the current line */
int indent_level = 0;          /* indentation level passed to the parser */
%}

%x indent /* start state for parsing the indentation */
%s normal /* normal start state for everything else */

%%
<indent>" "      { current_line_indent++; }
<indent>"\t"     { current_line_indent = (current_line_indent + 8) & ~7; }
<indent>"\n"     { current_line_indent = 0; /*ignoring blank line */ }
<indent>.        {
                   unput(*yytext);
                   if (current_line_indent > indent_level) {
                       indent_level++;
                       return INDENT;
                   } else if (current_line_indent < indent_level) {
                       indent_level--;
                       return UNINDENT;
                   } else {
                       BEGIN normal;
                   }
                 }

<normal>"\n"     { current_line_indent = 0; BEGIN indent; }
... other flex rules ...

La réponse de Chris va un long chemin vers une solution utilisable, merci un tas pour cela! Malheureusement, il manque quelques aspects plus importants dont j'avais besoin:

• multiples idées (unindants) à la fois. Considérez que le code suivant devrait émettre deux forte> dépassement après l'appel à Baz code>: p> XXX PRE> LI>

• Émettez-vous lorsque la fin du fichier est atteinte et est toujours à un niveau d'indentation. p> li>

• niveaux d'indentation de taille différente. Le code actuel de Chris fonctionne uniquement correctement pour les tirettes 1 espace. Li> ul>

  basé sur le code de Chris, j'ai proposé une solution qui fonctionne dans tous les cas où j'ai rencontré jusqu'à présent. J'ai créé un projet de modèle pour analyser le texte basé sur l'indentation à l'aide de Flex (et Bison) sur Github: https://github.com/lucasb-eyer/flex-bison-indentation . Il s'agit d'un projet entièrement actif (basé sur la cmake) qui suit également la position de la ligne et la plage de colonnes du jeton actuel. P>

  Juste au cas où le lien devrait casser une raison quelconque, voici la viande de la Lexer: P>

  #include <stack>
  
  int g_current_line_indent = 0;
  std::stack<size_t> g_indent_levels;
  int g_is_fake_outdent_symbol = 0;
  
  static const unsigned int TAB_WIDTH = 2;
  
  #define YY_USER_INIT { \
      g_indent_levels.push(0); \
      BEGIN(initial); \
  }
  #include "parser.hh"
  
  %}
  
  %x initial
  %x indent
  %s normal
  
  %%
      int indent_caller = normal;
  
   /* Everything runs in the <normal> mode and enters the <indent> mode
      when a newline symbol is encountered.
      There is no newline symbol before the first line, so we need to go
      into the <indent> mode by hand there.
   */
  <initial>.  { set_yycolumn(yycolumn-1); indent_caller = normal; yyless(0); BEGIN(indent); }
  <initial>\n { indent_caller = normal; yyless(0); BEGIN(indent); }    
  
  <indent>" "     { g_current_line_indent++; }
  <indent>\t      { g_current_line_indent = (g_current_line_indent + TAB_WIDTH) & ~(TAB_WIDTH-1); }
  <indent>\n      { g_current_line_indent = 0; /* ignoring blank line */ }
  <indent><<EOF>> {
                      // When encountering the end of file, we want to emit an
                      // outdent for all indents currently left.
                      if(g_indent_levels.top() != 0) {
                          g_indent_levels.pop();
  
                          // See the same code below (<indent>.) for a rationale.
                          if(g_current_line_indent != g_indent_levels.top()) {
                              unput('\n');
                              for(size_t i = 0 ; i < g_indent_levels.top() ; ++i) {
                                  unput(' ');
                              }
                          } else {
                              BEGIN(indent_caller);
                          }
  
                          return TOK_OUTDENT;
                      } else {
                          yyterminate();
                      }
                  }
  
  <indent>.       {
                      if(!g_is_fake_outdent_symbol) {
                          unput(*yytext);
                      }
                      g_is_fake_outdent_symbol = 0;
                      // -2: -1 for putting it back and -1 for ending at the last space.
                      set_yycolumn(yycolumn-1);
  
                      // Indentation level has increased. It can only ever
                      // increase by one level at a time. Remember how many
                      // spaces this level has and emit an indentation token.
                      if(g_current_line_indent > g_indent_levels.top()) {
                          g_indent_levels.push(g_current_line_indent);
                          BEGIN(indent_caller);
                          return TOK_INDENT;
                      } else if(g_current_line_indent < g_indent_levels.top()) {
                          // Outdenting is the most difficult, as we might need to
                          // outdent multiple times at once, but flex doesn't allow
                          // emitting multiple tokens at once! So we fake this by
                          // 'unput'ting fake lines which will give us the next
                          // outdent.
                          g_indent_levels.pop();
  
                          if(g_current_line_indent != g_indent_levels.top()) {
                              // Unput the rest of the current line, including the newline.
                              // We want to keep it untouched.
                              for(size_t i = 0 ; i < g_current_line_indent ; ++i) {
                                  unput(' ');
                              }
                              unput('\n');
                              // Now, insert a fake character indented just so
                              // that we get a correct outdent the next time.
                              unput('.');
                              // Though we need to remember that it's a fake one
                              // so we can ignore the symbol.
                              g_is_fake_outdent_symbol = 1;
                              for(size_t i = 0 ; i < g_indent_levels.top() ; ++i) {
                                  unput(' ');
                              }
                              unput('\n');
                          } else {
                              BEGIN(indent_caller);
                          }
  
                          return TOK_OUTDENT;
                      } else {
                          // No change in indentation, not much to do here...
                          BEGIN(indent_caller);
                      }
                  }
  
  <normal>\n    { g_current_line_indent = 0; indent_caller = YY_START; BEGIN(indent); }