Home | History | Annotate | Download | only in kati
      1 // Copyright 2015 Google Inc. All rights reserved
      2 //
      3 // Licensed under the Apache License, Version 2.0 (the "License");
      4 // you may not use this file except in compliance with the License.
      5 // You may obtain a copy of the License at
      6 //
      7 //      http://www.apache.org/licenses/LICENSE-2.0
      8 //
      9 // Unless required by applicable law or agreed to in writing, software
     10 // distributed under the License is distributed on an "AS IS" BASIS,
     11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     12 // See the License for the specific language governing permissions and
     13 // limitations under the License.
     14 
     15 // +build ignore
     16 
     17 #include "flags.h"
     18 
     19 #include <stdlib.h>
     20 #include <unistd.h>
     21 
     22 #include "log.h"
     23 #include "strutil.h"
     24 
     25 Flags g_flags;
     26 
     27 static bool ParseCommandLineOptionWithArg(StringPiece option,
     28                                           char* argv[],
     29                                           int* index,
     30                                           const char** out_arg) {
     31   const char* arg = argv[*index];
     32   if (!HasPrefix(arg, option))
     33     return false;
     34   if (arg[option.size()] == '\0') {
     35     ++*index;
     36     *out_arg = argv[*index];
     37     return true;
     38   }
     39   if (arg[option.size()] == '=') {
     40     *out_arg = arg + option.size() + 1;
     41     return true;
     42   }
     43   // E.g, -j999
     44   if (option.size() == 2) {
     45     *out_arg = arg + option.size();
     46     return true;
     47   }
     48   return false;
     49 }
     50 
     51 void Flags::Parse(int argc, char** argv) {
     52   subkati_args.push_back(argv[0]);
     53   num_jobs = num_cpus = sysconf(_SC_NPROCESSORS_ONLN);
     54   const char* num_jobs_str;
     55 
     56   if (const char* makeflags = getenv("MAKEFLAGS")) {
     57     for (StringPiece tok : WordScanner(makeflags)) {
     58       if (!HasPrefix(tok, "-") && tok.find('=') != string::npos)
     59         cl_vars.push_back(tok);
     60     }
     61   }
     62 
     63   for (int i = 1; i < argc; i++) {
     64     const char* arg = argv[i];
     65     bool should_propagate = true;
     66     int pi = i;
     67     if (!strcmp(arg, "-f")) {
     68       makefile = argv[++i];
     69       should_propagate = false;
     70     } else if (!strcmp(arg, "-c")) {
     71       is_syntax_check_only = true;
     72     } else if (!strcmp(arg, "-i")) {
     73       is_dry_run = true;
     74     } else if (!strcmp(arg, "-s")) {
     75       is_silent_mode = true;
     76     } else if (!strcmp(arg, "-d")) {
     77       enable_debug = true;
     78     } else if (!strcmp(arg, "--kati_stats")) {
     79       enable_stat_logs = true;
     80     } else if (!strcmp(arg, "--warn")) {
     81       enable_kati_warnings = true;
     82     } else if (!strcmp(arg, "--ninja")) {
     83       generate_ninja = true;
     84     } else if (!strcmp(arg, "--gen_all_targets")) {
     85       gen_all_targets = true;
     86     } else if (!strcmp(arg, "--regen")) {
     87       // TODO: Make this default.
     88       regen = true;
     89     } else if (!strcmp(arg, "--regen_debug")) {
     90       regen_debug = true;
     91     } else if (!strcmp(arg, "--regen_ignoring_kati_binary")) {
     92       regen_ignoring_kati_binary = true;
     93     } else if (!strcmp(arg, "--dump_kati_stamp")) {
     94       dump_kati_stamp = true;
     95       regen_debug = true;
     96     } else if (!strcmp(arg, "--detect_android_echo")) {
     97       detect_android_echo = true;
     98     } else if (!strcmp(arg, "--detect_depfiles")) {
     99       detect_depfiles = true;
    100     } else if (!strcmp(arg, "--color_warnings")) {
    101       color_warnings = true;
    102     } else if (!strcmp(arg, "--werror_find_emulator")) {
    103       werror_find_emulator = true;
    104     } else if (!strcmp(arg, "--werror_overriding_commands")) {
    105       werror_overriding_commands = true;
    106     } else if (ParseCommandLineOptionWithArg("-j", argv, &i, &num_jobs_str)) {
    107       num_jobs = strtol(num_jobs_str, NULL, 10);
    108       if (num_jobs <= 0) {
    109         ERROR("Invalid -j flag: %s", num_jobs_str);
    110       }
    111     } else if (ParseCommandLineOptionWithArg("--remote_num_jobs", argv, &i,
    112                                              &num_jobs_str)) {
    113       remote_num_jobs = strtol(num_jobs_str, NULL, 10);
    114       if (remote_num_jobs <= 0) {
    115         ERROR("Invalid -j flag: %s", num_jobs_str);
    116       }
    117     } else if (ParseCommandLineOptionWithArg("--ninja_suffix", argv, &i,
    118                                              &ninja_suffix)) {
    119     } else if (ParseCommandLineOptionWithArg("--ninja_dir", argv, &i,
    120                                              &ninja_dir)) {
    121     } else if (!strcmp(arg, "--use_find_emulator")) {
    122       use_find_emulator = true;
    123     } else if (ParseCommandLineOptionWithArg("--goma_dir", argv, &i,
    124                                              &goma_dir)) {
    125     } else if (ParseCommandLineOptionWithArg(
    126                    "--ignore_optional_include", argv, &i,
    127                    &ignore_optional_include_pattern)) {
    128     } else if (ParseCommandLineOptionWithArg("--ignore_dirty", argv, &i,
    129                                              &ignore_dirty_pattern)) {
    130     } else if (ParseCommandLineOptionWithArg("--no_ignore_dirty", argv, &i,
    131                                              &no_ignore_dirty_pattern)) {
    132     } else if (arg[0] == '-') {
    133       ERROR("Unknown flag: %s", arg);
    134     } else {
    135       if (strchr(arg, '=')) {
    136         cl_vars.push_back(arg);
    137       } else {
    138         should_propagate = false;
    139         targets.push_back(Intern(arg));
    140       }
    141     }
    142 
    143     if (should_propagate) {
    144       for (; pi <= i; pi++) {
    145         subkati_args.push_back(argv[pi]);
    146       }
    147     }
    148   }
    149 }
    150