elna/source/lexer.ll

/*
 * This Source Code Form is subject to the terms of the Mozilla Public License
 * v. 2.0. If a copy of the MPL was not distributed with this file, You can
 * obtain one at http://mozilla.org/MPL/2.0/.
 */
%{
#define YY_NO_UNISTD_H
#define YY_USER_ACTION this->location.columns(yyleng);

#include <sstream>
#include "parser.hh"

#undef YY_DECL
#define YY_DECL yy::parser::symbol_type elna::source::lexer::lex(elna::source::driver& driver)
#define yyterminate() return yy::parser::make_YYEOF(this->location)
%}

%option c++ noyywrap never-interactive
%option yyclass="elna::source::lexer"

%%
%{
    this->location.step();
%}

\-\-.*                  {
                            /* Skip the comment */
                        }
[\ \t\r]                ; /* Skip the whitespaces */
\n+                     {
                            this->location.lines(yyleng);
                            this->location.step();
                        }
if                      {
                            return yy::parser::make_IF(this->location);
                        }
then                    {
                            return yy::parser::make_THEN(this->location);
                        }
else                    {
                            return yy::parser::make_ELSE(this->location);
                        }
while                   {
                            return yy::parser::make_WHILE(this->location);
                        }
do                      {
                            return yy::parser::make_DO(this->location);
                        }
proc                    {
                            return yy::parser::make_PROCEDURE(this->location);
                        }
begin                   {
                            return yy::parser::make_BEGIN_BLOCK(this->location);
                        }
end                     {
                            return yy::parser::make_END_BLOCK(this->location);
                        }
const                   {
                            return yy::parser::make_CONST(this->location);
                        }
var                     {
                            return yy::parser::make_VAR(this->location);
                        }
array                   {
                            return yy::parser::make_ARRAY(this->location);
                        }
of                      {
                            return yy::parser::make_OF(this->location);
                        }
type                    {
                            return yy::parser::make_TYPE(this->location);
                        }

true                    {
                            return yy::parser::make_BOOLEAN(true, this->location);
                        }
false                   {
                            return yy::parser::make_BOOLEAN(false, this->location);
                        }
[A-Za-z_][A-Za-z0-9_]*  {
                            return yy::parser::make_IDENTIFIER(yytext, this->location);
                        }
[0-9]+                  {
                            return yy::parser::make_INTEGER(strtol(yytext, NULL, 10), this->location);
                        }
[0-9]+\.[0-9]           {
                            return yy::parser::make_FLOAT(strtof(yytext, NULL), this->location);
                        }
'[^']'                  {
                            return yy::parser::make_CHARACTER(
									std::string(yytext, 1, strlen(yytext) - 2), this->location);
                        }
\"[^\"]*\"              {
                            return yy::parser::make_STRING(
									std::string(yytext, 1, strlen(yytext) - 2), this->location);
                        }
\(                      {
                            return yy::parser::make_LEFT_PAREN(this->location);
                        }
\)                      {
                            return yy::parser::make_RIGHT_PAREN(this->location);
                        }
\[                      {
                            return yy::parser::make_LEFT_SQUARE(this->location);
                        }
\]                      {
                            return yy::parser::make_RIGHT_SQUARE(this->location);
                        }
\>=                     {
                            return yy::parser::make_GREATER_EQUAL(this->location);
                        }
\<=                     {
                            return yy::parser::make_LESS_EQUAL(this->location);
                        }
\>                      {
                            return yy::parser::make_GREATER_THAN(this->location);
                        }
\<                      {
                            return yy::parser::make_LESS_THAN(this->location);
                        }
\/=                     {
                            return yy::parser::make_NOT_EQUAL(this->location);
                        }
=                       {
                            return yy::parser::make_EQUALS(this->location);
                        }
;                       {
                            return yy::parser::make_SEMICOLON(this->location);
                        }
\.                      {
                            return yy::parser::make_DOT(this->location);
                        }
,                       {
                            return yy::parser::make_COMMA(this->location);
                        }
\+                      {
                            return yy::parser::make_PLUS(this->location);
                        }
\-                      {
                            return yy::parser::make_MINUS(this->location);
                        }
\*                      {
                            return yy::parser::make_MULTIPLICATION(this->location);
                        }
\/                      {
                            return yy::parser::make_DIVISION(this->location);
                        }
:=                      {
                            return yy::parser::make_ASSIGNMENT(this->location);
                        }
:                       {
                            return yy::parser::make_COLON(this->location);
                        }
\^                      {
                            return yy::parser::make_HAT(this->location);
                        }
@                       {
                            return yy::parser::make_AT(this->location);
                        }
.                       {
                            std::stringstream ss;

                            ss << "Illegal character 0x" << std::hex << static_cast<unsigned int>(yytext[0]);
                            driver.error(this->location, ss.str());
                        }
%%