compilation_tools/vtsc/VtsCompilerMain.cpp

/*
 * Copyright 2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <dirent.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>

#include <iostream>

#include <android-base/logging.h>
#include "VtsCompilerUtils.h"
#include "code_gen/CodeGenBase.h"

using namespace std;

// To generate both header and source files,
//   Usage: vtsc -mDRIVER | -mPROFILER <.vts input file path> \
//          <header output dir> <C/C++ source output file path>
// To generate only a header file,
//   Usage: vtsc -mDRIVER | -mPROFILER -tHEADER -b<base path> \
//          <.vts input file or dir path> <header output file or dir path>
// To generate only a source file,
//   Usage: vtsc -mDRIVER | -mPROFILER -tSOURCE -b<base path> \
//          <.vts input file or dir path> \
//          <C/C++ source output file or dir path>
// where <base path> is a base path of where .vts input file or dir is
// stored but should be excluded when computing the package path of generated
// source or header output file(s).

int main(int argc, char* argv[]) {
#ifdef VTS_DEBUG
  cout << "Android VTS Compiler (AVTSC)" << endl;
#endif
  int opt_count = 0;
  android::vts::VtsCompileMode mode = android::vts::kDriver;
  android::vts::VtsCompileFileType type = android::vts::VtsCompileFileType::kBoth;
  string vts_base_dir;
  for (int i = 0; i < argc; i++) {
#ifdef VTS_DEBUG
    cout << "- args[" << i << "] " << argv[i] << endl;
#endif
    if (argv[i] && strlen(argv[i]) > 1 && argv[i][0] == '-') {
      opt_count++;
      if (argv[i][1] == 'm') {
        if (!strcmp(&argv[i][2], "PROFILER")) {
          mode = android::vts::kProfiler;
#ifdef VTS_DEBUG
          cout << "- mode: PROFILER" << endl;
#endif
        } else if (!strcmp(&argv[i][2], "FUZZER")) {
          mode = android::vts::kFuzzer;
#ifdef VTS_DEBUG
          cout << "- mode: FUZZER" << endl;
#endif
        }
      }
      if (argv[i][1] == 't') {
        if (!strcmp(&argv[i][2], "HEADER")) {
          type = android::vts::kHeader;
#ifdef VTS_DEBUG
          cout << "- type: HEADER" << endl;
#endif
        } else if (!strcmp(&argv[i][2], "SOURCE")) {
          type = android::vts::kSource;
#ifdef VTS_DEBUG
          cout << "- type: SOURCE" << endl;
#endif
        }
      }
      if (argv[i][1] == 'b') {
        vts_base_dir = &argv[i][2];
#ifdef VTS_DEBUG
        cout << "- VTS base dir: " << vts_base_dir << endl;
#endif
      }
    }
  }
  if (argc < 5) {
    cerr << "argc " << argc << " < 5" << endl;
    return -1;
  }
  switch (type) {
    case android::vts::kBoth:
      android::vts::Translate(
          mode, argv[opt_count + 1], argv[opt_count + 2], argv[opt_count + 3]);
      break;
    case android::vts::kHeader:
    case android::vts::kSource: {
      struct stat s;
      bool is_dir = false;
      if (vts_base_dir.length() > 0) {
        if (chdir(vts_base_dir.c_str())) {
          cerr << __func__ << " can't chdir to " << vts_base_dir << endl;
          exit(-1);
        }
      }
      if (stat(argv[opt_count + 1], &s) == 0) {
        if (s.st_mode & S_IFDIR) {
          is_dir = true;
        }
      }
      if (!is_dir) {
        android::vts::TranslateToFile(
            mode, argv[opt_count + 1], argv[opt_count + 2], type);
      } else {
        DIR* input_dir;
        struct dirent* ent;
        if ((input_dir = opendir(argv[opt_count + 1])) != NULL) {
          // argv[opt_count + 2] should be a directory. if that dir does not exist,
          // that dir is created as part of the translation operation.
          while ((ent = readdir(input_dir)) != NULL) {
            if (!strncmp(&ent->d_name[strlen(ent->d_name)-4], ".vts", 4)) {
              string src_file = android::vts::RemoveBaseDir(
                  android::vts::PathJoin(
                      argv[opt_count + 1], ent->d_name), vts_base_dir);
              string dst_file = android::vts::RemoveBaseDir(
                  android::vts::PathJoin(
                      argv[opt_count + 2], ent->d_name), vts_base_dir);
              if (type == android::vts::kHeader) {
                dst_file = android::vts::PathJoin(dst_file.c_str(), ".h");
              } else {
                dst_file = android::vts::PathJoin(dst_file.c_str(), ".cpp");
              }
#ifdef VTS_DEBUG
              cout << ent->d_name << endl;
              cout << "<- " << src_file.c_str() << endl;
              cout << "-> " << dst_file.c_str() << endl;
#endif
              android::vts::TranslateToFile(
                  mode, src_file.c_str(), dst_file.c_str(), type);
            }
          }
          closedir(input_dir);
        } else {
          cerr << __func__ << " can't open the given input dir, "
               << argv[opt_count + 1] << "." << endl;
          exit(-1);
        }
      }
      break;
    }
  }
  return 0;
}