How to use indentation as block delimiters with bison and flex
Chris' answer goes a long way towards a usable solution, thanks a bunch for this! Unfortunately, it is missing a few more important aspects which I needed:
Multiple outdents (unindents) at once. Consider the following code should emit two outdents after the call to
baz:def foo(): if bar: baz()Emit outdents when the end of the file is reached and still is in some indentation level.
- Indentation levels of different size. Chris' current code only works correctly for 1-space indents.
Based on Chris' code, I came up with a solution which works in all the cases I have come across so far. I have created a template project for parsing indentation-based text using flex (and bison) on github: https://github.com/lucasb-eyer/flex-bison-indentation. It is a fully working (CMake-based) project which also tracks the line position and the column range of the current token.
Just in case the link should break for whatever reason, here is the meat of the lexer:
#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); }
What you need to do is have flex count the amount of whitespace at the beginning of every line and insert an appropriate number of INDENT/UNINDENT tokens for the parser to use to group things. One question is what you want to do about tabs vs spaces -- do you just want to have them be equivalent with fixed tab stops, or do you want to require indenting to be consistent (so if one line begins with a tab and the next with a space, you signal an error, which is probably a little harder).
Assuming you want fixed 8-column tabstops, you can use something like
%{
/* 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 ...
You do have to make sure you start the parse in indent mode (to get the indentation on the first line).