v8::internal::FlagList Class Reference

#include <flags.h>

Collaboration diagram for v8::internal::FlagList:

Static Public Member Functions
static List< const char * > *	argv ()
static int	SetFlagsFromCommandLine (int *argc, char **argv, bool remove_flags)
static int	SetFlagsFromString (const char *str, int len)
static void	ResetAllFlags ()
static void	PrintHelp ()
static void	EnforceFlagImplications ()

Detailed Description

Definition at line 18 of file flags.h.

Member Function Documentation

argv()

List< const char * > * v8::internal::FlagList::argv ( )

static

Definition at line 221 of file flags.cc.

                                  {
  List<const char*>* args = new List<const char*>(8);
  Flag* args_flag = NULL;
  for (size_t i = 0; i < num_flags; ++i) {
    Flag* f = &flags[i];
    if (!f->IsDefault()) {
      if (f->type() == Flag::TYPE_ARGS) {
        DCHECK(args_flag == NULL);
        args_flag = f;  // Must be last in arguments.
        continue;
      }
      {
        bool disabled = f->type() == Flag::TYPE_BOOL && !*f->bool_variable();
        OStringStream os;
        os << (disabled ? "--no" : "--") << f->name();
        args->Add(StrDup(os.c_str()));
      }
      if (f->type() != Flag::TYPE_BOOL) {
        OStringStream os;
        os << *f;
        args->Add(StrDup(os.c_str()));
      }
    }
  }
  if (args_flag != NULL) {
    OStringStream os;
    os << "--" << args_flag->name();
    args->Add(StrDup(os.c_str()));
    JSArguments jsargs = *args_flag->args_variable();
    for (int j = 0; j < jsargs.argc; j++) {
      args->Add(StrDup(jsargs[j]));
    }
  }
  return args;
}

References v8::internal::List< T, AllocationPolicy >::Add(), v8::internal::OStringStream::c_str(), DCHECK, v8::internal::anonymous_namespace{flags.cc}::flags, NULL, v8::internal::anonymous_namespace{flags.cc}::num_flags, and v8::internal::StrDup().

Referenced by SetFlagsFromCommandLine(), and SetFlagsFromString().

Here is the call graph for this function:

Here is the caller graph for this function:

EnforceFlagImplications()

void v8::internal::FlagList::EnforceFlagImplications ( )

static

Definition at line 545 of file flags.cc.

                                       {
#define FLAG_MODE_DEFINE_IMPLICATIONS
#include "src/flag-definitions.h"
#undef FLAG_MODE_DEFINE_IMPLICATIONS
}

Referenced by v8::internal::V8::InitializeOncePerProcessImpl().

Here is the caller graph for this function:

PrintHelp()

void v8::internal::FlagList::PrintHelp ( )

static

Definition at line 516 of file flags.cc.

                         {
  CpuFeatures::Probe(false);
  CpuFeatures::PrintTarget();
  CpuFeatures::PrintFeatures();
 
  OFStream os(stdout);
  os << "Usage:\n"
     << "  shell [options] -e string\n"
     << "    execute string in V8\n"
     << "  shell [options] file1 file2 ... filek\n"
     << "    run JavaScript scripts in file1, file2, ..., filek\n"
     << "  shell [options]\n"
     << "  shell [options] --shell [file1 file2 ... filek]\n"
     << "    run an interactive JavaScript shell\n"
     << "  d8 [options] file1 file2 ... filek\n"
     << "  d8 [options]\n"
     << "  d8 [options] --shell [file1 file2 ... filek]\n"
     << "    run the new debugging shell\n\n"
     << "Options:\n";
  for (size_t i = 0; i < num_flags; ++i) {
    Flag* f = &flags[i];
    os << "  --" << f->name() << " (" << f->comment() << ")\n"
       << "        type: " << Type2String(f->type()) << "  default: " << *f
       << "\n";
  }
}

References v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::anonymous_namespace{flags.cc}::num_flags, v8::internal::CpuFeatures::PrintFeatures(), v8::internal::CpuFeatures::PrintTarget(), v8::internal::CpuFeatures::Probe(), and v8::internal::Type2String().

Referenced by main(), and SetFlagsFromCommandLine().

Here is the call graph for this function:

Here is the caller graph for this function:

ResetAllFlags()

void v8::internal::FlagList::ResetAllFlags ( )

static

Definition at line 508 of file flags.cc.

                             {
  for (size_t i = 0; i < num_flags; ++i) {
    flags[i].Reset();
  }
}

References v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::anonymous_namespace{flags.cc}::num_flags, and v8::internal::anonymous_namespace{flags.cc}::Flag::Reset().

Referenced by v8::internal::V8::TearDown().

Here is the call graph for this function:

Here is the caller graph for this function:

SetFlagsFromCommandLine()

int v8::internal::FlagList::SetFlagsFromCommandLine ( int *  argc, char **  argv, bool  remove_flags  )

static

