compiler/cpp/src/main.cc

   1 // Copyright (c) 2006- Facebook
   2 // Distributed under the Thrift Software License
   3 //
   4 // See accompanying file LICENSE or visit the Thrift site at:
   5 // http://developers.facebook.com/thrift/
   6
   7 /**
   8  * thrift - a lightweight cross-language rpc/serialization tool
   9  *
  10  * This file contains the main compiler engine for Thrift, which invokes the
  11  * scanner/parser to build the thrift object tree. The interface generation
  12  * code for each language lives in a file by the language name under the
  13  * generate/ folder, and all parse structures live in parse/
  14  *
  15  * @author Mark Slee <mcslee@facebook.com>
  16  */
  17
  18 #include <stdlib.h>
  19 #include <stdio.h>
  20 #include <stdarg.h>
  21 #include <string>
  22 #include <sys/types.h>
  23 #include <sys/stat.h>
  24 #include <errno.h>
  25
  26 #ifdef MINGW
  27 # include <windows.h> /* for GetFullPathName */
  28 # include <limits.h>
  29 #endif
  30
  31 // Careful: must include globals first for extern definitions
  32 #include "globals.h"
  33
  34 #include "main.h"
  35 #include "parse/t_program.h"
  36 #include "parse/t_scope.h"
  37 #include "generate/t_cpp_generator.h"
  38 #include "generate/t_java_generator.h"
  39 #include "generate/t_php_generator.h"
  40 #include "generate/t_py_generator.h"
  41 #include "generate/t_rb_generator.h"
  42 #include "generate/t_xsd_generator.h"
  43 #include "generate/t_perl_generator.h"
  44 #include "generate/t_erl_generator.h"
  45 #include "generate/t_ocaml_generator.h"
  46 #include "generate/t_hs_generator.h"
  47 #include "generate/t_cocoa_generator.h"
  48 #include "generate/t_st_generator.h"
  49 #include "generate/t_csharp_generator.h"
  50
  51 using namespace std;
  52
  53 /**
  54  * Global program tree
  55  */
  56 t_program* g_program;
  57
  58 /**
  59  * Global types
  60  */
  61
  62 t_type* g_type_void;
  63 t_type* g_type_string;
  64 t_type* g_type_binary;
  65 t_type* g_type_slist;
  66 t_type* g_type_bool;
  67 t_type* g_type_byte;
  68 t_type* g_type_i16;
  69 t_type* g_type_i32;
  70 t_type* g_type_i64;
  71 t_type* g_type_double;
  72
  73 /**
  74  * Global scope
  75  */
  76 t_scope* g_scope;
  77
  78 /**
  79  * Parent scope to also parse types
  80  */
  81 t_scope* g_parent_scope;
  82
  83 /**
  84  * Prefix for putting types in parent scope
  85  */
  86 string g_parent_prefix;
  87
  88 /**
  89  * Parsing pass
  90  */
  91 PARSE_MODE g_parse_mode;
  92
  93 /**
  94  * Current directory of file being parsed
  95  */
  96 string g_curdir;
  97
  98 /**
  99  * Current file being parsed
 100  */
 101 string g_curpath;
 102
 103 /**
 104  * Search path for inclusions
 105  */
 106 vector<string> g_incl_searchpath;
 107
 108 /**
 109  * Global debug state
 110  */
 111 int g_debug = 0;
 112
 113 /**
 114  * Warning level
 115  */
 116 int g_warn = 1;
 117
 118 /**
 119  * Verbose output
 120  */
 121 int g_verbose = 0;
 122
 123 /**
 124  * Global time string
 125  */
 126 char* g_time_str;
 127
 128 /**
 129  * The last parsed doctext comment.
 130  */
 131 char* g_doctext;
 132
 133 /**
 134  * The location of the last parsed doctext comment.
 135  */
 136 int g_doctext_lineno;
 137
 138 /**
 139  * Flags to control code generation
 140  */
 141 bool gen_cpp = false;
 142 bool gen_dense = false;
 143 bool gen_java = false;
 144 bool gen_javabean = false;
 145 bool gen_rb = false;
 146 bool gen_py = false;
 147 bool gen_py_newstyle = false;
 148 bool gen_xsd = false;
 149 bool gen_php = false;
 150 bool gen_phpi = false;
 151 bool gen_phps = true;
 152 bool gen_phpa = false;
 153 bool gen_phpo = false;
 154 bool gen_rest = false;
 155 bool gen_perl = false;
 156 bool gen_erl = false;
 157 bool gen_ocaml = false;
 158 bool gen_hs = false;
 159 bool gen_cocoa = false;
 160 bool gen_csharp = false;
 161 bool gen_st = false;
 162 bool gen_recurse = false;
 163
 164 /**
 165  * MinGW doesn't have realpath, so use fallback implementation in that case,
 166  * otherwise this just calls through to realpath
 167  */
 168 char *saferealpath(const char *path, char *resolved_path) {
 169 #ifdef MINGW
 170   char buf[MAX_PATH];
 171   char* basename;
 172   DWORD len = GetFullPathName(path, MAX_PATH, buf, &basename);
 173   if (len == 0 || len > MAX_PATH - 1){
 174     strcpy(resolved_path, path);
 175   } else {
 176     CharLowerBuff(buf, len);
 177     strcpy(resolved_path, buf);
 178   }
 179   return resolved_path;
 180 #else
 181   return realpath(path, resolved_path);
 182 #endif
 183 }
 184
 185
 186 /**
 187  * Report an error to the user. This is called yyerror for historical
 188  * reasons (lex and yacc expect the error reporting routine to be called
 189  * this). Call this function to report any errors to the user.
 190  * yyerror takes printf style arguments.
 191  *
 192  * @param fmt C format string followed by additional arguments
 193  */
 194 void yyerror(char* fmt, ...) {
 195   va_list args;
 196   fprintf(stderr,
 197           "[ERROR:%s:%d] (last token was '%s')\n",
 198           g_curpath.c_str(),
 199           yylineno,
 200           yytext);
 201
 202   va_start(args, fmt);
 203   vfprintf(stderr, fmt, args);
 204   va_end(args);
 205
 206   fprintf(stderr, "\n");
 207 }
 208
 209 /**
 210  * Prints a debug message from the parser.
 211  *
 212  * @param fmt C format string followed by additional arguments
 213  */
 214 void pdebug(char* fmt, ...) {
 215   if (g_debug == 0) {
 216     return;
 217   }
 218   va_list args;
 219   printf("[PARSE:%d] ", yylineno);
 220   va_start(args, fmt);
 221   vprintf(fmt, args);
 222   va_end(args);
 223   printf("\n");
 224 }
 225
 226 /**
 227  * Prints a verbose output mode message
 228  *
 229  * @param fmt C format string followed by additional arguments
 230  */
 231 void pverbose(char* fmt, ...) {
 232   if (g_verbose == 0) {
 233     return;
 234   }
 235   va_list args;
 236   va_start(args, fmt);
 237   vprintf(fmt, args);
 238   va_end(args);
 239 }
 240
 241 /**
 242  * Prints a warning message
 243  *
 244  * @param fmt C format string followed by additional arguments
 245  */
 246 void pwarning(int level, char* fmt, ...) {
 247   if (g_warn < level) {
 248     return;
 249   }
 250   va_list args;
 251   printf("[WARNING:%s:%d] ", g_curpath.c_str(), yylineno);
 252   va_start(args, fmt);
 253   vprintf(fmt, args);
 254   va_end(args);
 255   printf("\n");
 256 }
 257
 258 /**
 259  * Prints a failure message and exits
 260  *
 261  * @param fmt C format string followed by additional arguments
 262  */
 263 void failure(const char* fmt, ...) {
 264   va_list args;
 265   fprintf(stderr, "[FAILURE:%s:%d] ", g_curpath.c_str(), yylineno);
 266   va_start(args, fmt);
 267   vfprintf(stderr, fmt, args);
 268   va_end(args);
 269   printf("\n");
 270   exit(1);
 271 }
 272
 273 /**
 274  * Converts a string filename into a thrift program name
 275  */
 276 string program_name(string filename) {
 277   string::size_type slash = filename.rfind("/");
 278   if (slash != string::npos) {
 279     filename = filename.substr(slash+1);
 280   }
 281   string::size_type dot = filename.rfind(".");
 282   if (dot != string::npos) {
 283     filename = filename.substr(0, dot);
 284   }
 285   return filename;
 286 }
 287
 288 /**
 289  * Gets the directory path of a filename
 290  */
 291 string directory_name(string filename) {
 292   string::size_type slash = filename.rfind("/");
 293   // No slash, just use the current directory
 294   if (slash == string::npos) {
 295     return ".";
 296   }
 297   return filename.substr(0, slash);
 298 }
 299
 300 /**
 301  * Finds the appropriate file path for the given filename
 302  */
 303 string include_file(string filename) {
 304   // Absolute path? Just try that
 305   if (filename[0] == '/') {
 306     // Realpath!
 307     char rp[PATH_MAX];
 308     if (saferealpath(filename.c_str(), rp) == NULL) {
 309       pwarning(0, "Cannot open include file %s\n", filename.c_str());
 310       return std::string();
 311     }
 312
 313     // Stat this file
 314     struct stat finfo;
 315     if (stat(rp, &finfo) == 0) {
 316       return rp;
 317     }
 318   } else { // relative path, start searching
 319     // new search path with current dir global
 320     vector<string> sp = g_incl_searchpath;
 321     sp.insert(sp.begin(), g_curdir);
 322
 323     // iterate through paths
 324     vector<string>::iterator it;
 325     for (it = sp.begin(); it != sp.end(); it++) {
 326       string sfilename = *(it) + "/" + filename;
 327
 328       // Realpath!
 329       char rp[PATH_MAX];
 330       if (saferealpath(sfilename.c_str(), rp) == NULL) {
 331         continue;
 332       }
 333
 334       // Stat this files
 335       struct stat finfo;
 336       if (stat(rp, &finfo) == 0) {
 337         return rp;
 338       }
 339     }
 340   }
 341
 342   // Uh oh
 343   pwarning(0, "Could not find include file %s\n", filename.c_str());
 344   return std::string();
 345 }
 346
 347 /**
 348  * Clears any previously stored doctext string.
 349  * Also prints a warning if we are discarding information.
 350  */
 351 void clear_doctext() {
 352   if (g_doctext != NULL) {
 353     pwarning(2, "Uncaptured doctext at on line %d.", g_doctext_lineno);
 354   }
 355   free(g_doctext);
 356   g_doctext = NULL;
 357 }
 358
 359 /**
 360  * Cleans up text commonly found in doxygen-like comments
 361  *
 362  * Warning: if you mix tabs and spaces in a non-uniform way,
 363  * you will get what you deserve.
 364  */
 365 char* clean_up_doctext(char* doctext) {
 366   // Convert to C++ string, and remove Windows's carriage returns.
 367   string docstring = doctext;
 368   docstring.erase(
 369       remove(docstring.begin(), docstring.end(), '\r'),
 370       docstring.end());
 371
 372   // Separate into lines.
 373   vector<string> lines;
 374   string::size_type pos = string::npos;
 375   string::size_type last;
 376   while (true) {
 377     last = (pos == string::npos) ? 0 : pos+1;
 378     pos = docstring.find('\n', last);
 379     if (pos == string::npos) {
 380       // First bit of cleaning.  If the last line is only whitespace, drop it.
 381       string::size_type nonwhite = docstring.find_first_not_of(" \t", last);
 382       if (nonwhite != string::npos) {
 383         lines.push_back(docstring.substr(last));
 384       }
 385       break;
 386     }
 387     lines.push_back(docstring.substr(last, pos-last));
 388   }
 389
 390   // A very profound docstring.
 391   if (lines.empty()) {
 392     return NULL;
 393   }
 394
 395   // Clear leading whitespace from the first line.
 396   pos = lines.front().find_first_not_of(" \t");
 397   lines.front().erase(0, pos);
 398
 399   // If every nonblank line after the first has the same number of spaces/tabs,
 400   // then a star, remove them.
 401   bool have_prefix = true;
 402   bool found_prefix = false;
 403   string::size_type prefix_len = 0;
 404   vector<string>::iterator l_iter;
 405   for (l_iter = lines.begin()+1; l_iter != lines.end(); ++l_iter) {
 406     if (l_iter->empty()) {
 407       continue;
 408     }
 409
 410     pos = l_iter->find_first_not_of(" \t");
 411     if (!found_prefix) {
 412       if (pos != string::npos) {
 413         if (l_iter->at(pos) == '*') {
 414           found_prefix = true;
 415           prefix_len = pos;
 416         } else {
 417           have_prefix = false;
 418           break;
 419         }
 420       } else {
 421         // Whitespace-only line.  Truncate it.
 422         l_iter->clear();
 423       }
 424     } else if (l_iter->size() > pos
 425         && l_iter->at(pos) == '*'
 426         && pos == prefix_len) {
 427       // Business as usual.
 428     } else if (pos == string::npos) {
 429       // Whitespace-only line.  Let's truncate it for them.
 430       l_iter->clear();
 431     } else {
 432       // The pattern has been broken.
 433       have_prefix = false;
 434       break;
 435     }
 436   }
 437
 438   // If our prefix survived, delete it from every line.
 439   if (have_prefix) {
 440     // Get the star too.
 441     prefix_len++;
 442     for (l_iter = lines.begin()+1; l_iter != lines.end(); ++l_iter) {
 443       l_iter->erase(0, prefix_len);
 444     }
 445   }
 446
 447   // Now delete the minimum amount of leading whitespace from each line.
 448   prefix_len = string::npos;
 449   for (l_iter = lines.begin()+1; l_iter != lines.end(); ++l_iter) {
 450     if (l_iter->empty()) {
 451       continue;
 452     }
 453     pos = l_iter->find_first_not_of(" \t");
 454     if (pos != string::npos
 455         && (prefix_len == string::npos || pos < prefix_len)) {
 456       prefix_len = pos;
 457     }
 458   }
 459
 460   // If our prefix survived, delete it from every line.
 461   if (prefix_len != string::npos) {
 462     for (l_iter = lines.begin()+1; l_iter != lines.end(); ++l_iter) {
 463       l_iter->erase(0, prefix_len);
 464     }
 465   }
 466
 467   // Remove trailing whitespace from every line.
 468   for (l_iter = lines.begin(); l_iter != lines.end(); ++l_iter) {
 469     pos = l_iter->find_last_not_of(" \t");
 470     if (pos != string::npos && pos != l_iter->length()-1) {
 471       l_iter->erase(pos+1);
 472     }
 473   }
 474
 475   // If the first line is empty, remove it.
 476   // Don't do this earlier because a lot of steps skip the first line.
 477   if (lines.front().empty()) {
 478     lines.erase(lines.begin());
 479   }
 480
 481   // Now rejoin the lines and copy them back into doctext.
 482   docstring.clear();
 483   for (l_iter = lines.begin(); l_iter != lines.end(); ++l_iter) {
 484     docstring += *l_iter;
 485     docstring += '\n';
 486   }
 487
 488   assert(docstring.length() <= strlen(doctext));
 489   strcpy(doctext, docstring.c_str());
 490   return doctext;
 491 }
 492
 493 /** Set to true to debug docstring parsing */
 494 static bool dump_docs = false;
 495
 496 /**
 497  * Dumps docstrings to stdout
 498  * Only works for top-level definitions and the whole program doc
 499  * (i.e., not enum constants, struct fields, or functions.
 500  */
 501 void dump_docstrings(t_program* program) {
 502   string progdoc = program->get_doc();
 503   if (!progdoc.empty()) {
 504     printf("Whole program doc:\n%s\n", progdoc.c_str());
 505   }
 506   const vector<t_typedef*>& typedefs = program->get_typedefs();
 507   vector<t_typedef*>::const_iterator t_iter;
 508   for (t_iter = typedefs.begin(); t_iter != typedefs.end(); ++t_iter) {
 509     t_typedef* td = *t_iter;
 510     if (td->has_doc()) {
 511       printf("typedef %s:\n%s\n", td->get_name().c_str(), td->get_doc().c_str());
 512     }
 513   }
 514   const vector<t_enum*>& enums = program->get_enums();
 515   vector<t_enum*>::const_iterator e_iter;
 516   for (e_iter = enums.begin(); e_iter != enums.end(); ++e_iter) {
 517     t_enum* en = *e_iter;
 518     if (en->has_doc()) {
 519       printf("enum %s:\n%s\n", en->get_name().c_str(), en->get_doc().c_str());
 520     }
 521   }
 522   const vector<t_const*>& consts = program->get_consts();
 523   vector<t_const*>::const_iterator c_iter;
 524   for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) {
 525     t_const* co = *c_iter;
 526     if (co->has_doc()) {
 527       printf("const %s:\n%s\n", co->get_name().c_str(), co->get_doc().c_str());
 528     }
 529   }
 530   const vector<t_struct*>& structs = program->get_structs();
 531   vector<t_struct*>::const_iterator s_iter;
 532   for (s_iter = structs.begin(); s_iter != structs.end(); ++s_iter) {
 533     t_struct* st = *s_iter;
 534     if (st->has_doc()) {
 535       printf("struct %s:\n%s\n", st->get_name().c_str(), st->get_doc().c_str());
 536     }
 537   }
 538   const vector<t_struct*>& xceptions = program->get_xceptions();
 539   vector<t_struct*>::const_iterator x_iter;
 540   for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) {
 541     t_struct* xn = *x_iter;
 542     if (xn->has_doc()) {
 543       printf("xception %s:\n%s\n", xn->get_name().c_str(), xn->get_doc().c_str());
 544     }
 545   }
 546   const vector<t_service*>& services = program->get_services();
 547   vector<t_service*>::const_iterator v_iter;
 548   for (v_iter = services.begin(); v_iter != services.end(); ++v_iter) {
 549     t_service* sv = *v_iter;
 550     if (sv->has_doc()) {
 551       printf("service %s:\n%s\n", sv->get_name().c_str(), sv->get_doc().c_str());
 552     }
 553   }
 554 }
 555
 556 /**
 557  * Call generate_fingerprint for every structure.
 558  */
 559 void generate_all_fingerprints(t_program* program) {
 560   const vector<t_struct*>& structs = program->get_structs();
 561   vector<t_struct*>::const_iterator s_iter;
 562   for (s_iter = structs.begin(); s_iter != structs.end(); ++s_iter) {
 563     t_struct* st = *s_iter;
 564     st->generate_fingerprint();
 565   }
 566
 567   const vector<t_struct*>& xceptions = program->get_xceptions();
 568   vector<t_struct*>::const_iterator x_iter;
 569   for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) {
 570     t_struct* st = *x_iter;
 571     st->generate_fingerprint();
 572   }
 573
 574   g_type_void->generate_fingerprint();
 575
 576   // If you want to generate fingerprints for implicit structures, start here.
 577   /*
 578   const vector<t_service*>& services = program->get_services();
 579   vector<t_service*>::const_iterator v_iter;
 580   for (v_iter = services.begin(); v_iter != services.end(); ++v_iter) {
 581     t_service* sv = *v_iter;
 582   }
 583   */
 584 }
 585
 586 /**
 587  * Diplays the usage message and then exits with an error code.
 588  */
 589 void usage() {
 590   fprintf(stderr, "Usage: thrift [options] file\n");
 591   fprintf(stderr, "Options:\n");
 592   fprintf(stderr, "  -cpp        Generate C++ output files\n");
 593   fprintf(stderr, "  -java       Generate Java output files\n");
 594   fprintf(stderr, "  -javabean   Generate Java bean-style output files\n");
 595   fprintf(stderr, "  -php        Generate PHP output files\n");
 596   fprintf(stderr, "  -phpi       Generate PHP inlined files\n");
 597   fprintf(stderr, "  -phps       Generate PHP server stubs (with -php)\n");
 598   fprintf(stderr, "  -phpl       Generate PHP-lite (with -php)\n");
 599   fprintf(stderr, "  -phpa       Generate PHP with autoload (with -php)\n");
 600   fprintf(stderr, "  -phpo       Generate PHP with object oriented subclasses (with -php)\n");
 601   fprintf(stderr, "  -py         Generate Python output files\n");
 602   fprintf(stderr, "  -pyns       Generate Python new-style classes (with -py)\n");
 603   fprintf(stderr, "  -rb         Generate Ruby output files\n");
 604   fprintf(stderr, "  -xsd        Generate XSD output files\n");
 605   fprintf(stderr, "  -perl       Generate Perl output files\n");
 606   fprintf(stderr, "  -erl        Generate Erlang output files\n");
 607   fprintf(stderr, "  -ocaml      Generate OCaml output files\n");
 608   fprintf(stderr, "  -hs         Generate Haskell output files\n");
 609   fprintf(stderr, "  -cocoa      Generate Cocoa/Objective-C output files\n");
 610   fprintf(stderr, "  -csharp     Generate C# output files\n");
 611   fprintf(stderr, "  -st         Generate Squeak/Smalltalk output files\n");
 612   fprintf(stderr, "  -o dir      Set the output directory for gen-* packages\n");
 613   fprintf(stderr, "               (default: current directory)\n");
 614   fprintf(stderr, "  -I dir      Add a directory to the list of directories\n");
 615   fprintf(stderr, "                searched for include directives\n");
 616   fprintf(stderr, "  -dense      Generate metadata for TDenseProtocol (C++)\n");
 617   fprintf(stderr, "  -rest       Generate PHP REST processors (with -php)\n");
 618   fprintf(stderr, "  -nowarn     Suppress all compiler warnings (BAD!)\n");
 619   fprintf(stderr, "  -strict     Strict compiler warnings on\n");
 620   fprintf(stderr, "  -v[erbose]  Verbose mode\n");
 621   fprintf(stderr, "  -r[ecurse]  Also generate included files\n");
 622   fprintf(stderr, "  -debug      Parse debug trace to stdout\n");
 623   exit(1);
 624 }
 625
 626 /**
 627  * You know, when I started working on Thrift I really thought it wasn't going
 628  * to become a programming language because it was just a generator and it
 629  * wouldn't need runtime type information and all that jazz. But then we
 630  * decided to add constants, and all of a sudden that means runtime type
 631  * validation and inference, except the "runtime" is the code generator
 632  * runtime. Shit. I've been had.
 633  */
 634 void validate_const_rec(std::string name, t_type* type, t_const_value* value) {
 635   if (type->is_void()) {
 636     throw "type error: cannot declare a void const: " + name;
 637   }
 638
 639   if (type->is_base_type()) {
 640     t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
 641     switch (tbase) {
 642     case t_base_type::TYPE_STRING:
 643       if (value->get_type() != t_const_value::CV_STRING) {
 644         throw "type error: const \"" + name + "\" was declared as string";
 645       }
 646       break;
 647     case t_base_type::TYPE_BOOL:
 648       if (value->get_type() != t_const_value::CV_INTEGER) {
 649         throw "type error: const \"" + name + "\" was declared as bool";
 650       }
 651       break;
 652     case t_base_type::TYPE_BYTE:
 653       if (value->get_type() != t_const_value::CV_INTEGER) {
 654         throw "type error: const \"" + name + "\" was declared as byte";
 655       }
 656       break;
 657     case t_base_type::TYPE_I16:
 658       if (value->get_type() != t_const_value::CV_INTEGER) {
 659         throw "type error: const \"" + name + "\" was declared as i16";
 660       }
 661       break;
 662     case t_base_type::TYPE_I32:
 663       if (value->get_type() != t_const_value::CV_INTEGER) {
 664         throw "type error: const \"" + name + "\" was declared as i32";
 665       }
 666       break;
 667     case t_base_type::TYPE_I64:
 668       if (value->get_type() != t_const_value::CV_INTEGER) {
 669         throw "type error: const \"" + name + "\" was declared as i64";
 670       }
 671       break;
 672     case t_base_type::TYPE_DOUBLE:
 673       if (value->get_type() != t_const_value::CV_INTEGER &&
 674           value->get_type() != t_const_value::CV_DOUBLE) {
 675         throw "type error: const \"" + name + "\" was declared as double";
 676       }
 677       break;
 678     default:
 679       throw "compiler error: no const of base type " + t_base_type::t_base_name(tbase) + name;
 680     }
 681   } else if (type->is_enum()) {
 682     if (value->get_type() != t_const_value::CV_INTEGER) {
 683       throw "type error: const \"" + name + "\" was declared as enum";
 684     }
 685   } else if (type->is_struct() || type->is_xception()) {
 686     if (value->get_type() != t_const_value::CV_MAP) {
 687       throw "type error: const \"" + name + "\" was declared as struct/xception";
 688     }
 689     const vector<t_field*>& fields = ((t_struct*)type)->get_members();
 690     vector<t_field*>::const_iterator f_iter;
 691
 692     const map<t_const_value*, t_const_value*>& val = value->get_map();
 693     map<t_const_value*, t_const_value*>::const_iterator v_iter;
 694     for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
 695       if (v_iter->first->get_type() != t_const_value::CV_STRING) {
 696         throw "type error: " + name + " struct key must be string";
 697       }
 698       t_type* field_type = NULL;
 699       for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
 700         if ((*f_iter)->get_name() == v_iter->first->get_string()) {
 701           field_type = (*f_iter)->get_type();
 702         }
 703       }
 704       if (field_type == NULL) {
 705         throw "type error: " + type->get_name() + " has no field " + v_iter->first->get_string();
 706       }
 707
 708       validate_const_rec(name + "." + v_iter->first->get_string(), field_type, v_iter->second);
 709     }
 710   } else if (type->is_map()) {
 711     t_type* k_type = ((t_map*)type)->get_key_type();
 712     t_type* v_type = ((t_map*)type)->get_val_type();
 713     const map<t_const_value*, t_const_value*>& val = value->get_map();
 714     map<t_const_value*, t_const_value*>::const_iterator v_iter;
 715     for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
 716       validate_const_rec(name + "<key>", k_type, v_iter->first);
 717       validate_const_rec(name + "<val>", v_type, v_iter->second);
 718     }
 719   } else if (type->is_list() || type->is_set()) {
 720     t_type* e_type;
 721     if (type->is_list()) {
 722       e_type = ((t_list*)type)->get_elem_type();
 723     } else {
 724       e_type = ((t_set*)type)->get_elem_type();
 725     }
 726     const vector<t_const_value*>& val = value->get_list();
 727     vector<t_const_value*>::const_iterator v_iter;
 728     for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
 729       validate_const_rec(name + "<elem>", e_type, *v_iter);
 730     }
 731   }
 732 }
 733
 734 /**
 735  * Check the type of the parsed const information against its declared type
 736  */
 737 void validate_const_type(t_const* c) {
 738   validate_const_rec(c->get_name(), c->get_type(), c->get_value());
 739 }
 740
 741 /**
 742  * Check the type of a default value assigned to a field.
 743  */
 744 void validate_field_value(t_field* field, t_const_value* cv) {
 745   validate_const_rec(field->get_name(), field->get_type(), cv);
 746 }
 747
 748 /**
 749  * Parses a program
 750  */
 751 void parse(t_program* program, t_program* parent_program) {
 752   // Get scope file path
 753   string path = program->get_path();
 754
 755   // Set current dir global, which is used in the include_file function
 756   g_curdir = directory_name(path);
 757   g_curpath = path;
 758
 759   // Open the file
 760   yyin = fopen(path.c_str(), "r");
 761   if (yyin == 0) {
 762     failure("Could not open input file: \"%s\"", path.c_str());
 763   }
 764
 765   // Create new scope and scan for includes
 766   pverbose("Scanning %s for includes\n", path.c_str());
 767   g_parse_mode = INCLUDES;
 768   g_program = program;
 769   g_scope = program->scope();
 770   try {
 771     yylineno = 1;
 772     if (yyparse() != 0) {
 773       failure("Parser error during include pass.");
 774     }
 775   } catch (string x) {
 776     failure(x.c_str());
 777   }
 778   fclose(yyin);
 779
 780   // Recursively parse all the include programs
 781   vector<t_program*>& includes = program->get_includes();
 782   vector<t_program*>::iterator iter;
 783   for (iter = includes.begin(); iter != includes.end(); ++iter) {
 784     parse(*iter, program);
 785   }
 786
 787   // Parse the program file
 788   g_parse_mode = PROGRAM;
 789   g_program = program;
 790   g_scope = program->scope();
 791   g_parent_scope = (parent_program != NULL) ? parent_program->scope() : NULL;
 792   g_parent_prefix = program->get_name() + ".";
 793   g_curpath = path;
 794   yyin = fopen(path.c_str(), "r");
 795   if (yyin == 0) {
 796     failure("Could not open input file: \"%s\"", path.c_str());
 797   }
 798   pverbose("Parsing %s for types\n", path.c_str());
 799   yylineno = 1;
 800   try {
 801     if (yyparse() != 0) {
 802       failure("Parser error during types pass.");
 803     }
 804   } catch (string x) {
 805     failure(x.c_str());
 806   }
 807   fclose(yyin);
 808 }
 809
 810 /**
 811  * Generate code
 812  */
 813 void generate(t_program* program) {
 814   // Oooohh, recursive code generation, hot!!
 815   if (gen_recurse) {
 816     const vector<t_program*>& includes = program->get_includes();
 817     for (size_t i = 0; i < includes.size(); ++i) {
 818       // Propogate output path from parent to child programs
 819       includes[i]->set_out_path(program->get_out_path());
 820
 821       generate(includes[i]);
 822     }
 823   }
 824
 825   // Generate code!
 826   try {
 827     pverbose("Program: %s\n", program->get_path().c_str());
 828
 829     // Compute fingerprints.
 830     generate_all_fingerprints(program);
 831
 832     if (gen_cpp) {
 833       pverbose("Generating C++\n");
 834       t_cpp_generator* cpp = new t_cpp_generator(program, gen_dense);
 835       cpp->generate_program();
 836       delete cpp;
 837     }
 838
 839     if (gen_java) {
 840       pverbose("Generating Java\n");
 841       t_java_generator* java = new t_java_generator(program, false);
 842       java->generate_program();
 843       delete java;
 844     }
 845
 846     if (gen_javabean) {
 847       pverbose("Generating Java Beans\n");
 848       t_java_generator* java = new t_java_generator(program, true);
 849       java->generate_program();
 850       delete java;
 851     }
 852
 853     if (gen_php) {
 854       pverbose("Generating PHP\n");
 855       t_php_generator* php = new t_php_generator(program, false, gen_rest, gen_phps, gen_phpa, gen_phpo);
 856       php->generate_program();
 857       delete php;
 858     }
 859
 860     if (gen_phpi) {
 861       pverbose("Generating PHP-inline\n");
 862       t_php_generator* phpi = new t_php_generator(program, true, gen_rest);
 863       phpi->generate_program();
 864       delete phpi;
 865     }
 866
 867     if (gen_py) {
 868       pverbose("Generating Python\n");
 869       t_py_generator* py = new t_py_generator(program, gen_py_newstyle);
 870       py->generate_program();
 871       delete py;
 872     }
 873
 874     if (gen_rb) {
 875       pverbose("Generating Ruby\n");
 876       t_rb_generator* rb = new t_rb_generator(program);
 877       rb->generate_program();
 878       delete rb;
 879     }
 880
 881     if (gen_xsd) {
 882       pverbose("Generating XSD\n");
 883       t_xsd_generator* xsd = new t_xsd_generator(program);
 884       xsd->generate_program();
 885       delete xsd;
 886     }
 887
 888     if (gen_perl) {
 889       pverbose("Generating PERL\n");
 890       t_perl_generator* perl = new t_perl_generator(program);
 891       perl->generate_program();
 892       delete perl;
 893     }
 894
 895     if (gen_erl) {
 896       pverbose("Generating Erlang\n");
 897       t_erl_generator* erl = new t_erl_generator(program);
 898       erl->generate_program();
 899       delete erl;
 900     }
 901
 902     if (gen_ocaml) {
 903       pverbose("Generating OCaml\n");
 904       t_ocaml_generator* ocaml = new t_ocaml_generator(program);
 905       ocaml->generate_program();
 906       delete ocaml;
 907     }
 908
 909     if (gen_hs) {
 910       pverbose("Generating Haskell\n");
 911       t_hs_generator* hs = new t_hs_generator(program);
 912       hs->generate_program();
 913       delete hs;
 914     }
 915
 916     if (gen_cocoa) {
 917       pverbose("Generating Cocoa/Objective-C\n");
 918       t_cocoa_generator* cocoa = new t_cocoa_generator(program);
 919       cocoa->generate_program();
 920       delete cocoa;
 921     }
 922
 923     if (gen_st) {
 924       pverbose("Generating Smalltalk/Squeak\n");
 925       t_st_generator* st = new t_st_generator(program);
 926       st->generate_program();
 927       delete st;
 928     }
 929
 930     if (gen_csharp) {
 931       pverbose("Generating C#\n");
 932       t_csharp_generator* csharp = new t_csharp_generator(program);
 933       csharp->generate_program();
 934       delete csharp;
 935     }
 936
 937     if (dump_docs) {
 938       dump_docstrings(program);
 939     }
 940   } catch (string s) {
 941     printf("Error: %s\n", s.c_str());
 942   } catch (const char* exc) {
 943     printf("Error: %s\n", exc);
 944   }
 945
 946 }
 947
 948 /**
 949  * Parse it up.. then spit it back out, in pretty much every language. Alright
 950  * not that many languages, but the cool ones that we care about.
 951  */
 952 int main(int argc, char** argv) {
 953   int i;
 954   std::string out_path;
 955
 956   // Setup time string
 957   time_t now = time(NULL);
 958   g_time_str = ctime(&now);
 959
 960   // Check for necessary arguments, you gotta have at least a filename and
 961   // an output language flag
 962   if (argc < 2) {
 963     usage();
 964   }
 965
 966   // Hacky parameter handling... I didn't feel like using a library sorry!
 967   for (i = 1; i < argc-1; i++) {
 968     char* arg;
 969
 970     arg = strtok(argv[i], " ");
 971     while (arg != NULL) {
 972       // Treat double dashes as single dashes
 973       if (arg[0] == '-' && arg[1] == '-') {
 974         ++arg;
 975       }
 976
 977       if (strcmp(arg, "-debug") == 0) {
 978         g_debug = 1;
 979       } else if (strcmp(arg, "-nowarn") == 0) {
 980         g_warn = 0;
 981       } else if (strcmp(arg, "-strict") == 0) {
 982         g_warn = 2;
 983       } else if (strcmp(arg, "-v") == 0 || strcmp(arg, "-verbose") == 0 ) {
 984         g_verbose = 1;
 985       } else if (strcmp(arg, "-r") == 0 || strcmp(arg, "-recurse") == 0 ) {
 986         gen_recurse = true;
 987       } else if (strcmp(arg, "-dense") == 0) {
 988         gen_dense = true;
 989       } else if (strcmp(arg, "-cpp") == 0) {
 990         gen_cpp = true;
 991       } else if (strcmp(arg, "-javabean") == 0) {
 992         gen_javabean = true;
 993       } else if (strcmp(arg, "-java") == 0) {
 994         gen_java = true;
 995       } else if (strcmp(arg, "-php") == 0) {
 996         gen_php = true;
 997       } else if (strcmp(arg, "-phpi") == 0) {
 998         gen_phpi = true;
 999       } else if (strcmp(arg, "-phps") == 0) {
1000         gen_php = true;
1001         gen_phps = true;
1002       } else if (strcmp(arg, "-phpl") == 0) {
1003         gen_php = true;
1004         gen_phps = false;
1005       } else if (strcmp(arg, "-phpa") == 0) {
1006         gen_php = true;
1007         gen_phps = false;
1008         gen_phpa = true;
1009       } else if (strcmp(arg, "-phpo") == 0) {
1010         gen_php = true;
1011         gen_phpo = true;
1012       } else if (strcmp(arg, "-rest") == 0) {
1013         gen_rest = true;
1014       } else if (strcmp(arg, "-py") == 0) {
1015         gen_py = true;
1016       } else if (strcmp(arg, "-pyns") == 0) {
1017         gen_py = true;
1018         gen_py_newstyle = true;
1019       } else if (strcmp(arg, "-rb") == 0) {
1020         gen_rb = true;
1021       } else if (strcmp(arg, "-xsd") == 0) {
1022         gen_xsd = true;
1023       } else if (strcmp(arg, "-perl") == 0) {
1024         gen_perl = true;
1025       } else if (strcmp(arg, "-erl") == 0) {
1026         gen_erl = true;
1027       } else if (strcmp(arg, "-ocaml") == 0) {
1028         gen_ocaml = true;
1029       } else if (strcmp(arg, "-hs") == 0) {
1030         gen_hs = true;
1031       } else if (strcmp(arg, "-cocoa") == 0) {
1032         gen_cocoa = true;
1033       } else if (strcmp(arg, "-st") == 0) {
1034         gen_st = true;
1035       } else if (strcmp(arg, "-csharp") == 0) {
1036         gen_csharp = true;
1037       } else if (strcmp(arg, "-I") == 0) {
1038         // An argument of "-I\ asdf" is invalid and has unknown results
1039         arg = argv[++i];
1040
1041         if (arg == NULL) {
1042           fprintf(stderr, "!!! Missing Include directory");
1043           usage();
1044         }
1045         g_incl_searchpath.push_back(arg);
1046       } else if (strcmp(arg, "-o") == 0) {
1047         arg = argv[++i];
1048         if (arg == NULL) {
1049           fprintf(stderr, "-o: missing output directory");
1050           usage();
1051         }
1052         out_path = arg;
1053
1054 #ifdef MINGW
1055         //strip out trailing \ on Windows
1056         int last = out_path.length()-1;
1057         if (out_path[last] == '\\')
1058         {
1059           out_path.erase(last);
1060         }
1061 #endif
1062
1063         struct stat sb;
1064         if (stat(out_path.c_str(), &sb) < 0) {
1065           fprintf(stderr, "Output directory %s is unusable: %s\n", out_path.c_str(), strerror(errno));
1066           return -1;
1067         }
1068         if (! S_ISDIR(sb.st_mode)) {
1069           fprintf(stderr, "Output directory %s exists but is not a directory\n", out_path.c_str());
1070           return -1;
1071         }
1072       } else {
1073         fprintf(stderr, "!!! Unrecognized option: %s\n", arg);
1074         usage();
1075       }
1076
1077       // Tokenize more
1078       arg = strtok(NULL, " ");
1079     }
1080   }
1081
1082   // You gotta generate something!
1083   if (!gen_cpp && !gen_java && !gen_javabean && !gen_php && !gen_phpi && !gen_py && !gen_rb && !gen_xsd && !gen_perl && !gen_erl && !gen_ocaml && !gen_hs && !gen_cocoa && !gen_st && !gen_csharp) {
1084     fprintf(stderr, "!!! No output language(s) specified\n\n");
1085     usage();
1086   }
1087
1088   // Real-pathify it
1089   char rp[PATH_MAX];
1090   if (saferealpath(argv[i], rp) == NULL) {
1091     failure("Could not open input file with realpath: %s", argv[i]);
1092   }
1093   string input_file(rp);
1094
1095   // Instance of the global parse tree
1096   t_program* program = new t_program(input_file);
1097   if (out_path.size()) {
1098     program->set_out_path(out_path);
1099   }
1100
1101   // Initialize global types
1102   g_type_void   = new t_base_type("void",   t_base_type::TYPE_VOID);
1103   g_type_string = new t_base_type("string", t_base_type::TYPE_STRING);
1104   g_type_binary = new t_base_type("string", t_base_type::TYPE_STRING);
1105   ((t_base_type*)g_type_binary)->set_binary(true);
1106   g_type_slist  = new t_base_type("string", t_base_type::TYPE_STRING);
1107   ((t_base_type*)g_type_slist)->set_string_list(true);
1108   g_type_bool   = new t_base_type("bool",   t_base_type::TYPE_BOOL);
1109   g_type_byte   = new t_base_type("byte",   t_base_type::TYPE_BYTE);
1110   g_type_i16    = new t_base_type("i16",    t_base_type::TYPE_I16);
1111   g_type_i32    = new t_base_type("i32",    t_base_type::TYPE_I32);
1112   g_type_i64    = new t_base_type("i64",    t_base_type::TYPE_I64);
1113   g_type_double = new t_base_type("double", t_base_type::TYPE_DOUBLE);
1114
1115   // Parse it!
1116   parse(program, NULL);
1117
1118   // Generate it!
1119   generate(program);
1120
1121   // Clean up. Who am I kidding... this program probably orphans heap memory
1122   // all over the place, but who cares because it is about to exit and it is
1123   // all referenced and used by this wacky parse tree up until now anyways.
1124
1125   delete program;
1126   delete g_type_void;
1127   delete g_type_string;
1128   delete g_type_bool;
1129   delete g_type_byte;
1130   delete g_type_i16;
1131   delete g_type_i32;
1132   delete g_type_i64;
1133   delete g_type_double;
1134
1135   // Finished
1136   return 0;
1137 }