← Back to branch summary

~ubuntu-branches/ubuntu/vivid/cctools/vivid

« back to all changes in this revision

Viewing changes to ftsh/src/scanner.l

  • Committer: Bazaar Package Importer
  • Author(s): Michael Hanke
  • Date: 2011-05-07 09:05:00 UTC
  • Revision ID: james.westby@ubuntu.com-20110507090500-lqpmdtwndor6e7os
Tags: upstream-3.3.2
Import upstream version 3.3.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
ftsh/src/scanner.l
 
1
 
 
2
%option noinput
 
3
%option nounput
 
4
 
 
5
%{
 
6
#include "parser.h"
 
7
#include "parser.tab.h"
 
8
#include "ftsh_error.h"
 
9
 
 
10
#include <stdlib.h>
 
11
#include <stdio.h>
 
12
#include <string.h>
 
13
 
 
14
static int grab( int type, int firstint );
 
15
static int grab_int( int type );
 
16
 
 
17
int current_line=1;
 
18
 
 
19
%}
 
20
 
 
21
DQUOTE          ["]
 
22
NOTDQUOTE       [^"]
 
23
SQUOTE          [']
 
24
NOTSQUOTE       [^']
 
25
BQUOTE          [`]
 
26
ESCAPED         \\.
 
27
NOTSPECIAL      [^;,><&|\\'"` \t\n=()]
 
28
VARCHAR         [a-zA-Z0-9_]
 
29
 
 
30
STRING          ({NOTSPECIAL}|{ESCAPED})+
 
31
DQSTRING        {DQUOTE}({NOTDQUOTE}|{ESCAPED})*{DQUOTE}
 
32
SQSTRING        {SQUOTE}({NOTSQUOTE}|{ESCAPED})*{SQUOTE}
 
33
 
 
34
%%
 
35
#[^\n]*\n                       current_line++;
 
36
[\t ]+                          ;
 
37
\\\n                            current_line++;
 
38
\r?\n                           { grab(TOKEN_DELIMITER,0); current_line++; return TOKEN_DELIMITER; }
 
39
;                               return grab(TOKEN_DELIMITER,0);
 
40
 
 
41
\>                              return grab(TOKEN_RIGHT_ARROW,1);
 
42
[0-2]\>                         return grab_int(TOKEN_RIGHT_ARROW);
 
43
\<                              return grab(TOKEN_LEFT_ARROW,0);
 
44
[0-2]\<                         return grab_int(TOKEN_LEFT_ARROW);
 
45
\>\>                            return grab(TOKEN_DOUBLE_RIGHT_ARROW,1);
 
46
[0-2]\>\>                       return grab_int(TOKEN_DOUBLE_RIGHT_ARROW);
 
47
[0-2]\>\&                       return grab_int(TOKEN_NUMBERED_SQUIGGLY_RIGHT_ARROW);
 
48
[0-2]\>\>\&                     return grab_int(TOKEN_NUMBERED_DOUBLE_SQUIGGLY_RIGHT_ARROW);
 
49
\>\&                            return grab(TOKEN_SQUIGGLY_RIGHT_ARROW,0);
 
50
\&\>                            return grab(TOKEN_SQUIGGLY_RIGHT_ARROW,0);
 
51
\>\>\&                          return grab(TOKEN_DOUBLE_SQUIGGLY_RIGHT_ARROW,0);
 
52
\&\>\>                          return grab(TOKEN_DOUBLE_SQUIGGLY_RIGHT_ARROW,0);
 
53
\-\>                            return grab(TOKEN_LONG_RIGHT_ARROW,1);
 
54
[0-2]\-\>                       return grab_int(TOKEN_LONG_RIGHT_ARROW);
 
55
\-\<                            return grab(TOKEN_LONG_LEFT_ARROW,0);
 
56
[0-2]\-\<                       return grab_int(TOKEN_LONG_LEFT_ARROW);
 
57
\-\>\>                          return grab(TOKEN_LONG_DOUBLE_RIGHT_ARROW,1);
 
58
[0-2]\-\>\>                     return grab_int(TOKEN_LONG_DOUBLE_RIGHT_ARROW);
 
59
\-\>\&                          return grab_int(TOKEN_LONG_SQUIGGLY_RIGHT_ARROW);
 
60
\-\>\>\&                        return grab_int(TOKEN_LONG_DOUBLE_SQUIGGLY_RIGHT_ARROW);
 
61
\<\<                            ftsh_fatal(current_line," I don't support << 'here-file' (yet)\n");
 
62
[0-2]\<\<                       ftsh_fatal(current_line," I don't support [n]<< 'here-file' (yet)\n");
 
63
\-\<\<                          ftsh_fatal(current_line," I don't support -<< 'here-file' (yet)\n");
 
64
[0-2]\-\<\<                     ftsh_fatal(current_line," I don't support [n]-<< 'here-file' (yet)\n");
 
65
\|                              ftsh_fatal(current_line," I don't support | pipes (yet)\n");
 
66
\|\&                            ftsh_fatal(current_line," I don't support |& pipes (yet)\n");
 
67
function                        return grab(TOKEN_FUNCTION,0);
 
68
if                              return grab(TOKEN_IF,0);
 
69
in                              return grab(TOKEN_IN,0);
 
70
else                            return grab(TOKEN_ELSE,0);
 
71
end                             return grab(TOKEN_END,0);
 
72
try                             return grab(TOKEN_TRY,0);
 
73
every                           return grab(TOKEN_EVERY,0);
 
74
catch                           return grab(TOKEN_CATCH,0);
 
75
for                             return grab(TOKEN_FOR,0);
 
76
forany                          return grab(TOKEN_FORANY,0);
 
77
forall                          return grab(TOKEN_FORALL,0);
 
78
or                              return grab(TOKEN_OR,0);
 
79
time                            return grab(TOKEN_TIMES,0);
 
80
times                           return grab(TOKEN_TIMES,0);
 
81
second                          return grab(TOKEN_SECONDS,0);
 
82
seconds                         return grab(TOKEN_SECONDS,0);
 
83
minute                          return grab(TOKEN_MINUTES,0);
 
84
minutes                         return grab(TOKEN_MINUTES,0);
 
85
hour                            return grab(TOKEN_HOURS,0);
 
86
hours                           return grab(TOKEN_HOURS,0);
 
87
day                             return grab(TOKEN_DAYS,0);
 
88
days                            return grab(TOKEN_DAYS,0);
 
89
shift                           return grab(TOKEN_SHIFT,0);
 
90
while                           return grab(TOKEN_WHILE,0);
 
91
return                          return grab(TOKEN_RETURN,0);
 
92
\.add\.                         return grab(TOKEN_ADD,0);
 
93
\.sub\.                         return grab(TOKEN_SUB,0);
 
94
\.mul\.                         return grab(TOKEN_MUL,0);
 
95
\.div\.                         return grab(TOKEN_DIV,0);
 
96
\.mod\.                         return grab(TOKEN_MOD,0);
 
97
\.pow\.                         return grab(TOKEN_POW,0);
 
98
\.eq\.                          return grab(TOKEN_EQ,0);
 
99
\.ne\.                          return grab(TOKEN_NE,0);
 
100
\.eql\.                         return grab(TOKEN_EQL,0);
 
101
\.neql\.                        return grab(TOKEN_NEQL,0);
 
102
\.lt\.                          return grab(TOKEN_LT,0);
 
103
\.gt\.                          return grab(TOKEN_GT,0);
 
104
\.le\.                          return grab(TOKEN_LE,0);
 
105
\.ge\.                          return grab(TOKEN_GE,0);
 
106
\.and\.                         return grab(TOKEN_AND,0);
 
107
\.or\.                          return grab(TOKEN_OR,0);
 
108
\.not\.                         return grab(TOKEN_NOT,0);
 
109
\.to\.                          return grab(TOKEN_TO,0);
 
110
\.step\.                        return grab(TOKEN_STEP,0);
 
111
\(                              return grab(TOKEN_LPAREN,0);
 
112
\)                              return grab(TOKEN_RPAREN,0);
 
113
\,                              return grab(TOKEN_COMMA,0);
 
114
\.exists\.                      return grab(TOKEN_EXISTS,0);
 
115
\.isr\.                         return grab(TOKEN_ISR,0);
 
116
\.isw\.                         return grab(TOKEN_ISW,0);
 
117
\.isx\.                         return grab(TOKEN_ISX,0);
 
118
\.isblock\.                     return grab(TOKEN_ISBLOCK,0);
 
119
\.ischar\.                      return grab(TOKEN_ISCHAR,0);
 
120
\.isdir\.                       return grab(TOKEN_ISDIR,0);
 
121
\.isfile\.                      return grab(TOKEN_ISFILE,0);
 
122
\.islink\.                      return grab(TOKEN_ISLINK,0);
 
123
\.ispipe\.                      return grab(TOKEN_ISPIPE,0);
 
124
\.issock\.                      return grab(TOKEN_ISSOCK,0);
 
125
{BQUOTE}                        ftsh_fatal(current_line,"I don't support backticks (``).  Try variable redirection instead.");
 
126
{VARCHAR}+=                     { yytext[strlen(yytext)-1]=0; return grab(TOKEN_ASSIGN,0); }
 
127
{STRING}                        return grab(TOKEN_ATOM,0);
 
128
{SQSTRING}                      return grab(TOKEN_ATOM,0);
 
129
{DQSTRING}                      return grab(TOKEN_ATOM,0);
 
130
.                               ftsh_fatal(current_line,"scan error near %s",yytext);
 
131
%%
 
132
 
 
133
static int grab_int( int type )
 
134
{
 
135
        yylval.token.line = current_line;
 
136
        yylval.token.type = type;
 
137
        yylval.token.firstint = yytext[0]-'0';
 
138
        return type;
 
139
}
 
140
 
 
141
static int grab( int type, int firstint )
 
142
{
 
143
        yylval.token.line = current_line;
 
144
        yylval.token.type = type;
 
145
        yylval.token.firstint = firstint;
 
146
        return type;
 
147
}
 
148
 
 
149
int yywrap()
 
150
{
 
151
        return 1;
 
152
}
 
153