Prevent crash when no URL is specified.
[wine] / tools / widl / parser.l
1 /*
2  * IDL Compiler
3  *
4  * Copyright 2002 Ove Kaaven
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20
21 %option stack
22 %option never-interactive
23
24 nl      \r?\n
25 ws      [ \f\t\r]
26 cident  [a-zA-Z_][0-9a-zA-Z_]*
27 int     [0-9]+
28 hexd    [0-9a-fA-F]
29 hex     0x{hexd}+
30 uuid    {hexd}{8}-{hexd}{4}-{hexd}{4}-{hexd}{4}-{hexd}{12}
31
32 %x QUOTE
33 %x pp_line
34
35 %{
36
37 #include "config.h"
38
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <string.h>
42 #include <ctype.h>
43 #include <assert.h>
44 #ifdef HAVE_UNISTD_H
45 # include <unistd.h>
46 #endif
47
48 #include "widl.h"
49 #include "utils.h"
50 #include "parser.h"
51 #include "wine/wpp.h"
52
53 #include "y.tab.h"
54
55 #define YY_USE_PROTOS
56 #define YY_NO_UNPUT
57 #define YY_NO_TOP_STATE
58
59 extern char *temp_name;
60
61 static void addcchar(char c);
62 static char *get_buffered_cstring(void);
63
64 static char *cbuffer;
65 static int cbufidx;
66 static int cbufalloc = 0;
67
68 static int kw_token(const char *kw);
69
70 #define MAX_IMPORT_DEPTH 10
71 struct {
72   YY_BUFFER_STATE state;
73   char *input_name;
74   int   line_number;
75   char *temp_name;
76 } import_stack[MAX_IMPORT_DEPTH];
77 int import_stack_ptr = 0;
78
79 static void pop_import(void);
80
81 static UUID* parse_uuid(const char*u)
82 {
83   UUID* uuid = xmalloc(sizeof(UUID));
84   char b[3];
85   /* it would be nice to use UuidFromStringA */
86   uuid->Data1 = strtoul(u, NULL, 16);
87   uuid->Data2 = strtoul(u+9, NULL, 16);
88   uuid->Data3 = strtoul(u+14, NULL, 16);
89   b[2] = 0;
90   memcpy(b, u+19, 2); uuid->Data4[0] = strtoul(b, NULL, 16);
91   memcpy(b, u+21, 2); uuid->Data4[1] = strtoul(b, NULL, 16);
92   memcpy(b, u+24, 2); uuid->Data4[2] = strtoul(b, NULL, 16);
93   memcpy(b, u+26, 2); uuid->Data4[3] = strtoul(b, NULL, 16);
94   memcpy(b, u+28, 2); uuid->Data4[4] = strtoul(b, NULL, 16);
95   memcpy(b, u+30, 2); uuid->Data4[5] = strtoul(b, NULL, 16);
96   memcpy(b, u+32, 2); uuid->Data4[6] = strtoul(b, NULL, 16);
97   memcpy(b, u+34, 2); uuid->Data4[7] = strtoul(b, NULL, 16);
98   return uuid;
99 }
100
101 %}
102
103 /*
104  **************************************************************************
105  * The flexer starts here
106  **************************************************************************
107  */
108 %%
109 <INITIAL>^{ws}*\#{ws}*  yy_push_state(pp_line);
110 <pp_line>[^\n]*         {
111                             int lineno;
112                             char *cptr, *fname;
113                             yy_pop_state();
114                             lineno = (int)strtol(yytext, &cptr, 10);
115                             if(!lineno)
116                                 yyerror("Malformed '#...' line-directive; invalid linenumber");
117                             fname = strchr(cptr, '"');
118                             if(!fname)
119                                 yyerror("Malformed '#...' line-directive; missing filename");
120                             fname++;
121                             cptr = strchr(fname, '"');
122                             if(!cptr)
123                                 yyerror("Malformed '#...' line-directive; missing terminating \"");
124                             *cptr = '\0';
125                             line_number = lineno - 1;  /* We didn't read the newline */
126                             free( input_name );
127                             input_name = xstrdup(fname);
128                         }
129 \"                      yy_push_state(QUOTE); cbufidx = 0;
130 <QUOTE>\"               {
131                                 yy_pop_state();
132                                 yylval.str = get_buffered_cstring();
133                                 return aSTRING;
134                         }
135 <QUOTE>\\\\             |
136 <QUOTE>\\\"             addcchar(yytext[1]);
137 <QUOTE>\\.              addcchar('\\'); addcchar(yytext[1]);
138 <QUOTE>.                addcchar(yytext[0]);
139 {uuid}                  {
140                                 yylval.uuid = parse_uuid(yytext);
141                                 return aUUID;
142                         }
143 {hex}                   {
144                                 yylval.num = strtoul(yytext, NULL, 0);
145                                 return aHEXNUM;
146                         }
147 {int}                   {
148                                 yylval.num = strtoul(yytext, NULL, 0);
149                                 return aNUM;
150                         }
151 {cident}                return kw_token(yytext);
152 \n                      line_number++;
153 {ws}
154 \<\<                    return SHL;
155 \>\>                    return SHR;
156 .                       return yytext[0];
157 <<EOF>>                 {
158                                 if (import_stack_ptr) {
159                                         pop_import();
160                                         return aEOF;
161                                 }
162                                 else yyterminate();
163                         }
164 %%
165
166 #ifndef yywrap
167 int yywrap(void)
168 {
169         return 1;
170 }
171 #endif
172
173 static struct keyword {
174         const char *kw;
175         int token;
176         int val;
177 } keywords[] = {
178         {"__cdecl",                     tCDECL},
179         {"__int64",                     tINT64},
180         {"__stdcall",                   tSTDCALL},
181         {"_stdcall",                    tSTDCALL},
182         {"aggregatable",                tAGGREGATABLE},
183         {"allocate",                    tALLOCATE},
184         {"appobject",                   tAPPOBJECT},
185         {"arrays",                      tARRAYS},
186         {"async",                       tASYNC},
187         {"async_uuid",                  tASYNCUUID},
188         {"auto_handle",                 tAUTOHANDLE},
189         {"bindable",                    tBINDABLE},
190         {"boolean",                     tBOOLEAN},
191         {"broadcast",                   tBROADCAST},
192         {"byte",                        tBYTE},
193         {"byte_count",                  tBYTECOUNT},
194         {"call_as",                     tCALLAS},
195         {"callback",                    tCALLBACK},
196         {"case",                        tCASE},
197         {"char",                        tCHAR},
198         {"coclass",                     tCOCLASS},
199         {"code",                        tCODE},
200         {"comm_status",                 tCOMMSTATUS},
201         {"const",                       tCONST},
202         {"context_handle",              tCONTEXTHANDLE},
203         {"context_handle_noserialize",  tCONTEXTHANDLENOSERIALIZE},
204         {"context_handle_serialize",    tCONTEXTHANDLENOSERIALIZE},
205         {"control",                     tCONTROL},
206         {"cpp_quote",                   tCPPQUOTE},
207 /* ... */
208         {"default",                     tDEFAULT},
209         {"defaultvalue",                tDEFAULTVALUE},
210 /* ... */
211         {"dispinterface",               tDISPINTERFACE},
212 /* ... */
213         {"dllname",                     tDLLNAME},
214         {"double",                      tDOUBLE},
215         {"dual",                        tDUAL},
216 /* ... */
217         {"endpoint",                    tENDPOINT},
218         {"entry",                       tENTRY},
219         {"enum",                        tENUM},
220         {"error_status_t",              tERRORSTATUST},
221         {"explicit_handle",             tEXPLICITHANDLE},
222         {"extern",                      tEXTERN},
223 /* ... */
224         {"float",                       tFLOAT},
225 /* ... */
226         {"handle",                      tHANDLE},
227         {"handle_t",                    tHANDLET},
228 /* ... */
229         {"helpcontext",                 tHELPCONTEXT},
230         {"helpfile",                    tHELPFILE},
231         {"helpstring",                  tHELPSTRING},
232         {"helpstringcontext",           tHELPSTRINGCONTEXT},
233         {"helpstringdll",               tHELPSTRINGDLL},
234 /* ... */
235         {"hidden",                      tHIDDEN},
236         {"hyper",                       tHYPER},
237         {"id",                          tID},
238         {"idempotent",                  tIDEMPOTENT},
239 /* ... */
240         {"iid_is",                      tIIDIS},
241 /* ... */
242         {"implicit_handle",             tIMPLICITHANDLE},
243         {"import",                      tIMPORT},
244         {"importlib",                   tIMPORTLIB},
245         {"in",                          tIN},
246         {"include",                     tINCLUDE},
247         {"in_line",                     tINLINE},
248         {"input_sync",                  tINPUTSYNC},
249         {"int",                         tINT},
250 /* ... */
251         {"interface",                   tINTERFACE},
252 /* ... */
253         {"length_is",                   tLENGTHIS},
254         {"library",                     tLIBRARY},
255 /* ... */
256         {"local",                       tLOCAL},
257         {"long",                        tLONG},
258 /* ... */
259         {"methods",                     tMETHODS},
260 /* ... */
261         {"module",                      tMODULE},
262 /* ... */
263         {"noncreatable",                tNONCREATABLE},
264         {"object",                      tOBJECT},
265         {"odl",                         tODL},
266         {"oleautomation",               tOLEAUTOMATION},
267 /* ... */
268         {"optional",                    tOPTIONAL},
269         {"out",                         tOUT},
270 /* ... */
271         {"pointer_default",             tPOINTERDEFAULT},
272 /* ... */
273         {"properties",                  tPROPERTIES},
274         {"propget",                     tPROPGET},
275         {"propput",                     tPROPPUT},
276         {"propputref",                  tPROPPUTREF},
277 /* ... */
278         {"public",                      tPUBLIC},
279 /* ... */
280         {"readonly",                    tREADONLY},
281         {"ref",                         tREF},
282 /* ... */
283         {"restricted",                  tRESTRICTED},
284         {"retval",                      tRETVAL},
285 /* ... */
286         {"short",                       tSHORT},
287         {"signed",                      tSIGNED},
288         {"size_is",                     tSIZEIS},
289         {"sizeof",                      tSIZEOF},
290 /* ... */
291         {"source",                      tSOURCE},
292 /* ... */       
293         {"string",                      tSTRING},
294         {"struct",                      tSTRUCT},
295         {"switch",                      tSWITCH},
296         {"switch_is",                   tSWITCHIS},
297         {"switch_type",                 tSWITCHTYPE},
298 /* ... */
299         {"transmit_as",                 tTRANSMITAS},
300         {"typedef",                     tTYPEDEF},
301         {"union",                       tUNION},
302 /* ... */
303         {"unique",                      tUNIQUE},
304         {"unsigned",                    tUNSIGNED},
305 /* ... */
306         {"uuid",                        tUUID},
307         {"v1_enum",                     tV1ENUM},
308 /* ... */
309         {"vararg",                      tVARARG},
310         {"version",                     tVERSION},
311         {"void",                        tVOID},
312         {"wchar_t",                     tWCHAR},
313         {"wire_marshal",                tWIREMARSHAL}
314 };
315 #define NKEYWORDS (sizeof(keywords)/sizeof(keywords[0]))
316 #define KWP(p) ((const struct keyword *)(p))
317
318 static int kw_cmp_func(const void *s1, const void *s2)
319 {
320         return strcmp(KWP(s1)->kw, KWP(s2)->kw);
321 }
322
323 #define KW_BSEARCH
324 static int kw_token(const char *kw)
325 {
326         struct keyword key, *kwp;
327         key.kw = kw;
328 #ifdef KW_BSEARCH
329         kwp = bsearch(&key, keywords, NKEYWORDS, sizeof(keywords[0]), kw_cmp_func);
330 #else
331         {
332                 int i;
333                 for (kwp=NULL, i=0; i < NKEYWORDS; i++)
334                         if (!kw_cmp_func(&key, &keywords[i])) {
335                                 kwp = &keywords[i];
336                                 break;
337                         }
338         }
339 #endif
340         if (kwp) {
341                 yylval.str = (char*)kwp->kw;
342                 return kwp->token;
343         }
344         yylval.str = xstrdup(kw);
345         return is_type(kw) ? aKNOWNTYPE : aIDENTIFIER;
346 }
347
348 static void addcchar(char c)
349 {
350         if(cbufidx >= cbufalloc)
351         {
352                 cbufalloc += 1024;
353                 cbuffer = xrealloc(cbuffer, cbufalloc * sizeof(cbuffer[0]));
354                 if(cbufalloc > 65536)
355                         yywarning("Reallocating string buffer larger than 64kB");
356         }
357         cbuffer[cbufidx++] = c;
358 }
359
360 static char *get_buffered_cstring(void)
361 {
362         addcchar(0);
363         return xstrdup(cbuffer);
364 }
365
366 static void pop_import(void)
367 {
368         int ptr = import_stack_ptr-1;
369
370         fclose(yyin);
371         yy_delete_buffer( YY_CURRENT_BUFFER );
372         yy_switch_to_buffer( import_stack[ptr].state );
373         if (temp_name) {
374                 unlink(temp_name);
375                 free(temp_name);
376         }
377         temp_name = import_stack[ptr].temp_name;
378         free( input_name );
379         input_name = import_stack[ptr].input_name;
380         line_number = import_stack[ptr].line_number;
381         import_stack_ptr--;
382 }
383
384 struct imports {
385         char *name;
386         struct imports *next;
387 } *first_import;
388
389 int do_import(char *fname)
390 {
391         FILE *f;
392         char *hname, *path, *p;
393         struct imports *import;
394         int ptr = import_stack_ptr;
395         int ret;
396
397         if (!parse_only && do_header) {
398                 hname = dup_basename(fname, ".idl");
399                 p = hname + strlen(hname) - 2;
400                 if (p <= hname || strcmp( p, ".h" )) strcat(hname, ".h");
401
402                 fprintf(header, "#include <%s>\n", hname);
403                 free(hname);
404         }
405
406         import = first_import;
407         while (import && strcmp(import->name, fname))
408                 import = import->next;
409         if (import) return 0; /* already imported */
410
411         import = xmalloc(sizeof(struct imports));
412         import->name = xstrdup(fname);
413         import->next = first_import;
414         first_import = import;
415
416         if (!(path = wpp_find_include( fname, 1 )))
417             yyerror("Unable to open include file %s", fname);
418
419         import_stack[ptr].temp_name = temp_name;
420         import_stack[ptr].input_name = input_name;
421         import_stack[ptr].line_number = line_number;
422         import_stack_ptr++;
423         input_name = path;
424         line_number = 1;
425
426         ret = wpp_parse_temp( path, NULL, &temp_name );
427         if (ret) exit(1);
428
429         if((f = fopen(temp_name, "r")) == NULL)
430                 yyerror("Unable to open %s", temp_name);
431
432         import_stack[ptr].state = YY_CURRENT_BUFFER;
433         yy_switch_to_buffer(yy_create_buffer(f, YY_BUF_SIZE));
434         return 1;
435 }
436
437 void abort_import(void)
438 {
439         int ptr;
440
441         for (ptr=0; ptr<import_stack_ptr; ptr++)
442                 unlink(import_stack[ptr].temp_name);
443 }