blob: 3f085aea98647ea741d199047a880edd56b2cac7 [file] [log] [blame]
David Reissea2cba82009-03-30 21:35:00 +00001/*
2 * Licensed to the Apache Software Foundation (ASF) under one
3 * or more contributor license agreements. See the NOTICE file
4 * distributed with this work for additional information
5 * regarding copyright ownership. The ASF licenses this file
6 * to you under the Apache License, Version 2.0 (the
7 * "License"); you may not use this file except in compliance
8 * with the License. You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing,
13 * software distributed under the License is distributed on an
14 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 * KIND, either express or implied. See the License for the
16 * specific language governing permissions and limitations
17 * under the License.
18 */
Mark Sleee9ce01c2007-05-16 02:29:53 +000019
Mark Slee31985722006-05-24 21:45:31 +000020/**
21 * thrift - a lightweight cross-language rpc/serialization tool
22 *
23 * This file contains the main compiler engine for Thrift, which invokes the
24 * scanner/parser to build the thrift object tree. The interface generation
Mark Sleef5377b32006-10-10 01:42:59 +000025 * code for each language lives in a file by the language name under the
26 * generate/ folder, and all parse structures live in parse/
Mark Slee31985722006-05-24 21:45:31 +000027 *
Mark Slee31985722006-05-24 21:45:31 +000028 */
29
David Reissf10984b2008-03-27 21:39:52 +000030#include <cassert>
Mark Slee31985722006-05-24 21:45:31 +000031#include <stdlib.h>
32#include <stdio.h>
33#include <stdarg.h>
David Reiss5ad12602010-08-31 16:51:30 +000034#include <time.h>
Mark Slee31985722006-05-24 21:45:31 +000035#include <string>
David Reiss739cbe22008-04-15 05:44:00 +000036#include <algorithm>
Mark Sleef0712dc2006-10-25 19:03:57 +000037#include <sys/types.h>
38#include <sys/stat.h>
dweatherford65b70752007-10-31 02:18:14 +000039#include <errno.h>
David Reissab55ed52008-06-11 01:17:00 +000040#include <limits.h>
Mark Slee31985722006-05-24 21:45:31 +000041
David Reiss204420f2008-01-11 20:59:03 +000042#ifdef MINGW
43# include <windows.h> /* for GetFullPathName */
David Reiss204420f2008-01-11 20:59:03 +000044#endif
45
Mark Sleef0712dc2006-10-25 19:03:57 +000046// Careful: must include globals first for extern definitions
Mark Slee31985722006-05-24 21:45:31 +000047#include "globals.h"
48
49#include "main.h"
50#include "parse/t_program.h"
Mark Sleef0712dc2006-10-25 19:03:57 +000051#include "parse/t_scope.h"
David Reissbbbbe882009-02-17 20:27:48 +000052#include "generate/t_generator.h"
Mark Slee31985722006-05-24 21:45:31 +000053
David Reissdd08f6d2008-06-30 20:24:24 +000054#include "version.h"
55
Mark Slee31985722006-05-24 21:45:31 +000056using namespace std;
57
Mark Sleef5377b32006-10-10 01:42:59 +000058/**
59 * Global program tree
60 */
Mark Slee31985722006-05-24 21:45:31 +000061t_program* g_program;
62
Mark Sleef5377b32006-10-10 01:42:59 +000063/**
Mark Sleef0712dc2006-10-25 19:03:57 +000064 * Global types
65 */
66
67t_type* g_type_void;
68t_type* g_type_string;
Mark Slee8d725a22007-04-13 01:57:12 +000069t_type* g_type_binary;
Mark Sleeb6200d82007-01-19 19:14:36 +000070t_type* g_type_slist;
Mark Sleef0712dc2006-10-25 19:03:57 +000071t_type* g_type_bool;
72t_type* g_type_byte;
73t_type* g_type_i16;
74t_type* g_type_i32;
75t_type* g_type_i64;
76t_type* g_type_double;
77
78/**
79 * Global scope
80 */
81t_scope* g_scope;
82
83/**
84 * Parent scope to also parse types
85 */
86t_scope* g_parent_scope;
87
88/**
89 * Prefix for putting types in parent scope
90 */
91string g_parent_prefix;
92
93/**
94 * Parsing pass
95 */
96PARSE_MODE g_parse_mode;
97
98/**
99 * Current directory of file being parsed
100 */
101string g_curdir;
102
103/**
104 * Current file being parsed
105 */
106string g_curpath;
107
108/**
Martin Kraemer32c66e12006-11-09 00:06:36 +0000109 * Search path for inclusions
110 */
Mark Slee2329a832006-11-09 00:23:30 +0000111vector<string> g_incl_searchpath;
Martin Kraemer32c66e12006-11-09 00:06:36 +0000112
113/**
kholst76f2c882008-01-16 02:47:41 +0000114 * Should C++ include statements use path prefixes for other thrift-generated
115 * header files
116 */
117bool g_cpp_use_include_prefix = false;
118
119/**
Mark Sleef5377b32006-10-10 01:42:59 +0000120 * Global debug state
121 */
Mark Slee31985722006-05-24 21:45:31 +0000122int g_debug = 0;
123
Mark Sleef5377b32006-10-10 01:42:59 +0000124/**
Bryan Duxburya145b4d2009-04-03 17:29:25 +0000125 * Strictness level
126 */
127int g_strict = 127;
128
129/**
Mark Sleef0712dc2006-10-25 19:03:57 +0000130 * Warning level
131 */
132int g_warn = 1;
133
134/**
135 * Verbose output
136 */
137int g_verbose = 0;
138
139/**
Mark Sleef5377b32006-10-10 01:42:59 +0000140 * Global time string
141 */
Mark Slee31985722006-05-24 21:45:31 +0000142char* g_time_str;
143
Mark Slee31985722006-05-24 21:45:31 +0000144/**
David Reisscbd4bac2007-08-14 17:12:33 +0000145 * The last parsed doctext comment.
146 */
147char* g_doctext;
148
149/**
150 * The location of the last parsed doctext comment.
151 */
152int g_doctext_lineno;
153
154/**
Bryan Duxburyc7206a42011-08-17 23:17:04 +0000155 * Whether or not negative field keys are accepted.
156 */
157int g_allow_neg_field_keys;
158
159/**
Roger Meier887ff752011-08-19 11:25:39 +0000160 * Whether or not 64-bit constants will generate a warning.
161 */
162int g_allow_64bit_consts = 0;
163
164/**
Mark Sleef0712dc2006-10-25 19:03:57 +0000165 * Flags to control code generation
166 */
167bool gen_cpp = false;
David Reiss6495adb2007-12-18 03:37:30 +0000168bool gen_dense = false;
Mark Sleef0712dc2006-10-25 19:03:57 +0000169bool gen_java = false;
Mark Slee01a9f882007-08-31 00:55:28 +0000170bool gen_javabean = false;
Mark Slee6d7d5952007-01-27 01:44:22 +0000171bool gen_rb = false;
Mark Sleef0712dc2006-10-25 19:03:57 +0000172bool gen_py = false;
David Reiss6495adb2007-12-18 03:37:30 +0000173bool gen_py_newstyle = false;
Mark Slee0e0ff7e2007-01-18 22:59:59 +0000174bool gen_xsd = false;
Mark Sleef0712dc2006-10-25 19:03:57 +0000175bool gen_php = false;
176bool gen_phpi = false;
Mark Slee5b743072007-11-13 04:00:29 +0000177bool gen_phps = true;
Mark Slee09f69e02007-11-17 00:32:36 +0000178bool gen_phpa = false;
Mark Sleeb22df7c2007-11-28 02:39:59 +0000179bool gen_phpo = false;
Mark Slee756b1d12007-07-06 00:30:21 +0000180bool gen_rest = false;
Mark Slee2c44d202007-05-16 02:18:07 +0000181bool gen_perl = false;
David Reiss9f2a5d72008-06-11 01:15:45 +0000182bool gen_erl = false;
Christopher Pirob97b89d2007-09-18 00:07:42 +0000183bool gen_ocaml = false;
iproctorff8eb922007-07-25 19:06:13 +0000184bool gen_hs = false;
Mark Slee7e9eea42007-09-10 21:00:23 +0000185bool gen_cocoa = false;
David Reiss7f42bcf2008-01-11 20:59:12 +0000186bool gen_csharp = false;
Jake Farrell7ae13e12011-10-18 14:35:26 +0000187bool gen_delphi = false;
Mark Sleeefd37f12007-11-20 05:13:09 +0000188bool gen_st = false;
Mark Sleef0712dc2006-10-25 19:03:57 +0000189bool gen_recurse = false;
190
191/**
David Reiss204420f2008-01-11 20:59:03 +0000192 * MinGW doesn't have realpath, so use fallback implementation in that case,
193 * otherwise this just calls through to realpath
194 */
195char *saferealpath(const char *path, char *resolved_path) {
196#ifdef MINGW
197 char buf[MAX_PATH];
198 char* basename;
199 DWORD len = GetFullPathName(path, MAX_PATH, buf, &basename);
200 if (len == 0 || len > MAX_PATH - 1){
201 strcpy(resolved_path, path);
202 } else {
David Reiss204420f2008-01-11 20:59:03 +0000203 strcpy(resolved_path, buf);
204 }
Bryan Duxbury0137af62010-04-22 21:21:46 +0000205
206 // Replace backslashes with forward slashes so the
207 // rest of the code behaves correctly.
208 size_t resolved_len = strlen(resolved_path);
209 for (size_t i = 0; i < resolved_len; i++) {
210 if (resolved_path[i] == '\\') {
211 resolved_path[i] = '/';
212 }
213 }
David Reiss204420f2008-01-11 20:59:03 +0000214 return resolved_path;
215#else
216 return realpath(path, resolved_path);
217#endif
218}
219
Roger Meier061d4a22012-10-07 11:51:00 +0000220bool check_is_directory(const char *dir_name) {
221#ifdef MINGW
222 DWORD attributes = ::GetFileAttributesA(dir_name);
223 if(attributes == INVALID_FILE_ATTRIBUTES) {
224 fprintf(stderr, "Output directory %s is unusable: GetLastError() = %ld\n", dir_name, GetLastError());
225 return false;
226 }
227 if((attributes & FILE_ATTRIBUTE_DIRECTORY) != FILE_ATTRIBUTE_DIRECTORY) {
228 fprintf(stderr, "Output directory %s exists but is not a directory\n", dir_name);
229 return false;
230 }
231 return true;
232#else
233 struct stat sb;
234 if (stat(dir_name, &sb) < 0) {
235 fprintf(stderr, "Output directory %s is unusable: %s\n", dir_name, strerror(errno));
236 return false;
237 }
238 if (! S_ISDIR(sb.st_mode)) {
239 fprintf(stderr, "Output directory %s exists but is not a directory\n", dir_name);
240 return false;
241 }
242 return true;
243#endif
244}
David Reiss204420f2008-01-11 20:59:03 +0000245
246/**
Mark Slee31985722006-05-24 21:45:31 +0000247 * Report an error to the user. This is called yyerror for historical
248 * reasons (lex and yacc expect the error reporting routine to be called
249 * this). Call this function to report any errors to the user.
250 * yyerror takes printf style arguments.
251 *
252 * @param fmt C format string followed by additional arguments
253 */
David Reiss0babe402008-06-10 22:56:12 +0000254void yyerror(const char* fmt, ...) {
Mark Slee31985722006-05-24 21:45:31 +0000255 va_list args;
256 fprintf(stderr,
Mark Sleef0712dc2006-10-25 19:03:57 +0000257 "[ERROR:%s:%d] (last token was '%s')\n",
258 g_curpath.c_str(),
Mark Slee31985722006-05-24 21:45:31 +0000259 yylineno,
260 yytext);
Mark Slee31985722006-05-24 21:45:31 +0000261
262 va_start(args, fmt);
263 vfprintf(stderr, fmt, args);
264 va_end(args);
265
266 fprintf(stderr, "\n");
267}
268
269/**
270 * Prints a debug message from the parser.
271 *
272 * @param fmt C format string followed by additional arguments
273 */
David Reiss0babe402008-06-10 22:56:12 +0000274void pdebug(const char* fmt, ...) {
Mark Slee31985722006-05-24 21:45:31 +0000275 if (g_debug == 0) {
276 return;
277 }
278 va_list args;
Mark Slee30152872006-11-28 01:24:07 +0000279 printf("[PARSE:%d] ", yylineno);
Mark Sleef0712dc2006-10-25 19:03:57 +0000280 va_start(args, fmt);
281 vprintf(fmt, args);
282 va_end(args);
283 printf("\n");
284}
285
286/**
287 * Prints a verbose output mode message
288 *
289 * @param fmt C format string followed by additional arguments
290 */
David Reiss0babe402008-06-10 22:56:12 +0000291void pverbose(const char* fmt, ...) {
Mark Sleef0712dc2006-10-25 19:03:57 +0000292 if (g_verbose == 0) {
293 return;
294 }
295 va_list args;
296 va_start(args, fmt);
297 vprintf(fmt, args);
298 va_end(args);
299}
300
301/**
302 * Prints a warning message
303 *
304 * @param fmt C format string followed by additional arguments
305 */
David Reiss0babe402008-06-10 22:56:12 +0000306void pwarning(int level, const char* fmt, ...) {
Mark Sleef0712dc2006-10-25 19:03:57 +0000307 if (g_warn < level) {
308 return;
309 }
310 va_list args;
311 printf("[WARNING:%s:%d] ", g_curpath.c_str(), yylineno);
Mark Slee31985722006-05-24 21:45:31 +0000312 va_start(args, fmt);
313 vprintf(fmt, args);
314 va_end(args);
315 printf("\n");
316}
317
318/**
319 * Prints a failure message and exits
320 *
321 * @param fmt C format string followed by additional arguments
322 */
Mark Slee30152872006-11-28 01:24:07 +0000323void failure(const char* fmt, ...) {
Mark Slee2c44d202007-05-16 02:18:07 +0000324 va_list args;
Mark Sleef0712dc2006-10-25 19:03:57 +0000325 fprintf(stderr, "[FAILURE:%s:%d] ", g_curpath.c_str(), yylineno);
Mark Slee31985722006-05-24 21:45:31 +0000326 va_start(args, fmt);
327 vfprintf(stderr, fmt, args);
328 va_end(args);
329 printf("\n");
330 exit(1);
331}
332
333/**
Mark Sleef0712dc2006-10-25 19:03:57 +0000334 * Converts a string filename into a thrift program name
335 */
336string program_name(string filename) {
337 string::size_type slash = filename.rfind("/");
338 if (slash != string::npos) {
339 filename = filename.substr(slash+1);
340 }
341 string::size_type dot = filename.rfind(".");
342 if (dot != string::npos) {
343 filename = filename.substr(0, dot);
344 }
345 return filename;
346}
347
348/**
349 * Gets the directory path of a filename
350 */
351string directory_name(string filename) {
352 string::size_type slash = filename.rfind("/");
353 // No slash, just use the current directory
354 if (slash == string::npos) {
355 return ".";
356 }
357 return filename.substr(0, slash);
358}
359
360/**
361 * Finds the appropriate file path for the given filename
362 */
363string include_file(string filename) {
364 // Absolute path? Just try that
Martin Kraemer32c66e12006-11-09 00:06:36 +0000365 if (filename[0] == '/') {
366 // Realpath!
367 char rp[PATH_MAX];
David Reiss204420f2008-01-11 20:59:03 +0000368 if (saferealpath(filename.c_str(), rp) == NULL) {
Martin Kraemer32c66e12006-11-09 00:06:36 +0000369 pwarning(0, "Cannot open include file %s\n", filename.c_str());
370 return std::string();
371 }
Mark Slee2c44d202007-05-16 02:18:07 +0000372
373 // Stat this file
Martin Kraemer32c66e12006-11-09 00:06:36 +0000374 struct stat finfo;
375 if (stat(rp, &finfo) == 0) {
376 return rp;
377 }
378 } else { // relative path, start searching
379 // new search path with current dir global
380 vector<string> sp = g_incl_searchpath;
381 sp.insert(sp.begin(), g_curdir);
Mark Slee2c44d202007-05-16 02:18:07 +0000382
Martin Kraemer32c66e12006-11-09 00:06:36 +0000383 // iterate through paths
384 vector<string>::iterator it;
385 for (it = sp.begin(); it != sp.end(); it++) {
386 string sfilename = *(it) + "/" + filename;
Mark Slee2c44d202007-05-16 02:18:07 +0000387
Martin Kraemer32c66e12006-11-09 00:06:36 +0000388 // Realpath!
389 char rp[PATH_MAX];
David Reiss204420f2008-01-11 20:59:03 +0000390 if (saferealpath(sfilename.c_str(), rp) == NULL) {
Martin Kraemer32c66e12006-11-09 00:06:36 +0000391 continue;
392 }
Mark Slee2c44d202007-05-16 02:18:07 +0000393
Martin Kraemer32c66e12006-11-09 00:06:36 +0000394 // Stat this files
395 struct stat finfo;
396 if (stat(rp, &finfo) == 0) {
397 return rp;
398 }
399 }
Mark Sleef0712dc2006-10-25 19:03:57 +0000400 }
Mark Slee2c44d202007-05-16 02:18:07 +0000401
Mark Sleef0712dc2006-10-25 19:03:57 +0000402 // Uh oh
403 pwarning(0, "Could not find include file %s\n", filename.c_str());
404 return std::string();
405}
406
407/**
David Reisscbd4bac2007-08-14 17:12:33 +0000408 * Clears any previously stored doctext string.
409 * Also prints a warning if we are discarding information.
410 */
411void clear_doctext() {
412 if (g_doctext != NULL) {
413 pwarning(2, "Uncaptured doctext at on line %d.", g_doctext_lineno);
414 }
415 free(g_doctext);
416 g_doctext = NULL;
417}
418
419/**
David Reiss1ac05802007-07-30 22:00:27 +0000420 * Cleans up text commonly found in doxygen-like comments
421 *
422 * Warning: if you mix tabs and spaces in a non-uniform way,
423 * you will get what you deserve.
424 */
425char* clean_up_doctext(char* doctext) {
426 // Convert to C++ string, and remove Windows's carriage returns.
427 string docstring = doctext;
428 docstring.erase(
429 remove(docstring.begin(), docstring.end(), '\r'),
430 docstring.end());
431
432 // Separate into lines.
433 vector<string> lines;
434 string::size_type pos = string::npos;
435 string::size_type last;
436 while (true) {
437 last = (pos == string::npos) ? 0 : pos+1;
438 pos = docstring.find('\n', last);
439 if (pos == string::npos) {
440 // First bit of cleaning. If the last line is only whitespace, drop it.
441 string::size_type nonwhite = docstring.find_first_not_of(" \t", last);
442 if (nonwhite != string::npos) {
443 lines.push_back(docstring.substr(last));
444 }
445 break;
446 }
447 lines.push_back(docstring.substr(last, pos-last));
448 }
449
450 // A very profound docstring.
451 if (lines.empty()) {
452 return NULL;
453 }
454
455 // Clear leading whitespace from the first line.
456 pos = lines.front().find_first_not_of(" \t");
457 lines.front().erase(0, pos);
458
459 // If every nonblank line after the first has the same number of spaces/tabs,
460 // then a star, remove them.
461 bool have_prefix = true;
462 bool found_prefix = false;
463 string::size_type prefix_len = 0;
464 vector<string>::iterator l_iter;
465 for (l_iter = lines.begin()+1; l_iter != lines.end(); ++l_iter) {
466 if (l_iter->empty()) {
467 continue;
468 }
469
470 pos = l_iter->find_first_not_of(" \t");
471 if (!found_prefix) {
472 if (pos != string::npos) {
473 if (l_iter->at(pos) == '*') {
474 found_prefix = true;
475 prefix_len = pos;
476 } else {
477 have_prefix = false;
478 break;
479 }
480 } else {
481 // Whitespace-only line. Truncate it.
482 l_iter->clear();
483 }
484 } else if (l_iter->size() > pos
485 && l_iter->at(pos) == '*'
486 && pos == prefix_len) {
487 // Business as usual.
488 } else if (pos == string::npos) {
489 // Whitespace-only line. Let's truncate it for them.
490 l_iter->clear();
491 } else {
492 // The pattern has been broken.
493 have_prefix = false;
494 break;
495 }
496 }
497
498 // If our prefix survived, delete it from every line.
499 if (have_prefix) {
500 // Get the star too.
501 prefix_len++;
502 for (l_iter = lines.begin()+1; l_iter != lines.end(); ++l_iter) {
503 l_iter->erase(0, prefix_len);
504 }
505 }
506
507 // Now delete the minimum amount of leading whitespace from each line.
508 prefix_len = string::npos;
509 for (l_iter = lines.begin()+1; l_iter != lines.end(); ++l_iter) {
510 if (l_iter->empty()) {
511 continue;
512 }
513 pos = l_iter->find_first_not_of(" \t");
514 if (pos != string::npos
515 && (prefix_len == string::npos || pos < prefix_len)) {
516 prefix_len = pos;
517 }
518 }
519
520 // If our prefix survived, delete it from every line.
521 if (prefix_len != string::npos) {
522 for (l_iter = lines.begin()+1; l_iter != lines.end(); ++l_iter) {
523 l_iter->erase(0, prefix_len);
524 }
525 }
526
527 // Remove trailing whitespace from every line.
528 for (l_iter = lines.begin(); l_iter != lines.end(); ++l_iter) {
529 pos = l_iter->find_last_not_of(" \t");
530 if (pos != string::npos && pos != l_iter->length()-1) {
531 l_iter->erase(pos+1);
532 }
533 }
534
535 // If the first line is empty, remove it.
536 // Don't do this earlier because a lot of steps skip the first line.
537 if (lines.front().empty()) {
538 lines.erase(lines.begin());
539 }
540
541 // Now rejoin the lines and copy them back into doctext.
542 docstring.clear();
543 for (l_iter = lines.begin(); l_iter != lines.end(); ++l_iter) {
544 docstring += *l_iter;
545 docstring += '\n';
546 }
547
548 assert(docstring.length() <= strlen(doctext));
549 strcpy(doctext, docstring.c_str());
550 return doctext;
551}
552
553/** Set to true to debug docstring parsing */
554static bool dump_docs = false;
555
556/**
557 * Dumps docstrings to stdout
David Reisscdffe262007-08-14 17:12:31 +0000558 * Only works for top-level definitions and the whole program doc
559 * (i.e., not enum constants, struct fields, or functions.
David Reiss1ac05802007-07-30 22:00:27 +0000560 */
561void dump_docstrings(t_program* program) {
David Reisscdffe262007-08-14 17:12:31 +0000562 string progdoc = program->get_doc();
David Reissc2532a92007-07-30 23:46:11 +0000563 if (!progdoc.empty()) {
564 printf("Whole program doc:\n%s\n", progdoc.c_str());
565 }
David Reiss1ac05802007-07-30 22:00:27 +0000566 const vector<t_typedef*>& typedefs = program->get_typedefs();
567 vector<t_typedef*>::const_iterator t_iter;
568 for (t_iter = typedefs.begin(); t_iter != typedefs.end(); ++t_iter) {
569 t_typedef* td = *t_iter;
570 if (td->has_doc()) {
David Reisscdffe262007-08-14 17:12:31 +0000571 printf("typedef %s:\n%s\n", td->get_name().c_str(), td->get_doc().c_str());
572 }
573 }
574 const vector<t_enum*>& enums = program->get_enums();
575 vector<t_enum*>::const_iterator e_iter;
576 for (e_iter = enums.begin(); e_iter != enums.end(); ++e_iter) {
577 t_enum* en = *e_iter;
578 if (en->has_doc()) {
579 printf("enum %s:\n%s\n", en->get_name().c_str(), en->get_doc().c_str());
580 }
581 }
582 const vector<t_const*>& consts = program->get_consts();
583 vector<t_const*>::const_iterator c_iter;
584 for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) {
585 t_const* co = *c_iter;
586 if (co->has_doc()) {
587 printf("const %s:\n%s\n", co->get_name().c_str(), co->get_doc().c_str());
588 }
589 }
590 const vector<t_struct*>& structs = program->get_structs();
591 vector<t_struct*>::const_iterator s_iter;
592 for (s_iter = structs.begin(); s_iter != structs.end(); ++s_iter) {
593 t_struct* st = *s_iter;
594 if (st->has_doc()) {
595 printf("struct %s:\n%s\n", st->get_name().c_str(), st->get_doc().c_str());
596 }
597 }
598 const vector<t_struct*>& xceptions = program->get_xceptions();
599 vector<t_struct*>::const_iterator x_iter;
600 for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) {
601 t_struct* xn = *x_iter;
602 if (xn->has_doc()) {
603 printf("xception %s:\n%s\n", xn->get_name().c_str(), xn->get_doc().c_str());
604 }
605 }
606 const vector<t_service*>& services = program->get_services();
607 vector<t_service*>::const_iterator v_iter;
608 for (v_iter = services.begin(); v_iter != services.end(); ++v_iter) {
609 t_service* sv = *v_iter;
610 if (sv->has_doc()) {
611 printf("service %s:\n%s\n", sv->get_name().c_str(), sv->get_doc().c_str());
David Reiss1ac05802007-07-30 22:00:27 +0000612 }
613 }
614}
615
616/**
David Reiss3c5d2fd2008-02-08 21:58:06 +0000617 * Call generate_fingerprint for every structure and enum.
David Reiss18bf22d2007-08-28 20:49:17 +0000618 */
619void generate_all_fingerprints(t_program* program) {
620 const vector<t_struct*>& structs = program->get_structs();
621 vector<t_struct*>::const_iterator s_iter;
622 for (s_iter = structs.begin(); s_iter != structs.end(); ++s_iter) {
623 t_struct* st = *s_iter;
624 st->generate_fingerprint();
625 }
626
David Reissd779cbe2007-08-31 01:42:55 +0000627 const vector<t_struct*>& xceptions = program->get_xceptions();
628 vector<t_struct*>::const_iterator x_iter;
629 for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) {
630 t_struct* st = *x_iter;
631 st->generate_fingerprint();
632 }
633
David Reiss3c5d2fd2008-02-08 21:58:06 +0000634 const vector<t_enum*>& enums = program->get_enums();
635 vector<t_enum*>::const_iterator e_iter;
636 for (e_iter = enums.begin(); e_iter != enums.end(); ++e_iter) {
637 t_enum* e = *e_iter;
638 e->generate_fingerprint();
639 }
640
David Reiss47557bc2007-09-04 21:31:04 +0000641 g_type_void->generate_fingerprint();
642
David Reiss18bf22d2007-08-28 20:49:17 +0000643 // If you want to generate fingerprints for implicit structures, start here.
644 /*
645 const vector<t_service*>& services = program->get_services();
646 vector<t_service*>::const_iterator v_iter;
647 for (v_iter = services.begin(); v_iter != services.end(); ++v_iter) {
648 t_service* sv = *v_iter;
649 }
650 */
651}
652
653/**
David Reissdd08f6d2008-06-30 20:24:24 +0000654 * Prints the version number
655 */
656void version() {
Bryan Duxburya1e268c2010-05-03 21:33:00 +0000657 printf("Thrift version %s\n", THRIFT_VERSION);
David Reissdd08f6d2008-06-30 20:24:24 +0000658}
659
660/**
Jake Farrell2fd8a152012-09-29 00:26:36 +0000661 * Display the usage message and then exit with an error code.
Mark Slee31985722006-05-24 21:45:31 +0000662 */
663void usage() {
Jake Farrell2fd8a152012-09-29 00:26:36 +0000664 fprintf(stderr, "Usage: thrift [options] file\n\n");
665 fprintf(stderr, "Use thrift -help for a list of options\n");
666 exit(1);
667}
668
669/**
670 * Diplays the help message and then exits with an error code.
671 */
672void help() {
Mark Sleeb15a68b2006-06-07 06:46:24 +0000673 fprintf(stderr, "Usage: thrift [options] file\n");
674 fprintf(stderr, "Options:\n");
David Reissdd08f6d2008-06-30 20:24:24 +0000675 fprintf(stderr, " -version Print the compiler version\n");
dweatherford65b70752007-10-31 02:18:14 +0000676 fprintf(stderr, " -o dir Set the output directory for gen-* packages\n");
677 fprintf(stderr, " (default: current directory)\n");
Bryan Duxburybdca9f62011-03-01 19:53:07 +0000678 fprintf(stderr, " -out dir Set the ouput location for generated files.\n");
679 fprintf(stderr," (no gen-* folder will be created)\n");
David Reissd779cbe2007-08-31 01:42:55 +0000680 fprintf(stderr, " -I dir Add a directory to the list of directories\n");
Mark Slee227ac2c2007-03-07 05:46:50 +0000681 fprintf(stderr, " searched for include directives\n");
Mark Slee2329a832006-11-09 00:23:30 +0000682 fprintf(stderr, " -nowarn Suppress all compiler warnings (BAD!)\n");
683 fprintf(stderr, " -strict Strict compiler warnings on\n");
684 fprintf(stderr, " -v[erbose] Verbose mode\n");
685 fprintf(stderr, " -r[ecurse] Also generate included files\n");
686 fprintf(stderr, " -debug Parse debug trace to stdout\n");
Bryan Duxburyc7206a42011-08-17 23:17:04 +0000687 fprintf(stderr, " --allow-neg-keys Allow negative field keys (Used to "
688 "preserve protocol\n");
689 fprintf(stderr, " compatibility with older .thrift files)\n");
Roger Meier887ff752011-08-19 11:25:39 +0000690 fprintf(stderr, " --allow-64bit-consts Do not print warnings about using 64-bit constants\n");
David Reissbd0db882008-02-27 01:54:51 +0000691 fprintf(stderr, " --gen STR Generate code with a dynamically-registered generator.\n");
692 fprintf(stderr, " STR has the form language[:key1=val1[,key2,[key3=val3]]].\n");
693 fprintf(stderr, " Keys and values are options passed to the generator.\n");
694 fprintf(stderr, " Many options will not require values.\n");
695 fprintf(stderr, "\n");
696 fprintf(stderr, "Available generators (and options):\n");
697
698 t_generator_registry::gen_map_t gen_map = t_generator_registry::get_generator_map();
699 t_generator_registry::gen_map_t::iterator iter;
700 for (iter = gen_map.begin(); iter != gen_map.end(); ++iter) {
701 fprintf(stderr, " %s (%s):\n",
702 iter->second->get_short_name().c_str(),
703 iter->second->get_long_name().c_str());
704 fprintf(stderr, "%s", iter->second->get_documentation().c_str());
705 }
Mark Slee31985722006-05-24 21:45:31 +0000706 exit(1);
707}
708
709/**
Mark Slee30152872006-11-28 01:24:07 +0000710 * You know, when I started working on Thrift I really thought it wasn't going
711 * to become a programming language because it was just a generator and it
712 * wouldn't need runtime type information and all that jazz. But then we
713 * decided to add constants, and all of a sudden that means runtime type
714 * validation and inference, except the "runtime" is the code generator
David Reiss3bb5e052010-01-25 19:31:31 +0000715 * runtime.
Mark Slee30152872006-11-28 01:24:07 +0000716 */
717void validate_const_rec(std::string name, t_type* type, t_const_value* value) {
718 if (type->is_void()) {
719 throw "type error: cannot declare a void const: " + name;
720 }
721
722 if (type->is_base_type()) {
723 t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
724 switch (tbase) {
725 case t_base_type::TYPE_STRING:
726 if (value->get_type() != t_const_value::CV_STRING) {
727 throw "type error: const \"" + name + "\" was declared as string";
728 }
729 break;
730 case t_base_type::TYPE_BOOL:
731 if (value->get_type() != t_const_value::CV_INTEGER) {
732 throw "type error: const \"" + name + "\" was declared as bool";
733 }
734 break;
735 case t_base_type::TYPE_BYTE:
736 if (value->get_type() != t_const_value::CV_INTEGER) {
737 throw "type error: const \"" + name + "\" was declared as byte";
738 }
739 break;
740 case t_base_type::TYPE_I16:
741 if (value->get_type() != t_const_value::CV_INTEGER) {
742 throw "type error: const \"" + name + "\" was declared as i16";
743 }
744 break;
745 case t_base_type::TYPE_I32:
746 if (value->get_type() != t_const_value::CV_INTEGER) {
747 throw "type error: const \"" + name + "\" was declared as i32";
748 }
749 break;
750 case t_base_type::TYPE_I64:
751 if (value->get_type() != t_const_value::CV_INTEGER) {
752 throw "type error: const \"" + name + "\" was declared as i64";
753 }
754 break;
755 case t_base_type::TYPE_DOUBLE:
756 if (value->get_type() != t_const_value::CV_INTEGER &&
757 value->get_type() != t_const_value::CV_DOUBLE) {
758 throw "type error: const \"" + name + "\" was declared as double";
759 }
760 break;
761 default:
David Reissdd7796f2007-08-28 21:09:06 +0000762 throw "compiler error: no const of base type " + t_base_type::t_base_name(tbase) + name;
Mark Slee30152872006-11-28 01:24:07 +0000763 }
764 } else if (type->is_enum()) {
Bryan Duxbury2d804702009-12-18 19:41:11 +0000765 if (value->get_type() != t_const_value::CV_IDENTIFIER) {
Mark Slee30152872006-11-28 01:24:07 +0000766 throw "type error: const \"" + name + "\" was declared as enum";
767 }
Bryan Duxbury2d804702009-12-18 19:41:11 +0000768
Bryan Duxbury1606f252010-11-24 00:25:57 +0000769 // see if there's a dot in the identifier
770 std::string name_portion = value->get_identifier_name();
771
Bryan Duxbury2d804702009-12-18 19:41:11 +0000772 const vector<t_enum_value*>& enum_values = ((t_enum*)type)->get_constants();
773 vector<t_enum_value*>::const_iterator c_iter;
774 bool found = false;
Bryan Duxbury9f0a7862010-09-12 14:38:36 +0000775
Bryan Duxbury1606f252010-11-24 00:25:57 +0000776 for (c_iter = enum_values.begin(); c_iter != enum_values.end(); ++c_iter) {
Bryan Duxbury9f0a7862010-09-12 14:38:36 +0000777 if ((*c_iter)->get_name() == name_portion) {
Bryan Duxbury2d804702009-12-18 19:41:11 +0000778 found = true;
779 break;
780 }
781 }
782 if (!found) {
783 throw "type error: const " + name + " was declared as type "
784 + type->get_name() + " which is an enum, but "
785 + value->get_identifier() + " is not a valid value for that enum";
786 }
Mark Slee30152872006-11-28 01:24:07 +0000787 } else if (type->is_struct() || type->is_xception()) {
788 if (value->get_type() != t_const_value::CV_MAP) {
789 throw "type error: const \"" + name + "\" was declared as struct/xception";
790 }
791 const vector<t_field*>& fields = ((t_struct*)type)->get_members();
792 vector<t_field*>::const_iterator f_iter;
793
794 const map<t_const_value*, t_const_value*>& val = value->get_map();
795 map<t_const_value*, t_const_value*>::const_iterator v_iter;
796 for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
797 if (v_iter->first->get_type() != t_const_value::CV_STRING) {
798 throw "type error: " + name + " struct key must be string";
799 }
800 t_type* field_type = NULL;
801 for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
802 if ((*f_iter)->get_name() == v_iter->first->get_string()) {
803 field_type = (*f_iter)->get_type();
804 }
805 }
806 if (field_type == NULL) {
807 throw "type error: " + type->get_name() + " has no field " + v_iter->first->get_string();
808 }
809
810 validate_const_rec(name + "." + v_iter->first->get_string(), field_type, v_iter->second);
811 }
812 } else if (type->is_map()) {
813 t_type* k_type = ((t_map*)type)->get_key_type();
814 t_type* v_type = ((t_map*)type)->get_val_type();
815 const map<t_const_value*, t_const_value*>& val = value->get_map();
816 map<t_const_value*, t_const_value*>::const_iterator v_iter;
817 for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
818 validate_const_rec(name + "<key>", k_type, v_iter->first);
819 validate_const_rec(name + "<val>", v_type, v_iter->second);
Mark Slee2c44d202007-05-16 02:18:07 +0000820 }
Mark Slee30152872006-11-28 01:24:07 +0000821 } else if (type->is_list() || type->is_set()) {
822 t_type* e_type;
823 if (type->is_list()) {
824 e_type = ((t_list*)type)->get_elem_type();
825 } else {
826 e_type = ((t_set*)type)->get_elem_type();
827 }
828 const vector<t_const_value*>& val = value->get_list();
829 vector<t_const_value*>::const_iterator v_iter;
830 for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
831 validate_const_rec(name + "<elem>", e_type, *v_iter);
832 }
833 }
834}
835
836/**
837 * Check the type of the parsed const information against its declared type
838 */
839void validate_const_type(t_const* c) {
840 validate_const_rec(c->get_name(), c->get_type(), c->get_value());
841}
842
843/**
Mark Slee7ff32452007-02-01 05:26:18 +0000844 * Check the type of a default value assigned to a field.
845 */
846void validate_field_value(t_field* field, t_const_value* cv) {
847 validate_const_rec(field->get_name(), field->get_type(), cv);
848}
849
850/**
Mark Slee91f2b7b2008-01-31 01:49:16 +0000851 * Check that all the elements of a throws block are actually exceptions.
852 */
853bool validate_throws(t_struct* throws) {
854 const vector<t_field*>& members = throws->get_members();
855 vector<t_field*>::const_iterator m_iter;
856 for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
Bryan Duxburycff83572011-08-24 20:53:03 +0000857 if (!t_generator::get_true_type((*m_iter)->get_type())->is_xception()) {
Mark Slee91f2b7b2008-01-31 01:49:16 +0000858 return false;
859 }
860 }
861 return true;
862}
863
864/**
Mark Sleef0712dc2006-10-25 19:03:57 +0000865 * Parses a program
866 */
Mark Slee2c44d202007-05-16 02:18:07 +0000867void parse(t_program* program, t_program* parent_program) {
Mark Sleef0712dc2006-10-25 19:03:57 +0000868 // Get scope file path
869 string path = program->get_path();
Mark Slee2c44d202007-05-16 02:18:07 +0000870
Mark Sleef0712dc2006-10-25 19:03:57 +0000871 // Set current dir global, which is used in the include_file function
872 g_curdir = directory_name(path);
873 g_curpath = path;
874
875 // Open the file
876 yyin = fopen(path.c_str(), "r");
877 if (yyin == 0) {
878 failure("Could not open input file: \"%s\"", path.c_str());
879 }
880
881 // Create new scope and scan for includes
882 pverbose("Scanning %s for includes\n", path.c_str());
Mark Slee2c44d202007-05-16 02:18:07 +0000883 g_parse_mode = INCLUDES;
Mark Sleef0712dc2006-10-25 19:03:57 +0000884 g_program = program;
885 g_scope = program->scope();
Mark Slee30152872006-11-28 01:24:07 +0000886 try {
Mark Slee36bfa2e2007-01-19 20:09:51 +0000887 yylineno = 1;
Mark Slee30152872006-11-28 01:24:07 +0000888 if (yyparse() != 0) {
889 failure("Parser error during include pass.");
890 }
891 } catch (string x) {
892 failure(x.c_str());
Mark Sleef0712dc2006-10-25 19:03:57 +0000893 }
894 fclose(yyin);
895
896 // Recursively parse all the include programs
897 vector<t_program*>& includes = program->get_includes();
898 vector<t_program*>::iterator iter;
899 for (iter = includes.begin(); iter != includes.end(); ++iter) {
900 parse(*iter, program);
901 }
902
David Reiss204420f2008-01-11 20:59:03 +0000903 // Parse the program file
Mark Sleef0712dc2006-10-25 19:03:57 +0000904 g_parse_mode = PROGRAM;
905 g_program = program;
906 g_scope = program->scope();
907 g_parent_scope = (parent_program != NULL) ? parent_program->scope() : NULL;
908 g_parent_prefix = program->get_name() + ".";
909 g_curpath = path;
910 yyin = fopen(path.c_str(), "r");
911 if (yyin == 0) {
912 failure("Could not open input file: \"%s\"", path.c_str());
913 }
914 pverbose("Parsing %s for types\n", path.c_str());
Mark Slee36bfa2e2007-01-19 20:09:51 +0000915 yylineno = 1;
David Reiss877237a2007-07-27 00:40:19 +0000916 try {
917 if (yyparse() != 0) {
918 failure("Parser error during types pass.");
919 }
920 } catch (string x) {
921 failure(x.c_str());
Mark Sleef0712dc2006-10-25 19:03:57 +0000922 }
923 fclose(yyin);
924}
925
926/**
927 * Generate code
928 */
David Reissbd0db882008-02-27 01:54:51 +0000929void generate(t_program* program, const vector<string>& generator_strings) {
Mark Sleef0712dc2006-10-25 19:03:57 +0000930 // Oooohh, recursive code generation, hot!!
931 if (gen_recurse) {
932 const vector<t_program*>& includes = program->get_includes();
933 for (size_t i = 0; i < includes.size(); ++i) {
dweatherford65b70752007-10-31 02:18:14 +0000934 // Propogate output path from parent to child programs
Bryan Duxburybdca9f62011-03-01 19:53:07 +0000935 includes[i]->set_out_path(program->get_out_path(), program->is_out_path_absolute());
Mark Slee5b743072007-11-13 04:00:29 +0000936
David Reissbd0db882008-02-27 01:54:51 +0000937 generate(includes[i], generator_strings);
Mark Sleef0712dc2006-10-25 19:03:57 +0000938 }
939 }
940
941 // Generate code!
942 try {
943 pverbose("Program: %s\n", program->get_path().c_str());
944
David Reiss18bf22d2007-08-28 20:49:17 +0000945 // Compute fingerprints.
946 generate_all_fingerprints(program);
947
David Reiss1ac05802007-07-30 22:00:27 +0000948 if (dump_docs) {
949 dump_docstrings(program);
950 }
David Reissbd0db882008-02-27 01:54:51 +0000951
952 vector<string>::const_iterator iter;
953 for (iter = generator_strings.begin(); iter != generator_strings.end(); ++iter) {
954 t_generator* generator = t_generator_registry::get_generator(program, *iter);
955
956 if (generator == NULL) {
957 pwarning(1, "Unable to get a generator for \"%s\".\n", iter->c_str());
958 } else {
959 pverbose("Generating \"%s\"\n", iter->c_str());
960 generator->generate_program();
David Reissc9342682008-03-27 21:39:49 +0000961 delete generator;
David Reissbd0db882008-02-27 01:54:51 +0000962 }
963 }
964
Mark Sleef0712dc2006-10-25 19:03:57 +0000965 } catch (string s) {
966 printf("Error: %s\n", s.c_str());
967 } catch (const char* exc) {
968 printf("Error: %s\n", exc);
969 }
970
971}
972
973/**
Mark Sleef5377b32006-10-10 01:42:59 +0000974 * Parse it up.. then spit it back out, in pretty much every language. Alright
975 * not that many languages, but the cool ones that we care about.
Mark Slee31985722006-05-24 21:45:31 +0000976 */
977int main(int argc, char** argv) {
978 int i;
dweatherford65b70752007-10-31 02:18:14 +0000979 std::string out_path;
Bryan Duxburybdca9f62011-03-01 19:53:07 +0000980 bool out_path_is_absolute = false;
Mark Sleef5377b32006-10-10 01:42:59 +0000981
Mark Sleeb15a68b2006-06-07 06:46:24 +0000982 // Setup time string
983 time_t now = time(NULL);
984 g_time_str = ctime(&now);
Mark Slee31985722006-05-24 21:45:31 +0000985
Mark Sleef0712dc2006-10-25 19:03:57 +0000986 // Check for necessary arguments, you gotta have at least a filename and
987 // an output language flag
Mark Sleeb15a68b2006-06-07 06:46:24 +0000988 if (argc < 2) {
989 usage();
990 }
Mark Slee31985722006-05-24 21:45:31 +0000991
David Reissbd0db882008-02-27 01:54:51 +0000992 vector<string> generator_strings;
993
David Reiss9cc2c132008-02-27 01:54:47 +0000994 // Set the current path to a dummy value to make warning messages clearer.
995 g_curpath = "arguments";
996
Mark Sleef5377b32006-10-10 01:42:59 +0000997 // Hacky parameter handling... I didn't feel like using a library sorry!
Mark Slee31985722006-05-24 21:45:31 +0000998 for (i = 1; i < argc-1; i++) {
Mark Sleefdbee812006-09-27 18:50:48 +0000999 char* arg;
Mark Slee2329a832006-11-09 00:23:30 +00001000
Mark Sleefdbee812006-09-27 18:50:48 +00001001 arg = strtok(argv[i], " ");
1002 while (arg != NULL) {
Mark Slee2329a832006-11-09 00:23:30 +00001003 // Treat double dashes as single dashes
Mark Slee52cb2232006-11-10 22:32:07 +00001004 if (arg[0] == '-' && arg[1] == '-') {
Mark Slee2329a832006-11-09 00:23:30 +00001005 ++arg;
1006 }
1007
Jake Farrell2fd8a152012-09-29 00:26:36 +00001008 if (strcmp(arg, "-help") == 0) {
1009 help();
1010 } else if (strcmp(arg, "-version") == 0) {
David Reissdd08f6d2008-06-30 20:24:24 +00001011 version();
1012 exit(1);
1013 } else if (strcmp(arg, "-debug") == 0) {
Mark Sleefdbee812006-09-27 18:50:48 +00001014 g_debug = 1;
Mark Slee2329a832006-11-09 00:23:30 +00001015 } else if (strcmp(arg, "-nowarn") == 0) {
Mark Sleef0712dc2006-10-25 19:03:57 +00001016 g_warn = 0;
Mark Slee2329a832006-11-09 00:23:30 +00001017 } else if (strcmp(arg, "-strict") == 0) {
Bryan Duxburya145b4d2009-04-03 17:29:25 +00001018 g_strict = 255;
Mark Sleef0712dc2006-10-25 19:03:57 +00001019 g_warn = 2;
Mark Slee2329a832006-11-09 00:23:30 +00001020 } else if (strcmp(arg, "-v") == 0 || strcmp(arg, "-verbose") == 0 ) {
Mark Sleef0712dc2006-10-25 19:03:57 +00001021 g_verbose = 1;
Mark Slee2329a832006-11-09 00:23:30 +00001022 } else if (strcmp(arg, "-r") == 0 || strcmp(arg, "-recurse") == 0 ) {
Mark Sleef0712dc2006-10-25 19:03:57 +00001023 gen_recurse = true;
Bryan Duxburyc7206a42011-08-17 23:17:04 +00001024 } else if (strcmp(arg, "-allow-neg-keys") == 0) {
1025 g_allow_neg_field_keys = true;
Roger Meier887ff752011-08-19 11:25:39 +00001026 } else if (strcmp(arg, "-allow-64bit-consts") == 0) {
1027 g_allow_64bit_consts = true;
David Reissbd0db882008-02-27 01:54:51 +00001028 } else if (strcmp(arg, "-gen") == 0) {
1029 arg = argv[++i];
1030 if (arg == NULL) {
Jake Farrell2fd8a152012-09-29 00:26:36 +00001031 fprintf(stderr, "Missing generator specification\n");
David Reissbd0db882008-02-27 01:54:51 +00001032 usage();
1033 }
1034 generator_strings.push_back(arg);
David Reissd779cbe2007-08-31 01:42:55 +00001035 } else if (strcmp(arg, "-dense") == 0) {
1036 gen_dense = true;
Mark Slee2329a832006-11-09 00:23:30 +00001037 } else if (strcmp(arg, "-cpp") == 0) {
Mark Sleefdbee812006-09-27 18:50:48 +00001038 gen_cpp = true;
Mark Slee01a9f882007-08-31 00:55:28 +00001039 } else if (strcmp(arg, "-javabean") == 0) {
1040 gen_javabean = true;
Mark Slee2329a832006-11-09 00:23:30 +00001041 } else if (strcmp(arg, "-java") == 0) {
Mark Sleefdbee812006-09-27 18:50:48 +00001042 gen_java = true;
Mark Slee2329a832006-11-09 00:23:30 +00001043 } else if (strcmp(arg, "-php") == 0) {
Mark Sleefdbee812006-09-27 18:50:48 +00001044 gen_php = true;
Mark Slee2329a832006-11-09 00:23:30 +00001045 } else if (strcmp(arg, "-phpi") == 0) {
Mark Sleef5377b32006-10-10 01:42:59 +00001046 gen_phpi = true;
Mark Slee5b743072007-11-13 04:00:29 +00001047 } else if (strcmp(arg, "-phps") == 0) {
David Reiss6495adb2007-12-18 03:37:30 +00001048 gen_php = true;
Mark Slee5b743072007-11-13 04:00:29 +00001049 gen_phps = true;
1050 } else if (strcmp(arg, "-phpl") == 0) {
David Reiss6495adb2007-12-18 03:37:30 +00001051 gen_php = true;
Mark Slee5b743072007-11-13 04:00:29 +00001052 gen_phps = false;
Mark Slee09f69e02007-11-17 00:32:36 +00001053 } else if (strcmp(arg, "-phpa") == 0) {
David Reiss6495adb2007-12-18 03:37:30 +00001054 gen_php = true;
1055 gen_phps = false;
Mark Slee09f69e02007-11-17 00:32:36 +00001056 gen_phpa = true;
Mark Sleeb22df7c2007-11-28 02:39:59 +00001057 } else if (strcmp(arg, "-phpo") == 0) {
David Reiss6495adb2007-12-18 03:37:30 +00001058 gen_php = true;
Mark Sleeb22df7c2007-11-28 02:39:59 +00001059 gen_phpo = true;
Mark Slee756b1d12007-07-06 00:30:21 +00001060 } else if (strcmp(arg, "-rest") == 0) {
1061 gen_rest = true;
Mark Slee2329a832006-11-09 00:23:30 +00001062 } else if (strcmp(arg, "-py") == 0) {
Mark Sleefdbee812006-09-27 18:50:48 +00001063 gen_py = true;
David Reiss6495adb2007-12-18 03:37:30 +00001064 } else if (strcmp(arg, "-pyns") == 0) {
1065 gen_py = true;
1066 gen_py_newstyle = true;
Mark Slee6d7d5952007-01-27 01:44:22 +00001067 } else if (strcmp(arg, "-rb") == 0) {
1068 gen_rb = true;
Mark Slee0e0ff7e2007-01-18 22:59:59 +00001069 } else if (strcmp(arg, "-xsd") == 0) {
1070 gen_xsd = true;
Mark Slee2c44d202007-05-16 02:18:07 +00001071 } else if (strcmp(arg, "-perl") == 0) {
1072 gen_perl = true;
David Reiss9f2a5d72008-06-11 01:15:45 +00001073 } else if (strcmp(arg, "-erl") == 0) {
1074 gen_erl = true;
Christopher Pirob97b89d2007-09-18 00:07:42 +00001075 } else if (strcmp(arg, "-ocaml") == 0) {
1076 gen_ocaml = true;
iproctorff8eb922007-07-25 19:06:13 +00001077 } else if (strcmp(arg, "-hs") == 0) {
1078 gen_hs = true;
Mark Slee7e9eea42007-09-10 21:00:23 +00001079 } else if (strcmp(arg, "-cocoa") == 0) {
1080 gen_cocoa = true;
Mark Sleeefd37f12007-11-20 05:13:09 +00001081 } else if (strcmp(arg, "-st") == 0) {
1082 gen_st = true;
David Reiss7f42bcf2008-01-11 20:59:12 +00001083 } else if (strcmp(arg, "-csharp") == 0) {
1084 gen_csharp = true;
Jake Farrell7ae13e12011-10-18 14:35:26 +00001085 } else if (strcmp(arg, "-delphi") == 0) {
1086 gen_delphi = true;
kholst76f2c882008-01-16 02:47:41 +00001087 } else if (strcmp(arg, "-cpp_use_include_prefix") == 0) {
1088 g_cpp_use_include_prefix = true;
Martin Kraemer32c66e12006-11-09 00:06:36 +00001089 } else if (strcmp(arg, "-I") == 0) {
1090 // An argument of "-I\ asdf" is invalid and has unknown results
1091 arg = argv[++i];
1092
1093 if (arg == NULL) {
Jake Farrell2fd8a152012-09-29 00:26:36 +00001094 fprintf(stderr, "Missing Include directory\n");
Martin Kraemer32c66e12006-11-09 00:06:36 +00001095 usage();
1096 }
1097 g_incl_searchpath.push_back(arg);
Bryan Duxburybdca9f62011-03-01 19:53:07 +00001098 } else if ((strcmp(arg, "-o") == 0) || (strcmp(arg, "-out") == 0)) {
1099 out_path_is_absolute = (strcmp(arg, "-out") == 0) ? true : false;
1100
1101 arg = argv[++i];
dweatherford65b70752007-10-31 02:18:14 +00001102 if (arg == NULL) {
David Reiss9d866ac2008-06-10 22:56:19 +00001103 fprintf(stderr, "-o: missing output directory\n");
dweatherford65b70752007-10-31 02:18:14 +00001104 usage();
Mark Slee5b743072007-11-13 04:00:29 +00001105 }
dweatherford65b70752007-10-31 02:18:14 +00001106 out_path = arg;
David Reiss204420f2008-01-11 20:59:03 +00001107
1108#ifdef MINGW
1109 //strip out trailing \ on Windows
1110 int last = out_path.length()-1;
1111 if (out_path[last] == '\\')
1112 {
1113 out_path.erase(last);
1114 }
1115#endif
Roger Meier061d4a22012-10-07 11:51:00 +00001116 if (!check_is_directory(out_path.c_str()))
dweatherford65b70752007-10-31 02:18:14 +00001117 return -1;
Mark Sleefdbee812006-09-27 18:50:48 +00001118 } else {
Jake Farrell2fd8a152012-09-29 00:26:36 +00001119 fprintf(stderr, "Unrecognized option: %s\n", arg);
Mark Sleefdbee812006-09-27 18:50:48 +00001120 usage();
1121 }
1122
1123 // Tokenize more
1124 arg = strtok(NULL, " ");
Mark Slee31985722006-05-24 21:45:31 +00001125 }
1126 }
Mark Slee2c44d202007-05-16 02:18:07 +00001127
Jake Farrell2fd8a152012-09-29 00:26:36 +00001128 // display help
1129 if ((strcmp(argv[argc-1], "-help") == 0) || (strcmp(argv[argc-1], "--help") == 0)) {
1130 help();
1131 }
1132
David Reissdd08f6d2008-06-30 20:24:24 +00001133 // if you're asking for version, you have a right not to pass a file
Jake Farrell2fd8a152012-09-29 00:26:36 +00001134 if ((strcmp(argv[argc-1], "-version") == 0) || (strcmp(argv[argc-1], "--version") == 0)) {
David Reissdd08f6d2008-06-30 20:24:24 +00001135 version();
1136 exit(1);
1137 }
1138
Mark Sleef0712dc2006-10-25 19:03:57 +00001139 // You gotta generate something!
David Reissa9ea68b2009-02-17 20:28:24 +00001140 if (generator_strings.empty()) {
Jake Farrell2fd8a152012-09-29 00:26:36 +00001141 fprintf(stderr, "No output language(s) specified\n");
Mark Sleeb15a68b2006-06-07 06:46:24 +00001142 usage();
1143 }
Mark Sleef0712dc2006-10-25 19:03:57 +00001144
1145 // Real-pathify it
1146 char rp[PATH_MAX];
David Reiss5245f402008-06-10 22:56:26 +00001147 if (argv[i] == NULL) {
Jake Farrell2fd8a152012-09-29 00:26:36 +00001148 fprintf(stderr, "Missing file name\n");
David Reiss5245f402008-06-10 22:56:26 +00001149 usage();
1150 }
David Reiss204420f2008-01-11 20:59:03 +00001151 if (saferealpath(argv[i], rp) == NULL) {
1152 failure("Could not open input file with realpath: %s", argv[i]);
Mark Slee31985722006-05-24 21:45:31 +00001153 }
Mark Sleef0712dc2006-10-25 19:03:57 +00001154 string input_file(rp);
1155
Mark Sleef5377b32006-10-10 01:42:59 +00001156 // Instance of the global parse tree
Mark Sleef0712dc2006-10-25 19:03:57 +00001157 t_program* program = new t_program(input_file);
dweatherford65b70752007-10-31 02:18:14 +00001158 if (out_path.size()) {
Bryan Duxburybdca9f62011-03-01 19:53:07 +00001159 program->set_out_path(out_path, out_path_is_absolute);
dweatherford65b70752007-10-31 02:18:14 +00001160 }
kholst76f2c882008-01-16 02:47:41 +00001161
David Reiss4b6a3c72008-02-27 22:28:12 +00001162 // Compute the cpp include prefix.
1163 // infer this from the filename passed in
1164 string input_filename = argv[i];
1165 string include_prefix;
kholst76f2c882008-01-16 02:47:41 +00001166
David Reiss4b6a3c72008-02-27 22:28:12 +00001167 string::size_type last_slash = string::npos;
1168 if ((last_slash = input_filename.rfind("/")) != string::npos) {
1169 include_prefix = input_filename.substr(0, last_slash);
kholst76f2c882008-01-16 02:47:41 +00001170 }
Mark Sleef0712dc2006-10-25 19:03:57 +00001171
David Reiss4b6a3c72008-02-27 22:28:12 +00001172 program->set_include_prefix(include_prefix);
1173
Mark Sleef0712dc2006-10-25 19:03:57 +00001174 // Initialize global types
1175 g_type_void = new t_base_type("void", t_base_type::TYPE_VOID);
1176 g_type_string = new t_base_type("string", t_base_type::TYPE_STRING);
Mark Slee8d725a22007-04-13 01:57:12 +00001177 g_type_binary = new t_base_type("string", t_base_type::TYPE_STRING);
1178 ((t_base_type*)g_type_binary)->set_binary(true);
Mark Sleeb6200d82007-01-19 19:14:36 +00001179 g_type_slist = new t_base_type("string", t_base_type::TYPE_STRING);
1180 ((t_base_type*)g_type_slist)->set_string_list(true);
Mark Sleef0712dc2006-10-25 19:03:57 +00001181 g_type_bool = new t_base_type("bool", t_base_type::TYPE_BOOL);
1182 g_type_byte = new t_base_type("byte", t_base_type::TYPE_BYTE);
1183 g_type_i16 = new t_base_type("i16", t_base_type::TYPE_I16);
1184 g_type_i32 = new t_base_type("i32", t_base_type::TYPE_I32);
1185 g_type_i64 = new t_base_type("i64", t_base_type::TYPE_I64);
1186 g_type_double = new t_base_type("double", t_base_type::TYPE_DOUBLE);
Mark Sleee8540632006-05-30 09:24:40 +00001187
Mark Sleef5377b32006-10-10 01:42:59 +00001188 // Parse it!
Mark Sleef0712dc2006-10-25 19:03:57 +00001189 parse(program, NULL);
Mark Slee31985722006-05-24 21:45:31 +00001190
David Reiss9cc2c132008-02-27 01:54:47 +00001191 // The current path is not really relevant when we are doing generation.
1192 // Reset the variable to make warning messages clearer.
1193 g_curpath = "generation";
1194 // Reset yylineno for the heck of it. Use 1 instead of 0 because
1195 // That is what shows up during argument parsing.
1196 yylineno = 1;
1197
Mark Sleef0712dc2006-10-25 19:03:57 +00001198 // Generate it!
David Reissbd0db882008-02-27 01:54:51 +00001199 generate(program, generator_strings);
Mark Sleeb15a68b2006-06-07 06:46:24 +00001200
Mark Sleef0712dc2006-10-25 19:03:57 +00001201 // Clean up. Who am I kidding... this program probably orphans heap memory
1202 // all over the place, but who cares because it is about to exit and it is
1203 // all referenced and used by this wacky parse tree up until now anyways.
Mark Sleeb15a68b2006-06-07 06:46:24 +00001204
Mark Sleef0712dc2006-10-25 19:03:57 +00001205 delete program;
1206 delete g_type_void;
1207 delete g_type_string;
1208 delete g_type_bool;
1209 delete g_type_byte;
1210 delete g_type_i16;
1211 delete g_type_i32;
1212 delete g_type_i64;
1213 delete g_type_double;
Mark Slee31985722006-05-24 21:45:31 +00001214
1215 // Finished
Mark Slee31985722006-05-24 21:45:31 +00001216 return 0;
1217}