xsdconvert/converter.cc

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Copyright (c) 2000-2015 Ericsson Telecom AB
   3 // All rights reserved. This program and the accompanying materials
   4 // are made available under the terms of the Eclipse Public License v1.0
   5 // which accompanies this distribution, and is available at
   6 // http://www.eclipse.org/legal/epl-v10.html
   7 ///////////////////////////////////////////////////////////////////////////////
   8 #include "XMLParser.hh"
   9 #include "TTCN3Module.hh"
  10 #include "TTCN3ModuleInventory.hh"
  11 #include "SimpleType.hh"
  12 #include "ComplexType.hh"
  13
  14 #include "../common/version_internal.h"
  15 #include "../common/license.h"
  16
  17 #include <unistd.h> // for using "getopt" function
  18 #include <sys/stat.h>
  19
  20 bool c_flag_used = false;
  21 int  d_flag_used = 0;
  22 bool e_flag_used = false;
  23 bool f_flag_used = false;
  24 bool g_flag_used = true;
  25 bool h_flag_used = false;
  26 bool p_flag_used = false;
  27 bool s_flag_used = false;
  28 bool t_flag_used = false;
  29 bool q_flag_used = false;
  30 bool w_flag_used = false;
  31 bool x_flag_used = false;
  32 bool z_flag_used = false;
  33
  34 static void printProductinfo();
  35 static void printUsage(const char * argv0);
  36 static void printVersion();
  37 static void printErrorStatistics(const unsigned int errors, const unsigned int warnings);
  38 static bool generatePredefinedModules();
  39 static char **readModulesFromFile(const char *from_file, int *last_module);
  40 static int checkSyntax(const bool not_verbose, const int first_module, const int last_module,
  41   const char * const * const module_names);
  42 static int validate(int const first_module, int const last_module,
  43   const char * const * const module_names);
  44 static int generateCode(const bool quiet, const bool need_predefined,
  45   const int first_module, const int last_module,
  46   const char * const * const module_names);
  47
  48 int main(int argc, char **argv) {
  49   if (argc == 1) {
  50     printProductinfo();
  51     printUsage(argv[0]);
  52     return EXIT_SUCCESS;
  53   }
  54
  55   // The file holding a list of the XSD files.
  56   const char *from_file = NULL;
  57   char c;
  58   opterr = 0;
  59
  60   while ((c = getopt(argc, argv, "cdef:ghpqstvwxz")) != -1) {
  61     switch (c) {
  62       case 'c':
  63         c_flag_used = true;
  64         break;
  65       case 'd':
  66         ++d_flag_used;
  67         break;
  68       case 'e':
  69         e_flag_used = true;
  70         break;
  71       case 'f':
  72         f_flag_used = true;
  73         from_file = optarg;
  74         break;
  75       case 'g':
  76         g_flag_used = false;
  77         break;
  78       case 'h':
  79         h_flag_used = true;
  80         break;
  81       case 'p':
  82         p_flag_used = true;
  83         break;
  84       case 's':
  85         s_flag_used = true;
  86         break;
  87       case 't':
  88         t_flag_used = true;
  89         break;
  90       case 'v':
  91         printProductinfo();
  92         printVersion();
  93 #ifdef LICENSE
  94         print_license_info();
  95 #endif
  96         return EXIT_SUCCESS;
  97       case 'q':
  98         q_flag_used = true;
  99         break;
 100       case 'w':
 101         w_flag_used = true;
 102         break;
 103       case 'x':
 104         x_flag_used = true;
 105         break;
 106       case 'z':
 107         z_flag_used = true;
 108         break;
 109       default:
 110         fprintf(stderr, "ERROR:\nInvalid option: -%c!\n", char(optopt));
 111         printUsage(argv[0]);
 112         return EXIT_FAILURE;
 113     }
 114   }
 115
 116   int first_module = f_flag_used ? 0 : optind;
 117   int last_module = f_flag_used ? 0 : argc;
 118   char **module_names = f_flag_used ? NULL : argv;
 119   try {
 120     if (f_flag_used) {
 121       // Idea from CR_TR00015706.
 122       module_names = readModulesFromFile(from_file, &last_module);
 123       if (!module_names) {
 124         fprintf(stderr, "ERROR: The file `%s' holding the XSD files cannot be "
 125           "processed!\n", from_file);
 126         throw 1;
 127       }
 128     }
 129
 130     if (last_module - first_module <= 0) {
 131       fprintf(stderr, "ERROR:\nNo module name was specified!\n");
 132       printUsage(argv[0]);
 133       throw 1;
 134     }
 135
 136 #ifdef LICENSE
 137     {
 138       init_openssl();
 139       license_struct lstr;
 140       load_license(&lstr);
 141       int license_valid = verify_license(&lstr);
 142       free_license(&lstr);
 143       free_openssl();
 144       if (!license_valid) {
 145         exit(EXIT_FAILURE);
 146       }
 147     }
 148 #endif
 149
 150     for (int i = first_module; i < last_module; ++i) {
 151       if (!fopen(module_names[i], "r")) {
 152         fprintf(stderr, "ERROR:\nInput file `%s' does not exist.\n",
 153           module_names[i]);
 154         throw 1;
 155       }
 156     }
 157
 158     if (checkSyntax(q_flag_used, first_module, last_module, module_names) == EXIT_FAILURE) {
 159       throw 1;
 160     }
 161
 162     if (validate(first_module, last_module, module_names) == EXIT_FAILURE) {
 163       throw 1;
 164     }
 165
 166     if (s_flag_used) {
 167       printErrorStatistics(XMLParser::getNumErrors(),
 168         XMLParser::getNumWarnings());
 169       if (XMLParser::getNumErrors() > 0) {
 170         throw 1;
 171       }
 172       return EXIT_SUCCESS;
 173     }
 174
 175     if (generateCode(q_flag_used, p_flag_used, first_module, last_module,
 176       module_names) == EXIT_FAILURE) {
 177       throw 1;
 178     }
 179   } catch (int) {
 180     if (f_flag_used) {
 181       for (int i = 0; i < last_module; ++i) {
 182         Free(module_names[i]);
 183       }
 184       Free(module_names);
 185     }
 186     return EXIT_FAILURE;
 187   }
 188
 189   if (XMLParser::getNumWarnings() > 0 ||
 190     TTCN3ModuleInventory::getNumErrors() > 0 ||
 191     TTCN3ModuleInventory::getNumWarnings() > 0) {
 192     printErrorStatistics(TTCN3ModuleInventory::getNumErrors(),
 193       XMLParser::getNumWarnings() + TTCN3ModuleInventory::getNumWarnings());
 194   }
 195
 196   return EXIT_SUCCESS;
 197 }
 198
 199 static void printProductinfo() {
 200   fputs("XSD to TTCN-3 Converter for the TTCN-3 Test Executor, version "
 201     PRODUCT_NUMBER "\n", stderr);
 202 }
 203
 204 static void printUsage(const char * argv0) {
 205   fprintf(stderr, "\n"
 206     "usage: %s [-ceghpstVwx] [-f file] schema.xsd ...\n"
 207     "   or %s -v\n"
 208     "\n"
 209     "OPTIONS:\n"
 210     "   -c:             disable the generation of comments in TTCN-3 modules\n"
 211     "   -e:             disable the generation of encoding instructions in TTCN-3 modules\n"
 212     "   -f file:        the names of XSD files are taken from file instead of the command line\n"
 213     "   -g:             generate TTCN-3 code disallowing element substitution\n"
 214     "   -h:             generate TTCN-3 code allowing type substitution\n"
 215     "   -p:             do not generate the UsefulTtcn3Types and XSD predefined modules\n"
 216     "   -q:             quiet mode - disable the issue of status messages\n"
 217     "   -s:             parse and validate only - no TTCN-3 module generation\n"
 218     "   -t:             disable the generation of timing information in TTCN-3 modules\n"
 219     "   -v:             show version information\n"
 220     "   -w:             suppress warnings\n"
 221     "   -x:             disable schema validation but generate TTCN-3 modules\n"
 222     "   -z:             zap URI scheme from module name\n"
 223     , argv0, argv0);
 224 }
 225
 226 static void printVersion() {
 227   fputs("Product number: " PRODUCT_NUMBER "\n"
 228     "Build date: " __DATE__ " " __TIME__ "\n"
 229     "Compiled with: " C_COMPILER_VERSION "\n\n"
 230     COPYRIGHT_STRING "\n\n", stderr);
 231 }
 232
 233 static void printErrorStatistics(const unsigned int errors, const unsigned int warnings) {
 234   if (errors == 0) {
 235     if (warnings == 0) {
 236       fprintf(stderr,
 237         "Notify: No errors or warnings were detected.\n");
 238     } else {
 239       fprintf(stderr,
 240         "Notify: No errors and %u warning%s were detected.\n",
 241         warnings,
 242         warnings > 1 ? "s" : "");
 243     }
 244   } else {
 245     if (warnings == 0) {
 246       fprintf(stderr,
 247         "Notify: %u error%s and no warnings were detected.\n",
 248         errors,
 249         errors > 1 ? "s" : "");
 250     } else {
 251       fprintf(stderr,
 252         "Notify: %u error%s and %u warning%s were detected.\n",
 253         errors,
 254         errors > 1 ? "s" : "",
 255         warnings,
 256         warnings > 1 ? "s" : "");
 257     }
 258   }
 259 }
 260
 261 static bool checkFailure() {
 262   if (TTCN3ModuleInventory::getNumErrors() > 0) {
 263     printErrorStatistics(TTCN3ModuleInventory::getNumErrors(),
 264       XMLParser::getNumWarnings() + TTCN3ModuleInventory::getNumWarnings());
 265     return true;
 266   } else {
 267     return false;
 268   }
 269 }
 270
 271 static bool generatePredefinedModules() {
 272   struct stat stFileInfo;
 273   // Only generate the missing predefined modules.
 274   if (stat("UsefulTtcn3Types.ttcn", &stFileInfo) != 0) {
 275     extern const char *moduleUsefulTtcn3Types;
 276     FILE *fileUsefulTtcn3Types = fopen("UsefulTtcn3Types.ttcn", "w");
 277     if (fileUsefulTtcn3Types == NULL) {
 278       fprintf(stderr, "ERROR:\nCannot create file UsefulTtcn3Types.ttcn!\n");
 279       return false;
 280     }
 281     fprintf(fileUsefulTtcn3Types, "%s", moduleUsefulTtcn3Types);
 282     if (!q_flag_used) {
 283       fprintf(stderr, "Notify: File \'UsefulTtcn3Types.ttcn\' was generated.\n");
 284     }
 285     fclose(fileUsefulTtcn3Types);
 286   }
 287
 288   //XSD.ttcn changed
 289   //if (stat("XSD.ttcn", &stFileInfo) != 0) {
 290     extern const char *moduleXSD;
 291     FILE *fileXsd = fopen("XSD.ttcn", "w");
 292     if (fileXsd == NULL) {
 293       fprintf(stderr, "ERROR:\nCannot create file XSD.ttcn!\n");
 294       return false;
 295     }
 296     fprintf(fileXsd, "%s", moduleXSD);
 297     if (!q_flag_used) {
 298       fprintf(stderr, "Notify: File \'XSD.ttcn\' was generated.\n");
 299     }
 300     fclose(fileXsd);
 301   //}
 302   return true;
 303 }
 304
 305 static char **readModulesFromFile(const char *from_file, int *last_module) {
 306   FILE *input = fopen(from_file, "r");
 307   if (!input) return NULL;
 308   // It should be a relatively small file.
 309   fseek(input, 0, SEEK_END);
 310   size_t input_bytes = ftell(input);
 311   rewind(input);
 312   size_t buf_len = input_bytes + 1; // sizeof(char)==1 by definition
 313   char *buf = (char *) Malloc(buf_len);
 314   buf[buf_len - 1] = 0;
 315   size_t bytes_read = fread(buf, 1, input_bytes, input);
 316   fclose(input);
 317   if ((size_t) input_bytes != bytes_read) {
 318     Free(buf);
 319     return NULL;
 320   }
 321   char **ret_val = NULL;
 322   *last_module = 0;
 323   const char *delim = " \f\n\r\t\v";
 324   char *name = strtok(buf, delim);
 325   while (name) {
 326     if (!strlen(name))
 327       continue;
 328     ret_val = (char **) Realloc(ret_val, sizeof (char *) * ++(*last_module));
 329     ret_val[*last_module - 1] = mcopystr(name);
 330     name = strtok(NULL, delim);
 331   }
 332   Free(buf);
 333   return ret_val;
 334 }
 335
 336 static int checkSyntax(const bool not_verbose, const int first_module, const int last_module,
 337   const char * const * const module_names) {
 338   if (!not_verbose) {
 339     fprintf(stderr, "Notify: Checking documents...\n");
 340   }
 341   for (int i = first_module; i < last_module; ++i) {
 342     if (!not_verbose) {
 343       fprintf(stderr, "Notify: Parsing XML schema document `%s'...\n",
 344         module_names[i]);
 345     }
 346     XMLParser syntaxchecker(module_names[i]);
 347     syntaxchecker.checkSyntax();
 348   }
 349   if (XMLParser::getNumErrors() > 0) {
 350     printErrorStatistics(XMLParser::getNumErrors(),
 351       XMLParser::getNumWarnings());
 352     return EXIT_FAILURE;
 353   }
 354   return EXIT_SUCCESS;
 355 }
 356
 357 static int generateCode(const bool quiet, const bool need_predefined,
 358   const int first_module, const int last_module,
 359   const char * const * const module_names) {
 360   TTCN3ModuleInventory& modules = TTCN3ModuleInventory::getInstance();
 361   for (int i = first_module; i < last_module; ++i) {
 362     XMLParser parser(module_names[i]);
 363     TTCN3Module *module = modules.addModule(module_names[i], &parser);
 364     parser.startConversion(module);
 365     module->goodbyeParser(); // the parser is going away, don't use it
 366   }
 367
 368   if (XMLParser::getNumErrors() > 0) {
 369     printErrorStatistics(XMLParser::getNumErrors(),
 370       XMLParser::getNumWarnings());
 371     return EXIT_FAILURE;
 372   }
 373
 374   if (d_flag_used > 1) {
 375     modules.dump();
 376     fputs("+++++++++++++++++++++++++++++\n", stderr);
 377   }
 378
 379   modules.modulenameConversion();
 380   modules.referenceResolving();
 381   modules.nameConversion();
 382   modules.finalModification();
 383
 384   if (d_flag_used > 0) {
 385     modules.dump();
 386   }
 387
 388   if (checkFailure()) {
 389     return EXIT_FAILURE;
 390   }
 391
 392   if (!quiet) {
 393     fprintf(stderr, "Notify: Generating TTCN-3 modules...\n");
 394   }
 395
 396   modules.moduleGeneration();
 397
 398   if (checkFailure()) {
 399     return EXIT_FAILURE;
 400   }
 401
 402   if (!need_predefined) {
 403     if (!generatePredefinedModules()) {
 404       return EXIT_FAILURE;
 405     }
 406   }
 407   return EXIT_SUCCESS;
 408 }
 409
 410 static int validate(const int first_module, const int last_module,
 411   const char * const * const module_names) {
 412   for (int i = first_module; i < last_module; ++i) {
 413     XMLParser validator(module_names[i]);
 414     validator.validate();
 415   }
 416   if (XMLParser::getNumErrors() > 0) {
 417     printErrorStatistics(XMLParser::getNumErrors(),
 418       XMLParser::getNumWarnings());
 419     return EXIT_FAILURE;
 420   }
 421   return EXIT_SUCCESS;
 422 }
 423
 424 reffer::reffer(const char*) {
 425 }