98370a7fef5d55b860954f027e2902b38ac75e77
[oota-llvm.git] / utils / TableGen / FileLexer.l
1 /*===-- FileLexer.l - Scanner for TableGen Files ----------------*- C++ -*-===//
2 //
3 // This file defines a simple flex scanner for TableGen files.  This is pretty
4 // straight-forward, except for the magic to handle file inclusion.
5 //
6 //===----------------------------------------------------------------------===*/
7
8 %option prefix="File"
9 %option yylineno
10 %option nostdinit
11 %option never-interactive
12 %option batch
13 %option nodefault
14 %option 8bit
15 %option outfile="Lexer.cpp"
16 %option ecs
17 %option noreject
18 %option noyymore
19
20 %x comment
21
22 %{
23 #include "Record.h"
24 typedef std::pair<Record*, std::vector<Init*>*> SubClassRefTy;
25 #include "FileParser.h"
26
27 // ParseInt - This has to handle the special case of binary numbers 0b0101
28 static int ParseInt(const char *Str) {
29   if (Str[0] == '0' && Str[1] == 'b')
30     return strtol(Str+2, 0, 2);
31   return strtol(Str, 0, 0); 
32 }
33
34 static int CommentDepth = 0;
35
36 struct IncludeRec {
37   std::string Filename;
38   FILE *File;
39   unsigned LineNo;
40   YY_BUFFER_STATE Buffer;
41
42   IncludeRec(const std::string &FN, FILE *F)
43     : Filename(FN), File(F), LineNo(0){
44   }
45 };
46
47 static std::vector<IncludeRec> IncludeStack;
48
49
50 std::ostream &err() {
51   if (IncludeStack.empty())
52     return std::cerr << "At end of input: ";
53
54   for (unsigned i = 0, e = IncludeStack.size()-1; i != e; ++i)
55     std::cerr << "Included from " << IncludeStack[i].Filename << ":"
56               << IncludeStack[i].LineNo << ":\n";
57   return std::cerr << "Parsing " << IncludeStack.back().Filename << ":"
58                    << Filelineno << ": ";
59 }
60
61
62 int Fileparse();
63
64 void ParseFile(const std::string &Filename) {
65   FILE *F = stdin;
66   if (Filename != "-") {
67     F = fopen(Filename.c_str(), "r");
68
69     if (F == 0) {
70       std::cerr << "Could not open input file '" + Filename + "'!\n";
71       abort();
72     }
73     IncludeStack.push_back(IncludeRec(Filename, F));
74   } else {
75     IncludeStack.push_back(IncludeRec("<stdin>", stdin));
76   }
77
78   Filein = F;
79   Filelineno = 1;
80   Fileparse();
81   Filein = stdin;
82 }
83
84 // HandleInclude - This function is called when an include directive is
85 // encountered in the input stream...
86 static void HandleInclude(const char *Buffer) {
87   unsigned Length = yyleng;
88   assert(Buffer[Length-1] == '"');
89   Buffer += strlen("include ");
90   Length -= strlen("include ");
91   while (*Buffer != '"') {
92     ++Buffer;
93     --Length;
94   }
95   assert(Length >= 2 && "Double quotes not found?");
96   std::string Filename(Buffer+1, Buffer+Length-1);
97   //std::cerr << "Filename = '" << Filename << "'\n";
98
99   // Save the line number and lex buffer of the includer...
100   IncludeStack.back().LineNo = Filelineno;
101   IncludeStack.back().Buffer = YY_CURRENT_BUFFER;
102
103   // Open the new input file...
104   yyin = fopen(Filename.c_str(), "r");
105   if (yyin == 0) {
106     err() << "Could not find include file '" << Filename << "'!\n";
107     abort();
108   }
109
110   // Add the file to our include stack...
111   IncludeStack.push_back(IncludeRec(Filename, yyin));
112   Filelineno = 1;  // Reset line numbering...
113   //yyrestart(yyin);    // Start lexing the new file...
114
115   yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
116 }
117
118
119 // yywrap - This is called when the lexer runs out of input in one of the files.
120 // Switch back to an includer if an includee has run out of input.
121 //
122 extern "C"
123 int yywrap() {
124   if (IncludeStack.back().File != stdin)
125     fclose(IncludeStack.back().File);
126   IncludeStack.pop_back();
127   if (IncludeStack.empty()) return 1;  // Top-level file is done.
128
129   // Otherwise, we need to switch back to a file which included the current one.
130   Filelineno = IncludeStack.back().LineNo;  // Restore current line number
131   yy_switch_to_buffer(IncludeStack.back().Buffer);
132   return 0;
133 }
134
135 %}
136
137 Comment      \/\/.*
138
139 Identifier   [a-zA-Z_][0-9a-zA-Z_]*
140 Integer      [-+]?[0-9]+|0x[0-9a-fA-F]+|0b[01]+
141 CodeFragment \[\{([^}]+|\}[^\]])*\}\]
142 StringVal    \"[^"]*\"
143 IncludeStr   include[ \t\n]+\"[^"]*\"
144
145 %%
146
147 {Comment}      { /* Ignore comments */ }
148
149 {IncludeStr}   { HandleInclude(yytext); }
150 {CodeFragment} { Filelval.StrVal = new std::string(yytext+2, yytext+yyleng-2);
151                  return CODEFRAGMENT; }
152
153 int            { return INT; }
154 bit            { return BIT; }
155 bits           { return BITS; }
156 string         { return STRING; }
157 list           { return LIST; }
158 code           { return CODE; }
159 dag            { return DAG; }
160
161 class          { return CLASS; }
162 def            { return DEF; }
163 field          { return FIELD; }
164 let            { return LET; }
165 in             { return IN; }
166
167 {Identifier}   { Filelval.StrVal = new std::string(yytext, yytext+yyleng);
168                  return ID; }
169 ${Identifier}  { Filelval.StrVal = new std::string(yytext+1, yytext+yyleng);
170                  return VARNAME; } 
171
172 {StringVal}    { Filelval.StrVal = new std::string(yytext+1, yytext+yyleng-1);
173                  return STRVAL; }
174
175 {Integer}      { Filelval.IntVal = ParseInt(Filetext); return INTVAL; }
176
177 [ \t\n]+       { /* Ignore whitespace */ }
178
179
180 "/*"                    { BEGIN(comment); CommentDepth++; }
181 <comment>[^*/]*         /* eat anything that's not a '*' or '/' */
182 <comment>"*"+[^*/]*     /* eat up '*'s not followed by '/'s */
183 <comment>"/*"           { ++CommentDepth; }
184 <comment>"/"+[^*]*      /* eat up /'s not followed by *'s */
185 <comment>"*"+"/"        { if (!--CommentDepth) { BEGIN(INITIAL); } }
186 <comment><<EOF>>        { err() << "Unterminated comment!\n"; abort(); }
187
188 .              { return Filetext[0]; }
189
190 %%