Revert 8203: Revert 8202 - Add ragel decoder/validator to SCONS

src/trusted/validator_ragel/unreviewed/gen-decoder.cc

 /*
  * Copyright (c) 2012 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <fcntl.h>
 #include <getopt.h>
 #include <libgen.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
 #include <map>
 #include <set>
 #include <string>
 #include <tuple>
 #include <vector>
 
+
 template <typename T, size_t N>
 char (&ArraySizeHelper(T (&array)[N]))[N];
 #define arraysize(array) (sizeof(ArraySizeHelper(array)))
 
 namespace {
   const char* short_program_name;
 
   const struct option kProgramOptions[] = {
     {"mode",    required_argument,      NULL,   'm'},
     {"disable", required_argument,      NULL,   'd'},
@@ skipping 151 matching lines @@
      /* Flags for enabling/disabling based on architecture and validity.  */
      "ia32",
      "amd64",
      "nacl-ia32-forbidden",
      "nacl-amd64-forbidden",
      "nacl-forbidden"
   };
 
   class Instruction {
    public:
-    static bool check_flag_valid(const std::string &flag) {
+    static void check_flag_valid(const std::string &flag) {
       if (all_instruction_flags.find(flag) == all_instruction_flags.end()) {
         fprintf(stderr, "%s: unknown flag: '%s'\n",
                 short_program_name, flag.c_str());
         exit(1);
       }
     }
 
     void add_flag(const std::string &flag) {
       check_flag_valid(flag);
       flags.insert(flag);
@@ skipping 979 matching lines @@
                                  c_identifier(pair.first).c_str(), pair.second);
     }
   }
 
   class MarkedInstruction : Instruction {
    public:
     /* Additional marks are created in the process of parsing. */
     explicit MarkedInstruction(Instruction instruction_) :
         Instruction(instruction_),
         instruction_class(get_instruction_class(instruction_)),
-        opcode_in_modrm(false), opcode_in_imm(false), rex { } {
+        rex { }, opcode_in_modrm(false), opcode_in_imm(false) {
       if (has_flag("branch_hint")) {
         optional_prefixes.insert("branch_hint");
       }
       if (has_flag("condrep")) {
         optional_prefixes.insert("condrep");
       }
       if (has_flag("rep")) {
         optional_prefixes.insert("rep");
       }
       for (auto opcode_it = opcodes.begin();
@@ skipping 338 matching lines @@
       }
     }
 
     void print_one_size_definition(void) {
       /* 64bit commands are not supported in ia32 mode.  */
       if (ia32_mode && rex.w) {
         return;
       }
       bool modrm_memory = false;
       bool modrm_register = false;
-      char operand_source;
+      char operand_source = ' ';
       for (auto operand_it = operands.begin();
            operand_it != operands.end(); ++operand_it) {
         auto &operand = *operand_it;
         static std::map<char, std::pair<bool, bool> > operand_map {
           { 'E', std::make_pair(true,  true) },
           { 'M', std::make_pair(true,  false) },
           { 'N', std::make_pair(false, true) },
           { 'Q', std::make_pair(true,  true) },
           { 'R', std::make_pair(false, true) },
           { 'U', std::make_pair(false, true) },
@@ skipping 925 matching lines @@
 
   fprintf(out_file, "\n  one_instruction =");
 
   print_one_instruction_definition();
 
   fprintf(out_file, ");\n"
 "}%%%%\n"
 "");
   return 0;
 }