Definition at line 334 of file flags.cc.

                                                         {
  int return_code = 0;
  // parse arguments
  for (int i = 1; i < *argc;) {
    int j = i;  // j > 0
    const char* arg = argv[i++];
 
    // split arg into flag components
    char buffer[1*KB];
    const char* name;
    const char* value;
    bool is_bool;
    SplitArgument(arg, buffer, sizeof buffer, &name, &value, &is_bool);
 
    if (name != NULL) {
      // lookup the flag
      Flag* flag = FindFlag(name);
      if (flag == NULL) {
        if (remove_flags) {
          // We don't recognize this flag but since we're removing
          // the flags we recognize we assume that the remaining flags
          // will be processed somewhere else so this flag might make
          // sense there.
          continue;
        } else {
          PrintF(stderr, "Error: unrecognized flag %s\n"
                 "Try --help for options\n", arg);
          return_code = j;
          break;
        }
      }
 
      // if we still need a flag value, use the next argument if available
      if (flag->type() != Flag::TYPE_BOOL &&
          flag->type() != Flag::TYPE_MAYBE_BOOL &&
          flag->type() != Flag::TYPE_ARGS &&
          value == NULL) {
        if (i < *argc) {
          value = argv[i++];
        }
        if (!value) {
          PrintF(stderr, "Error: missing value for flag %s of type %s\n"
                 "Try --help for options\n",
                 arg, Type2String(flag->type()));
          return_code = j;
          break;
        }
      }
 
      // set the flag
      char* endp = const_cast<char*>("");  // *endp is only read
      switch (flag->type()) {
        case Flag::TYPE_BOOL:
          *flag->bool_variable() = !is_bool;
          break;
        case Flag::TYPE_MAYBE_BOOL:
          *flag->maybe_bool_variable() = MaybeBoolFlag::Create(true, !is_bool);
          break;
        case Flag::TYPE_INT:
          *flag->int_variable() = strtol(value, &endp, 10);  // NOLINT
          break;
        case Flag::TYPE_FLOAT:
          *flag->float_variable() = strtod(value, &endp);
          break;
        case Flag::TYPE_STRING:
          flag->set_string_value(value ? StrDup(value) : NULL, true);
          break;
        case Flag::TYPE_ARGS: {
          int start_pos = (value == NULL) ? i : i - 1;
          int js_argc = *argc - start_pos;
          const char** js_argv = NewArray<const char*>(js_argc);
          if (value != NULL) {
            js_argv[0] = StrDup(value);
          }
          for (int k = i; k < *argc; k++) {
            js_argv[k - start_pos] = StrDup(argv[k]);
          }
          *flag->args_variable() = JSArguments::Create(js_argc, js_argv);
          i = *argc;  // Consume all arguments
          break;
        }
      }
 
      // handle errors
      bool is_bool_type = flag->type() == Flag::TYPE_BOOL ||
          flag->type() == Flag::TYPE_MAYBE_BOOL;
      if ((is_bool_type && value != NULL) || (!is_bool_type && is_bool) ||
          *endp != '\0') {
        PrintF(stderr, "Error: illegal value for flag %s of type %s\n"
               "Try --help for options\n",
               arg, Type2String(flag->type()));
        return_code = j;
        break;
      }
 
      // remove the flag & value from the command
      if (remove_flags) {
        while (j < i) {
          argv[j++] = NULL;
        }
      }
    }
  }
 
  // shrink the argument list
  if (remove_flags) {
    int j = 1;
    for (int i = 1; i < *argc; i++) {
      if (argv[i] != NULL)
        argv[j++] = argv[i];
    }
    *argc = j;
  }
 
  if (FLAG_help) {
    PrintHelp();
    exit(0);
  }
  // parsed all flags successfully
  return return_code;
}

References argv(), v8::internal::FindFlag(), v8::internal::flag, v8::internal::KB, name, NULL, v8::internal::PrintF(), PrintHelp(), v8::internal::SplitArgument(), v8::internal::StrDup(), and v8::internal::Type2String().

Referenced by main(), v8::V8::SetFlagsFromCommandLine(), and SetFlagsFromString().

Here is the call graph for this function:

Here is the caller graph for this function:

SetFlagsFromString()

int v8::internal::FlagList::SetFlagsFromString ( const char *  str, int  len  )

static

Definition at line 472 of file flags.cc.

                                                         {
  // make a 0-terminated copy of str
  ScopedVector<char> copy0(len + 1);
  MemCopy(copy0.start(), str, len);
  copy0[len] = '\0';
 
  // strip leading white space
  char* copy = SkipWhiteSpace(copy0.start());
 
  // count the number of 'arguments'
  int argc = 1;  // be compatible with SetFlagsFromCommandLine()
  for (char* p = copy; *p != '\0'; argc++) {
    p = SkipBlackSpace(p);
    p = SkipWhiteSpace(p);
  }
 
  // allocate argument array
  ScopedVector<char*> argv(argc);
 
  // split the flags string into arguments
  argc = 1;  // be compatible with SetFlagsFromCommandLine()
  for (char* p = copy; *p != '\0'; argc++) {
    argv[argc] = p;
    p = SkipBlackSpace(p);
    if (*p != '\0') *p++ = '\0';  // 0-terminate argument
    p = SkipWhiteSpace(p);
  }
 
  // set the flags
  int result = SetFlagsFromCommandLine(&argc, argv.start(), false);
 
  return result;
}

References argv(), v8::internal::MemCopy(), SetFlagsFromCommandLine(), v8::internal::SkipBlackSpace(), v8::internal::SkipWhiteSpace(), and v8::internal::Vector< T >::start().

Referenced by v8::internal::RUNTIME_FUNCTION(), and v8::V8::SetFlagsFromString().

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• /mnt/V8SourceCode/src/flags.h
• /mnt/V8SourceCode/src/flags.cc