libsanitizer/sanitizer_common/sanitizer_flags.cc

   1 //===-- sanitizer_flags.cc ------------------------------------------------===//
   2 //
   3 // This file is distributed under the University of Illinois Open Source
   4 // License. See LICENSE.TXT for details.
   5 //
   6 //===----------------------------------------------------------------------===//
   7 //
   8 // This file is a part of ThreadSanitizer/AddressSanitizer runtime.
   9 //
  10 //===----------------------------------------------------------------------===//
  11
  12 #include "sanitizer_flags.h"
  13
  14 #include "sanitizer_common.h"
  15 #include "sanitizer_libc.h"
  16
  17 namespace __sanitizer {
  18
  19 static bool GetFlagValue(const char *env, const char *name,
  20                          const char **value, int *value_length) {
  21   if (env == 0)
  22     return false;
  23   const char *pos = internal_strstr(env, name);
  24   const char *end;
  25   if (pos == 0)
  26     return false;
  27   pos += internal_strlen(name);
  28   if (pos[0] != '=') {
  29     end = pos;
  30   } else {
  31     pos += 1;
  32     if (pos[0] == '"') {
  33       pos += 1;
  34       end = internal_strchr(pos, '"');
  35     } else if (pos[0] == '\'') {
  36       pos += 1;
  37       end = internal_strchr(pos, '\'');
  38     } else {
  39       // Read until the next space or colon.
  40       end = pos + internal_strcspn(pos, " :");
  41     }
  42     if (end == 0)
  43       end = pos + internal_strlen(pos);
  44   }
  45   *value = pos;
  46   *value_length = end - pos;
  47   return true;
  48 }
  49
  50 static bool StartsWith(const char *flag, int flag_length, const char *value) {
  51   if (!flag || !value)
  52     return false;
  53   int value_length = internal_strlen(value);
  54   return (flag_length >= value_length) &&
  55          (0 == internal_strncmp(flag, value, value_length));
  56 }
  57
  58 void ParseFlag(const char *env, bool *flag, const char *name) {
  59   const char *value;
  60   int value_length;
  61   if (!GetFlagValue(env, name, &value, &value_length))
  62     return;
  63   if (StartsWith(value, value_length, "0") ||
  64       StartsWith(value, value_length, "no") ||
  65       StartsWith(value, value_length, "false"))
  66     *flag = false;
  67   if (StartsWith(value, value_length, "1") ||
  68       StartsWith(value, value_length, "yes") ||
  69       StartsWith(value, value_length, "true"))
  70     *flag = true;
  71 }
  72
  73 void ParseFlag(const char *env, int *flag, const char *name) {
  74   const char *value;
  75   int value_length;
  76   if (!GetFlagValue(env, name, &value, &value_length))
  77     return;
  78   *flag = internal_atoll(value);
  79 }
  80
  81 static LowLevelAllocator allocator_for_flags;
  82
  83 void ParseFlag(const char *env, const char **flag, const char *name) {
  84   const char *value;
  85   int value_length;
  86   if (!GetFlagValue(env, name, &value, &value_length))
  87     return;
  88   // Copy the flag value. Don't use locks here, as flags are parsed at
  89   // tool startup.
  90   char *value_copy = (char*)(allocator_for_flags.Allocate(value_length + 1));
  91   internal_memcpy(value_copy, value, value_length);
  92   value_copy[value_length] = '\0';
  93   *flag = value_copy;
  94 }
  95
  96 }  // namespace __sanitizer