about summary refs log blame commit diff
path: root/src/libexpr/lexer.l
blob: 8f9d686a1c89816bf33acaa26885578e62501561 (plain) (tree)
1
2
3
4
5
6
7
8
9


                                              


                              

 
         
             

 
  
                     
                        
 



                    
 

                                  

                                             

 
 

                                                                


                                         

                      



                                      
                 

                                

                 
                              



        
 
                                                                
 

















                                                 
                                             

 
 
 
 


                                                         


                                                         


  
                                        
                  
                                          
                                                         
                                       
                                                             
                                                                                      








                              
                            
                           
                          
                           
                               
                             
                                


                           

                           


                            
                              
                              
 
                                                       


                                                
                                                                                 

                         





                                                                               
 


                                                         
 
                                               




                                                                           
                                                             
                         
             

                                                           

                                                                      
                                                                    
                                            
                                                      
                                  

                    
                                                   


                                  
                                                    


                                  
                                                                      
                                  
                  

                                                              
                  
                                                   

                                  
                                                                           
 
                                                           
                                                            
                                                            
                                                         
 

                                        
                                            




                             
 
%option reentrant bison-bridge bison-locations
%option noyywrap
%option never-interactive
%option stack
%option nodefault
%option nounput noyy_top_state


%x STRING
%x IND_STRING


%{
#include "nixexpr.hh"
#include "parser-tab.hh"

using namespace nix;

namespace nix {


static void initLoc(YYLTYPE * loc)
{
    loc->first_line = loc->last_line = 1;
    loc->first_column = loc->last_column = 1;
}


static void adjustLoc(YYLTYPE * loc, const char * s, size_t len)
{
    loc->first_line = loc->last_line;
    loc->first_column = loc->last_column;

    while (len--) {
       switch (*s++) {
       case '\r':
           if (*s == '\n') /* cr/lf */
               s++;
           /* fall through */
       case '\n':
           ++loc->last_line;
           loc->last_column = 1;
           break;
       default:
           ++loc->last_column;
       }
    }
}


static Expr * unescapeStr(SymbolTable & symbols, const char * s)
{
    string t;
    char c;
    while ((c = *s++)) {
        if (c == '\\') {
            assert(*s);
            c = *s++;
            if (c == 'n') t += '\n';
            else if (c == 'r') t += '\r';
            else if (c == 't') t += '\t';
            else t += c;
        }
        else if (c == '\r') {
            /* Normalise CR and CR/LF into LF. */
            t += '\n';
            if (*s == '\n') s++; /* cr/lf */
        }
        else t += c;
    }
    return new ExprString(symbols.create(t));
}


}

#define YY_USER_INIT initLoc(yylloc)
#define YY_USER_ACTION adjustLoc(yylloc, yytext, yyleng);

#define PUSH_STATE(state) yy_push_state(state, yyscanner)
#define POP_STATE() yy_pop_state(yyscanner)

%}


ID          [a-zA-Z\_][a-zA-Z0-9\_\'\-]*
INT         [0-9]+
FLOAT       {INT}[0-9]+\.[0-9]+[eE]-?{INT}
PATH        [a-zA-Z0-9\.\_\-\+]*(\/[a-zA-Z0-9\.\_\-\+]+)+
HPATH       \~(\/[a-zA-Z0-9\.\_\-\+]+)+
SPATH       \<[a-zA-Z0-9\.\_\-\+]+(\/[a-zA-Z0-9\.\_\-\+]+)*\>
URI         [a-zA-Z][a-zA-Z0-9\+\-\.]*\:[a-zA-Z0-9\%\/\?\:\@\&\=\+\$\,\-\_\.\!\~\*\']+


%%


if          { return IF; }
then        { return THEN; }
else        { return ELSE; }
assert      { return ASSERT; }
with        { return WITH; }
let         { return LET; }
in          { return IN; }
rec         { return REC; }
inherit     { return INHERIT; }
or          { return OR_KW; }
\.\.\.      { return ELLIPSIS; }

\=\=        { return EQ; }
\!\=        { return NEQ; }
\<\=        { return LEQ; }
\>\=        { return GEQ; }
\&\&        { return AND; }
\|\|        { return OR; }
\-\>        { return IMPL; }
\/\/        { return UPDATE; }
\+\+        { return CONCAT; }

{ID}        { yylval->id = strdup(yytext); return ID; }
{INT}       { errno = 0;
              yylval->n = strtol(yytext, 0, 10);
              if (errno != 0)
                  throw ParseError(format("invalid integer ‘%1%’") % yytext);
              return INT;
            }
{FLOAT}     { errno = 0;
              yylval->n = strtod(yytext, 0);
              if (errno != 0)
                  throw ParseError(format("invalid float ‘%1%’") % yytext);
              return FLOAT;
            }

\$\{        { PUSH_STATE(INITIAL); return DOLLAR_CURLY; }
\{          { PUSH_STATE(INITIAL); return '{'; }
\}          { POP_STATE(); return '}'; }

\"          { PUSH_STATE(STRING); return '"'; }
<STRING>([^\$\"\\]|\$[^\{\"\\]|\\.|\$\\.)*\$/\" |
<STRING>([^\$\"\\]|\$[^\{\"\\]|\\.|\$\\.)+ {
              /* It is impossible to match strings ending with '$' with one
                 regex because trailing contexts are only valid at the end
                 of a rule. (A sane but undocumented limitation.) */
              yylval->e = unescapeStr(data->symbols, yytext);
              return STR;
            }
<STRING>\$\{  { PUSH_STATE(INITIAL); return DOLLAR_CURLY; }
<STRING>\"  { POP_STATE(); return '"'; }
<STRING>.   return yytext[0]; /* just in case: shouldn't be reached */

\'\'(\ *\n)?     { PUSH_STATE(IND_STRING); return IND_STRING_OPEN; }
<IND_STRING>([^\$\']|\$[^\{\']|\'[^\'\$])+ {
                   yylval->e = new ExprIndStr(yytext);
                   return IND_STR;
                 }
<IND_STRING>\'\'\$ {
                   yylval->e = new ExprIndStr("$");
                   return IND_STR;
                 }
<IND_STRING>\'\'\' {
                   yylval->e = new ExprIndStr("''");
                   return IND_STR;
                 }
<IND_STRING>\'\'\\. {
                   yylval->e = unescapeStr(data->symbols, yytext + 2);
                   return IND_STR;
                 }
<IND_STRING>\$\{ { PUSH_STATE(INITIAL); return DOLLAR_CURLY; }
<IND_STRING>\'\' { POP_STATE(); return IND_STRING_CLOSE; }
<IND_STRING>\'   {
                   yylval->e = new ExprIndStr("'");
                   return IND_STR;
                 }
<IND_STRING>.    return yytext[0]; /* just in case: shouldn't be reached */

{PATH}      { yylval->path = strdup(yytext); return PATH; }
{HPATH}     { yylval->path = strdup(yytext); return HPATH; }
{SPATH}     { yylval->path = strdup(yytext); return SPATH; }
{URI}       { yylval->uri = strdup(yytext); return URI; }

[ \t\r\n]+    /* eat up whitespace */
\#[^\r\n]*    /* single-line comments */
\/\*([^*]|\*[^\/])*\*\/  /* long comments */

.           return yytext[0];


%%