initial commit
[xonotic/gmqcc.git] / lex.c
1 /*
2  * Copyright (C) 2012 
3  *      Dale Weiler
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining a copy of
6  * this software and associated documentation files (the "Software"), to deal in
7  * the Software without restriction, including without limitation the rights to
8  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
9  * of the Software, and to permit persons to whom the Software is furnished to do
10  * so, subject to the following conditions:
11  *
12  * The above copyright notice and this permission notice shall be included in all
13  * copies or substantial portions of the Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21  * SOFTWARE.
22  */
23 #include <stdio.h>
24 #include <limits.h>
25 #include <stdlib.h>
26 #include <ctype.h>
27 #include <string.h>
28 #include "gmqcc.h"
29
30 static const char *const lex_keywords[] = {
31         "do",    "else",     "if",     "while",
32         "break", "continue", "return", "goto",
33         "for"
34 };
35
36 struct lex_file *lex_open(const char *name) {
37         struct lex_file *lex = mem_a(sizeof(struct lex_file));
38         if (lex) {
39                 lex->file = fopen(name, "r");
40                 fseek(lex->file, 0, SEEK_END);
41                 lex->length = ftell(lex->file);
42                 lex->size   = lex->length; /* copy, this is never changed */
43                 fseek(lex->file, 0, SEEK_SET);
44                 lex->last = 0;
45                 
46                 memset(lex->peek, 0, sizeof(lex->peek));
47         }
48         return lex;
49 }
50
51 int lex_close(struct lex_file *file) {
52         int ret = -1;
53         if (file) {
54                 ret = fclose(file->file);
55                 mem_d(file);
56         }
57         return ret;
58 }
59
60 static void lex_addch(int ch, struct lex_file *file) {
61         if (file->current <  sizeof(file->lastok)-1)
62                 file->lastok[file->current++] = (char)ch;
63         if (file->current == sizeof(file->lastok)-1)
64                 file->lastok[file->current]   = (char)'\0';
65 }
66 static inline void lex_clear(struct lex_file *file) {
67         file->current = 0;
68 }
69
70 /*
71  * read in inget/unget character from a lexer stream.
72  * This doesn't play with file streams, the lexer has
73  * it's own internal state for this.
74  */
75 static int lex_inget(struct lex_file *file) {
76         file->length --;
77         if (file->last > 0)
78                 return file->peek[--file->last];
79         return fgetc(file->file);
80 }
81 static void lex_unget(int ch, struct lex_file *file) {
82         if (file->last < sizeof(file->peek))
83                 file->peek[file->last++] = ch;
84         file->length ++;
85 }
86
87 /*
88  * This is trigraph and digraph support, a feature not qc compiler
89  * supports.  Moving up in this world!
90  */
91 static int lex_trigraph(struct lex_file *file) {
92         int  ch;
93         if ((ch = lex_inget(file)) != '?') {
94                 lex_unget(ch, file);
95                 return '?';
96         }
97         
98         ch = lex_inget(file);
99         switch (ch) {
100                 case '(' : return '[' ;
101                 case ')' : return ']' ;
102                 case '/' : return '\\';
103                 case '\'': return '^' ;
104                 case '<' : return '{' ;
105                 case '>' : return '}' ;
106                 case '!' : return '|' ;
107                 case '-' : return '~' ;
108                 case '=' : return '#' ;
109                 default:
110                         lex_unget('?', file);
111                         lex_unget(ch , file);
112                         return '?';
113         }
114         return '?';
115 }
116 static int lex_digraph(struct lex_file *file, int first) {
117         int ch = lex_inget(file);
118         switch (first) {
119                 case '<':
120                         if (ch == '%') return '{';
121                         if (ch == ':') return '[';
122                         break;
123                 case '%':
124                         if (ch == '>') return '}';
125                         if (ch == ':') return '#';
126                         break;
127                 case ':':
128                         if (ch == '>') return ']';
129                         break;
130         }
131         
132         lex_unget(ch, file);
133         return first;
134 }
135
136 static int lex_getch(struct lex_file *file) {
137         int ch = lex_inget(file);
138         if (ch == '?')
139                 return lex_trigraph(file);
140         if (ch == '<' || ch == ':' || ch == '%')
141                 return lex_digraph (file, ch);
142                 
143         return ch;
144 }
145
146 static int lex_get(struct lex_file *file) {
147         int ch;
148         if (!isspace(ch = lex_getch(file)))
149                 return ch;
150         
151         /* skip over all spaces */
152         while (isspace(ch) && ch != '\n')
153                 ch = lex_getch(file);
154                 
155         if (ch == '\n')
156                 return ch;
157                 
158         lex_unget(ch, file);
159         return ' ';
160 }
161
162 static int lex_skipchr(struct lex_file *file) {
163         int ch;
164         int it;
165         
166         lex_clear(file);
167         lex_addch('\'', file);
168         
169         for (it = 0; it < 2 && ((ch = lex_inget(file)) != '\''); it++) {
170                 lex_addch(ch, file);
171                 
172                 if (ch == '\n')
173                         return ERROR_LEX;
174                 if (ch == '\\')
175                         lex_addch(lex_getch(file), file);
176         }
177         lex_addch('\'', file);
178         lex_addch('\0', file);
179         
180         if (it > 2)
181                 return ERROR_LEX;
182                 
183         return LEX_CHRLIT;
184 }
185
186 static int lex_skipstr(struct lex_file *file) {
187         int ch;
188         lex_clear(file);
189         lex_addch('"', file);
190         
191         while ((ch = lex_getch(file)) != '"') {
192                 if (ch == '\n' || ch == EOF)
193                         return ERROR_LEX;
194                         
195                 lex_addch(ch, file);
196                 if (ch == '\\')
197                         lex_addch(lex_inget(file), file);
198         }
199         
200         lex_addch('"', file);
201         lex_addch('\0', file);
202         
203         return LEX_STRLIT;
204 }
205 static int lex_skipcmt(struct lex_file *file) {
206         int ch;
207         lex_clear(file);
208         ch = lex_getch(file);
209         
210         if (ch == '/') {
211                 lex_addch('/', file);
212                 lex_addch('/', file);
213                 
214                 while ((ch = lex_getch(file)) != '\n') {
215                         if (ch == '\\') {
216                                 lex_addch(ch, file);
217                                 lex_addch(lex_getch(file), file);
218                         } else {
219                                 lex_addch(ch, file);
220                         }
221                 }
222                 lex_addch('\0', file);
223                 return LEX_COMMENT;
224         }
225         
226         if (ch != '*') {
227                 lex_unget(ch, file);
228                 return '/';
229         }
230         
231         lex_addch('/', file);
232         
233         /* hate this */
234         do {
235                 lex_addch(ch, file);
236                 while ((ch = lex_getch(file)) != '*') {
237                         if (ch == EOF)
238                                 return error(ERROR_LEX, "malformatted comment"," ");
239                         else
240                                 lex_addch(ch, file);
241                 }
242                 lex_addch(ch, file);
243         } while ((ch = lex_getch(file)) != '/');
244         
245         lex_addch('/',  file);
246         lex_addch('\0', file);
247         
248         return LEX_COMMENT;
249 }
250
251 static int lex_getsource(struct lex_file *file) {
252         int ch = lex_get(file);
253         
254         /* skip char/string/comment */
255         switch (ch) {
256                 case '\'': return lex_skipchr(file);
257                 case '"':  return lex_skipstr(file);
258                 case '/':  return lex_skipcmt(file);
259                 default:   return ch;
260         }
261 }
262
263 int lex_token(struct lex_file *file) {
264         int ch = lex_getsource(file);
265         int it;
266         
267         /* valid identifier */
268         if (ch > 0 && (ch == '_' || isalpha(ch))) {
269                 lex_clear(file);
270                 while (ch > 0 && (isalpha(ch) || isdigit(ch) || ch == '_')) {
271                         lex_addch(ch, file);
272                         ch = lex_getsource(file);
273                 }
274                 lex_unget(ch,   file);
275                 lex_addch('\0', file);
276                 
277                 /* look inside the table for a keyword .. */
278                 for (it = 0; it < sizeof(lex_keywords)/sizeof(*lex_keywords); it++)
279                         if (!strncmp(file->lastok, lex_keywords[it], sizeof(lex_keywords[it])))
280                                 return it;
281                                 
282                 return LEX_IDENT;
283         }
284         return ch;
285 }
286
287 void lex_reset(struct lex_file *file) {
288         file->current = 0;
289         file->last    = 0;
290         file->length  = file->size;
291         fseek(file->file, 0, SEEK_SET);
292         
293         memset(file->peek,   0, sizeof(file->peek  ));
294         memset(file->lastok, 0, sizeof(file->lastok));
295 }
296
297 int lex_debug(struct lex_file *file) {
298         int list_do       = 0;
299         int list_else     = 0;
300         int list_if       = 0;
301         int list_while    = 0;
302         int list_break    = 0;
303         int list_continue = 0;
304         int list_return   = 0;
305         int list_goto     = 0;
306         int list_for      = 0;
307         int token         = 0;
308         printf("===========================\nTOKENS:   \n===========================\n");
309         while ((token = lex_token(file)) != ERROR_LEX && file->length >= 0) {
310                 if (token != -1) {
311                         switch (token) {
312                                 case 0: list_do      ++; break;
313                                 case 1: list_else    ++; break;
314                                 case 2: list_if      ++; break;
315                                 case 3: list_while   ++; break;
316                                 case 4: list_break   ++; break;
317                                 case 5: list_continue++; break;
318                                 case 6: list_return  ++; break;
319                                 case 7: list_goto    ++; break;
320                                 case 8: list_for     ++; break;
321                         }
322                 }
323                 if (token >= 33 && token <= 126)
324                         putchar(token);
325         }
326         printf("\n===========================\nBRANCHES \n===========================\n");
327         printf("\t if       % 8d\n", list_if);
328         printf("\t else     % 8d\n", list_else);
329         printf("===========================\nLOOPS      \n===========================\n");
330         printf("\t for      % 8d\n", list_for);
331         printf("\t while    % 8d\n", list_while);
332         printf("\t do       % 8d\n", list_do);
333         printf("===========================\nSTATEMENTS \n===========================\n");
334         printf("\t break    % 8d\n", list_break);
335         printf("\t continue % 8d\n", list_continue);
336         printf("\t return   % 8d\n", list_return);
337         printf("\t goto     % 8d\n", list_goto);
338         printf("===========================\nIDENTIFIERS\n===========================\n");
339         lex_reset(file);
340         while ((token = lex_token(file)) != ERROR_LEX && file->length >= 0)
341                 if (token == LEX_IDENT)
342                         printf("%s ", file->lastok);
343         lex_reset(file);
344         return 1;
345 }