widl: Mark non-returning functions as noreturn.
[wine] / tools / widl / widl.c
1 /*
2  * IDL Compiler
3  *
4  * Copyright 2002 Ove Kaaven
5  * based on WRC code by Bertho Stultiens
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <errno.h>
26 #include <limits.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #ifdef HAVE_UNISTD_H
30 # include <unistd.h>
31 #endif
32 #include <string.h>
33 #include <assert.h>
34 #include <ctype.h>
35 #include <signal.h>
36 #ifdef HAVE_GETOPT_H
37 # include <getopt.h>
38 #endif
39
40 #include "widl.h"
41 #include "utils.h"
42 #include "parser.h"
43 #include "wine/wpp.h"
44 #include "header.h"
45
46 /* future options to reserve characters for: */
47 /* a = alignment of structures */
48 /* A = ACF input filename */
49 /* J = do not search standard include path */
50 /* O = generate interpreted stubs */
51 /* w = select win16/win32 output (?) */
52
53 static const char usage[] =
54 "Usage: widl [options...] infile.idl\n"
55 "   or: widl [options...] --dlldata-only name1 [name2...]\n"
56 "   -c          Generate client stub\n"
57 "   -C file     Name of client stub file (default is infile_c.c)\n"
58 "   -d n        Set debug level to 'n'\n"
59 "   -D id[=val] Define preprocessor identifier id=val\n"
60 "   --dlldata=file  Name of the dlldata file (default is dlldata.c)\n"
61 "   -E          Preprocess only\n"
62 "   -h          Generate headers\n"
63 "   -H file     Name of header file (default is infile.h)\n"
64 "   -I path     Set include search dir to path (multiple -I allowed)\n"
65 "   --local-stubs=file  Write empty stubs for call_as/local methods to file\n"
66 "   -N          Do not preprocess input\n"
67 "   --oldnames  Use old naming conventions\n"
68 "   -p          Generate proxy\n"
69 "   -P file     Name of proxy file (default is infile_p.c)\n"
70 "   --prefix-all=p  Prefix names of client stubs / server functions with 'p'\n"
71 "   --prefix-client=p  Prefix names of client stubs with 'p'\n"
72 "   --prefix-server=p  Prefix names of server functions with 'p'\n"
73 "   -s          Generate server stub\n"
74 "   -S file     Name of server stub file (default is infile_s.c)\n"
75 "   -t          Generate typelib\n"
76 "   -T file     Name of typelib file (default is infile.tlb)\n"
77 "   -u          Generate interface identifiers file\n"
78 "   -U file     Name of interface identifiers file (default is infile_i.c)\n"
79 "   -V          Print version and exit\n"
80 "   -W          Enable pedantic warnings\n"
81 "Debug level 'n' is a bitmask with following meaning:\n"
82 "    * 0x01 Tell which resource is parsed (verbose mode)\n"
83 "    * 0x02 Dump internal structures\n"
84 "    * 0x04 Create a parser trace (yydebug=1)\n"
85 "    * 0x08 Preprocessor messages\n"
86 "    * 0x10 Preprocessor lex messages\n"
87 "    * 0x20 Preprocessor yacc trace\n"
88 ;
89
90 static const char version_string[] = "Wine IDL Compiler version " PACKAGE_VERSION "\n"
91                         "Copyright 2002 Ove Kaaven\n";
92
93 int win32 = 1;
94 int debuglevel = DEBUGLEVEL_NONE;
95 int parser_debug, yy_flex_debug;
96
97 int pedantic = 0;
98 int do_everything = 1;
99 int preprocess_only = 0;
100 int do_header = 0;
101 int do_typelib = 0;
102 int do_proxies = 0;
103 int do_client = 0;
104 int do_server = 0;
105 int do_idfile = 0;
106 int do_dlldata = 0;
107 int no_preprocess = 0;
108 int old_names = 0;
109
110 char *input_name;
111 char *header_name;
112 char *local_stubs_name;
113 char *header_token;
114 char *typelib_name;
115 char *dlldata_name;
116 char *proxy_name;
117 char *proxy_token;
118 char *client_name;
119 char *client_token;
120 char *server_name;
121 char *server_token;
122 char *idfile_name;
123 char *idfile_token;
124 char *temp_name;
125 const char *prefix_client = "";
126 const char *prefix_server = "";
127
128 int line_number = 1;
129
130 FILE *header;
131 FILE *local_stubs;
132 FILE *proxy;
133 FILE *idfile;
134
135 time_t now;
136
137 enum {
138     OLDNAMES_OPTION = CHAR_MAX + 1,
139     DLLDATA_OPTION,
140     DLLDATA_ONLY_OPTION,
141     LOCAL_STUBS_OPTION,
142     PREFIX_ALL_OPTION,
143     PREFIX_CLIENT_OPTION,
144     PREFIX_SERVER_OPTION
145 };
146
147 static const char short_options[] =
148     "cC:d:D:EhH:I:NpP:sS:tT:uU:VW";
149 static const struct option long_options[] = {
150     { "dlldata", 1, 0, DLLDATA_OPTION },
151     { "dlldata-only", 0, 0, DLLDATA_ONLY_OPTION },
152     { "local-stubs", 1, 0, LOCAL_STUBS_OPTION },
153     { "oldnames", 0, 0, OLDNAMES_OPTION },
154     { "prefix-all", 1, 0, PREFIX_ALL_OPTION },
155     { "prefix-client", 1, 0, PREFIX_CLIENT_OPTION },
156     { "prefix-server", 1, 0, PREFIX_SERVER_OPTION },
157     { 0, 0, 0, 0 }
158 };
159
160 static void rm_tempfile(void);
161
162 static char *make_token(const char *name)
163 {
164   char *token;
165   char *slash;
166   int i;
167
168   slash = strrchr(name, '/');
169   if(!slash)
170     slash = strrchr(name, '\\');
171
172   if (slash) name = slash + 1;
173
174   token = xstrdup(name);
175   for (i=0; token[i]; i++) {
176     if (!isalnum(token[i])) token[i] = '_';
177     else token[i] = toupper(token[i]);
178   }
179   return token;
180 }
181
182 /* duplicate a basename into a valid C token */
183 static char *dup_basename_token(const char *name, const char *ext)
184 {
185     char *p, *ret = dup_basename( name, ext );
186     /* map invalid characters to '_' */
187     for (p = ret; *p; p++) if (!isalnum(*p)) *p = '_';
188     return ret;
189 }
190
191 /* clean things up when aborting on a signal */
192 static void exit_on_signal( int sig )
193 {
194     exit(1);  /* this will call the atexit functions */
195 }
196
197 static void set_everything(int x)
198 {
199   do_header = x;
200   do_typelib = x;
201   do_proxies = x;
202   do_client = x;
203   do_server = x;
204   do_idfile = x;
205   do_dlldata = x;
206 }
207
208 static void start_cplusplus_guard(FILE *fp)
209 {
210   fprintf(fp, "#ifdef __cplusplus\n");
211   fprintf(fp, "extern \"C\" {\n");
212   fprintf(fp, "#endif\n\n");
213 }
214
215 static void end_cplusplus_guard(FILE *fp)
216 {
217   fprintf(fp, "#ifdef __cplusplus\n");
218   fprintf(fp, "}\n");
219   fprintf(fp, "#endif\n\n");
220 }
221
222 typedef struct
223 {
224   char *filename;
225   struct list link;
226 } filename_node_t;
227
228 static void add_filename_node(struct list *list, const char *name)
229 {
230   filename_node_t *node = xmalloc(sizeof *node);
231   node->filename = dup_basename( name, ".idl" );
232   list_add_tail(list, &node->link);
233 }
234
235 static void free_filename_nodes(struct list *list)
236 {
237   filename_node_t *node, *next;
238   LIST_FOR_EACH_ENTRY_SAFE(node, next, list, filename_node_t, link) {
239     list_remove(&node->link);
240     free(node->filename);
241     free(node);
242   }
243 }
244
245 static void write_dlldata_list(struct list *filenames)
246 {
247   FILE *dlldata;
248   filename_node_t *node;
249
250   dlldata = fopen(dlldata_name, "w");
251   if (!dlldata)
252     error("couldn't open %s: %s\n", dlldata_name, strerror(errno));
253
254   fprintf(dlldata, "/*** Autogenerated by WIDL %s ", PACKAGE_VERSION);
255   fprintf(dlldata, "- Do not edit ***/\n\n");
256   fprintf(dlldata, "#include <objbase.h>\n");
257   fprintf(dlldata, "#include <rpcproxy.h>\n\n");
258   start_cplusplus_guard(dlldata);
259
260   LIST_FOR_EACH_ENTRY(node, filenames, filename_node_t, link)
261     fprintf(dlldata, "EXTERN_PROXY_FILE(%s)\n", node->filename);
262
263   fprintf(dlldata, "\nPROXYFILE_LIST_START\n");
264   fprintf(dlldata, "/* Start of list */\n");
265   LIST_FOR_EACH_ENTRY(node, filenames, filename_node_t, link)
266     fprintf(dlldata, "  REFERENCE_PROXY_FILE(%s),\n", node->filename);
267   fprintf(dlldata, "/* End of list */\n");
268   fprintf(dlldata, "PROXYFILE_LIST_END\n\n");
269
270   fprintf(dlldata, "DLLDATA_ROUTINES(aProxyFileList, GET_DLL_CLSID)\n\n");
271   end_cplusplus_guard(dlldata);
272   fclose(dlldata);
273 }
274
275 static char *eat_space(char *s)
276 {
277   while (isspace((unsigned char) *s))
278     ++s;
279   return s;
280 }
281
282 void write_dlldata(const statement_list_t *stmts)
283 {
284   struct list filenames = LIST_INIT(filenames);
285   filename_node_t *node;
286   FILE *dlldata;
287
288   if (!do_dlldata || !need_proxy_file(stmts))
289     return;
290
291   dlldata = fopen(dlldata_name, "r");
292   if (dlldata) {
293     static char marker[] = "REFERENCE_PROXY_FILE";
294     char *line = NULL;
295     size_t len = 0;
296
297     while (widl_getline(&line, &len, dlldata)) {
298       char *start, *end;
299       start = eat_space(line);
300       if (strncmp(start, marker, sizeof marker - 1) == 0) {
301         start = eat_space(start + sizeof marker - 1);
302         if (*start != '(')
303           continue;
304         end = start = eat_space(start + 1);
305         while (*end && *end != ')')
306           ++end;
307         if (*end != ')')
308           continue;
309         while (isspace((unsigned char) end[-1]))
310           --end;
311         *end = '\0';
312         if (start < end)
313           add_filename_node(&filenames, start);
314       }
315     }
316
317     if (ferror(dlldata))
318       error("couldn't read from %s: %s\n", dlldata_name, strerror(errno));
319
320     free(line);
321     fclose(dlldata);
322   }
323
324   LIST_FOR_EACH_ENTRY(node, &filenames, filename_node_t, link)
325     if (strcmp(proxy_token, node->filename) == 0) {
326       /* We're already in the list, no need to regenerate this file.  */
327       free_filename_nodes(&filenames);
328       return;
329     }
330
331   add_filename_node(&filenames, proxy_token);
332   write_dlldata_list(&filenames);
333   free_filename_nodes(&filenames);
334 }
335
336 int main(int argc,char *argv[])
337 {
338   extern char* optarg;
339   extern int   optind;
340   int optc;
341   int ret = 0;
342   int opti = 0;
343
344   signal( SIGTERM, exit_on_signal );
345   signal( SIGINT, exit_on_signal );
346 #ifdef SIGHUP
347   signal( SIGHUP, exit_on_signal );
348 #endif
349
350   now = time(NULL);
351
352   while((optc = getopt_long(argc, argv, short_options, long_options, &opti)) != EOF) {
353     switch(optc) {
354     case DLLDATA_OPTION:
355       dlldata_name = xstrdup(optarg);
356       break;
357     case DLLDATA_ONLY_OPTION:
358       do_everything = 0;
359       do_dlldata = 1;
360       break;
361     case LOCAL_STUBS_OPTION:
362       do_everything = 0;
363       local_stubs_name = xstrdup(optarg);
364       break;
365     case OLDNAMES_OPTION:
366       old_names = 1;
367       break;
368     case PREFIX_ALL_OPTION:
369       prefix_client = xstrdup(optarg);
370       prefix_server = xstrdup(optarg);
371       break;
372     case PREFIX_CLIENT_OPTION:
373       prefix_client = xstrdup(optarg);
374       break;
375     case PREFIX_SERVER_OPTION:
376       prefix_server = xstrdup(optarg);
377       break;
378     case 'c':
379       do_everything = 0;
380       do_client = 1;
381       break;
382     case 'C':
383       client_name = xstrdup(optarg);
384       break;
385     case 'd':
386       debuglevel = strtol(optarg, NULL, 0);
387       break;
388     case 'D':
389       wpp_add_cmdline_define(optarg);
390       break;
391     case 'E':
392       do_everything = 0;
393       preprocess_only = 1;
394       break;
395     case 'h':
396       do_everything = 0;
397       do_header = 1;
398       break;
399     case 'H':
400       header_name = xstrdup(optarg);
401       break;
402     case 'I':
403       wpp_add_include_path(optarg);
404       break;
405     case 'N':
406       no_preprocess = 1;
407       break;
408     case 'p':
409       do_everything = 0;
410       do_proxies = 1;
411       break;
412     case 'P':
413       proxy_name = xstrdup(optarg);
414       break;
415     case 's':
416       do_everything = 0;
417       do_server = 1;
418       break;
419     case 'S':
420       server_name = xstrdup(optarg);
421       break;
422     case 't':
423       do_everything = 0;
424       do_typelib = 1;
425       break;
426     case 'T':
427       typelib_name = xstrdup(optarg);
428       break;
429     case 'u':
430       do_everything = 0;
431       do_idfile = 1;
432       break;
433     case 'U':
434       idfile_name = xstrdup(optarg);
435       break;
436     case 'V':
437       printf("%s", version_string);
438       return 0;
439     case 'W':
440       pedantic = 1;
441       break;
442     default:
443       fprintf(stderr, "%s", usage);
444       return 1;
445     }
446   }
447
448   if(do_everything) {
449     set_everything(TRUE);
450   }
451
452   if (!dlldata_name && do_dlldata)
453     dlldata_name = xstrdup("dlldata.c");
454
455   if(optind < argc) {
456     if (do_dlldata && !do_everything) {
457       struct list filenames = LIST_INIT(filenames);
458       for ( ; optind < argc; ++optind)
459         add_filename_node(&filenames, argv[optind]);
460
461       write_dlldata_list(&filenames);
462       free_filename_nodes(&filenames);
463       return 0;
464     }
465     else if (optind != argc - 1) {
466       fprintf(stderr, "%s", usage);
467       return 1;
468     }
469     else
470       input_name = xstrdup(argv[optind]);
471   }
472   else {
473     fprintf(stderr, "%s", usage);
474     return 1;
475   }
476
477   if(debuglevel)
478   {
479     setbuf(stdout,0);
480     setbuf(stderr,0);
481   }
482
483   parser_debug = debuglevel & DEBUGLEVEL_TRACE ? 1 : 0;
484   yy_flex_debug = debuglevel & DEBUGLEVEL_TRACE ? 1 : 0;
485
486   wpp_set_debug( (debuglevel & DEBUGLEVEL_PPLEX) != 0,
487                  (debuglevel & DEBUGLEVEL_PPTRACE) != 0,
488                  (debuglevel & DEBUGLEVEL_PPMSG) != 0 );
489
490   if (!header_name) {
491     header_name = dup_basename(input_name, ".idl");
492     strcat(header_name, ".h");
493   }
494
495   if (!typelib_name && do_typelib) {
496     typelib_name = dup_basename(input_name, ".idl");
497     strcat(typelib_name, ".tlb");
498   }
499
500   if (!proxy_name && do_proxies) {
501     proxy_name = dup_basename(input_name, ".idl");
502     strcat(proxy_name, "_p.c");
503   }
504
505   if (!client_name && do_client) {
506     client_name = dup_basename(input_name, ".idl");
507     strcat(client_name, "_c.c");
508   }
509
510   if (!server_name && do_server) {
511     server_name = dup_basename(input_name, ".idl");
512     strcat(server_name, "_s.c");
513   }
514
515   if (!idfile_name && do_idfile) {
516     idfile_name = dup_basename(input_name, ".idl");
517     strcat(idfile_name, "_i.c");
518   }
519
520   if (do_proxies) proxy_token = dup_basename_token(proxy_name,"_p.c");
521   if (do_client) client_token = dup_basename_token(client_name,"_c.c");
522   if (do_server) server_token = dup_basename_token(server_name,"_s.c");
523
524   wpp_add_cmdline_define("__WIDL__");
525
526   atexit(rm_tempfile);
527   if (!no_preprocess)
528   {
529     chat("Starting preprocess\n");
530
531     if (!preprocess_only)
532     {
533         ret = wpp_parse_temp( input_name, header_name, &temp_name );
534     }
535     else
536     {
537         ret = wpp_parse( input_name, stdout );
538     }
539
540     if(ret) exit(1);
541     if(preprocess_only) exit(0);
542     if(!(parser_in = fopen(temp_name, "r"))) {
543       fprintf(stderr, "Could not open %s for input\n", temp_name);
544       return 1;
545     }
546   }
547   else {
548     if(!(parser_in = fopen(input_name, "r"))) {
549       fprintf(stderr, "Could not open %s for input\n", input_name);
550       return 1;
551     }
552   }
553
554   if(do_header) {
555     header_token = make_token(header_name);
556
557     if(!(header = fopen(header_name, "w"))) {
558       fprintf(stderr, "Could not open %s for output\n", header_name);
559       return 1;
560     }
561     fprintf(header, "/*** Autogenerated by WIDL %s from %s - Do not edit ***/\n", PACKAGE_VERSION, input_name);
562     fprintf(header, "#include <rpc.h>\n" );
563     fprintf(header, "#include <rpcndr.h>\n\n" );
564     fprintf(header, "#ifndef __WIDL_%s\n", header_token);
565     fprintf(header, "#define __WIDL_%s\n", header_token);
566     start_cplusplus_guard(header);
567   }
568
569   if (local_stubs_name) {
570     local_stubs = fopen(local_stubs_name, "w");
571     if (!local_stubs) {
572       fprintf(stderr, "Could not open %s for output\n", local_stubs_name);
573       return 1;
574     }
575     fprintf(local_stubs, "/* call_as/local stubs for %s */\n\n", input_name);
576     fprintf(local_stubs, "#include <objbase.h>\n");
577     fprintf(local_stubs, "#include \"%s\"\n\n", header_name);
578   }
579
580   if (do_idfile) {
581     idfile_token = make_token(idfile_name);
582
583     idfile = fopen(idfile_name, "w");
584     if (! idfile) {
585       fprintf(stderr, "Could not open %s for output\n", idfile_name);
586       return 1;
587     }
588
589     fprintf(idfile, "/*** Autogenerated by WIDL %s ", PACKAGE_VERSION);
590     fprintf(idfile, "from %s - Do not edit ***/\n\n", input_name);
591     fprintf(idfile, "#include <rpc.h>\n");
592     fprintf(idfile, "#include <rpcndr.h>\n\n");
593     fprintf(idfile, "#include <initguid.h>\n\n");
594     start_cplusplus_guard(idfile);
595   }
596
597   init_types();
598   ret = parser_parse();
599
600   if(do_header) {
601     fprintf(header, "/* Begin additional prototypes for all interfaces */\n");
602     fprintf(header, "\n");
603     write_user_types();
604     write_generic_handle_routines();
605     write_context_handle_rundowns();
606     fprintf(header, "\n");
607     fprintf(header, "/* End additional prototypes */\n");
608     fprintf(header, "\n");
609     end_cplusplus_guard(header);
610     fprintf(header, "#endif /* __WIDL_%s */\n", header_token);
611     fclose(header);
612   }
613
614   if (local_stubs) {
615     fclose(local_stubs);
616   }
617
618   if (do_idfile) {
619     fprintf(idfile, "\n");
620     end_cplusplus_guard(idfile);
621
622     fclose(idfile);
623   }
624
625   fclose(parser_in);
626
627   if(ret) {
628     exit(1);
629   }
630
631   /* Everything has been done successfully, don't delete any files.  */
632   set_everything(FALSE);
633   local_stubs_name = NULL;
634
635   return 0;
636 }
637
638 static void rm_tempfile(void)
639 {
640   abort_import();
641   if(temp_name)
642     unlink(temp_name);
643   if (do_header)
644     unlink(header_name);
645   if (local_stubs_name)
646     unlink(local_stubs_name);
647   if (do_client)
648     unlink(client_name);
649   if (do_server)
650     unlink(server_name);
651   if (do_idfile)
652     unlink(idfile_name);
653   if (do_proxies)
654     unlink(proxy_name);
655   if (do_typelib)
656     unlink(typelib_name);
657 }