Add ragel machine generators to SCONS

src/trusted/validator_ragel/unreviewed/gen-dfa.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 <iterator>
 #include <map>
 #include <set>
 #include <string>
 #include <tuple>
 #include <vector>
 
+#ifndef NACL_TRUSTED_BUT_NOT_TCB
+#error("This file is not meant for use in the TCB")
+#endif
+
+#ifdef __GNUC__
+/* We use operand number formats here.  They are defined in SUSv2 and supported
+   on all POSIX systems (including all versions of Linux and MacOS), yet
+   -pedantic warns about them.  */
+#pragma GCC diagnostic ignored "-Wformat"
+/* GCC complains even when we explicitly use empty initializer list.  Can be
+   easily fixed with data member initializers, but this requires GCC 4.7+.  */
+#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+/* Default is perfectly valid way to handle missing cases.  Especially if we
+   only care about very few non-default ones as often here.  */
+#pragma GCC diagnostic ignored "-Wswitch-enum"
+#pragma GCC diagnostic error "-Wswitch"
+#endif
+
 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'},
-    {"output",  required_argument,      NULL,   'o'},
-    {"help",    no_argument,            NULL,   'h'},
-    {"version", no_argument,            NULL,   'v'},
-    {NULL,      0,                      NULL,   0}
+    {"mode",       required_argument,      NULL,   'm'},
+    {"disable",    required_argument,      NULL,   'd'},
+    {"output",     required_argument,      NULL,   'o'},
+    {"const_file", required_argument,      NULL,   'c'},
+    {"help",       no_argument,            NULL,   'h'},
+    {"version",    no_argument,            NULL,   'v'},
+    {NULL,         0,                      NULL,   0}
   };
 
   const char kVersion[] = "0.0";
 
   const char* const kProgramHelp = "Usage: %1$s [OPTION]... [FILE]...\n"
 "\n"
 "Creates ragel machine which recognizes instructions listed in given files.\n"
 "\n"
 "Mandatory arguments to long options are mandatory for short options too.\n"
 "\n"
 "Options list:\n"
 "  -m, --mode=mode            CPU mode: ia32 for IA32, amd64 for x86-64\n"
 "  -d, --disable=action_list  disable actions from the comma-separated list\n"
 "  -o, --output=FILE          write result to FILE instead of standard output\n"
+"  -c, --const_file=FILE      wrire result of FILE instead of standard output\n"
 "  -h, --help                 display this help and exit\n"
 "  -v, --version              output version information and exit\n"
 "\n"
 "Here is the full list of possible action types with short descrion of places\n"
 "where they are insered:\n"
 "  rex_prefix          triggered when legacy REX prefix is parsed\n"
 "    @rex_prefix         inserted after possible REX prefix\n"
 "  vex_prefix          triggered when VEX-encoded action is detected\n"
 "    @vex_prefix2        inserted after second byte of 3-byte VEX/XOP prefix\n"
 "    @vex_prefix3        inserted after third byte of 3-byte VEX/XOP prefix\n"
@@ skipping 123 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 14 matching lines @@
     };
     std::vector<Operand> operands;
     std::vector<std::string> opcodes;
     std::set<std::string> flags;
   };
   std::vector<Instruction> instructions;
 
   FILE *out_file = stdout;
   FILE *const_file = stdout;
   char *out_file_name = NULL;
+  char *const_file_name = NULL;
 
   auto ia32_mode = true;
 
   std::string read_file(const char *filename) {
     std::string file_content;
     auto file = open(filename, O_RDONLY);
     char buf[1024];
     ssize_t count;
 
     if (file == -1) {
@@ skipping 324 matching lines @@
       }
     }
     return name;
   }
 
   void print_common_decoding(void) {
     if (enabled(Actions::kRelOperandAction)) {
       fprintf(out_file, "  action rel8_operand {\n"
 "    operand0 = JMP_TO;\n"
 "    base = REG_RIP;\n"
-"    index = REG_NONE;\n"
+"    index = NO_REG;\n"
 "    scale = 0;\n"
 "    disp_type = DISP8;\n"
 "    disp = p;\n"
 "  }\n"
 "  action rel16_operand {\n"
 "    operand0 = JMP_TO;\n"
 "    base = REG_RIP;\n"
-"    index = REG_NONE;\n"
+"    index = NO_REG;\n"
 "    scale = 0;\n"
 "    disp_type = DISP16;\n"
 "    disp = p - 1;\n"
 "  }\n"
 "  action rel32_operand {\n"
 "    operand0 = JMP_TO;\n"
 "    base = REG_RIP;\n"
-"    index = REG_NONE;\n"
+"    index = NO_REG;\n"
 "    scale = 0;\n"
 "    disp_type = DISP32;\n"
 "    disp = p - 3;\n"
 "  }\n"
 "");
     }
     fprintf(out_file,
 "  action branch_not_taken {\n"
 "    branch_not_taken = TRUE;\n"
 "  }\n"
@@ skipping 80 matching lines @@
 "  action imm64_second_operand {\n"
 "    imm2_operand = IMM64;\n"
 "    imm2 = p - 7;\n"
 "  }\n"
 "");
     }
     if (enabled(Actions::kParseOperands)) {
       if (ia32_mode) {
         fprintf(out_file, "  action modrm_only_base {\n"
 "    disp_type = DISPNONE;\n"
-"    index = REG_NONE;\n"
+"    index = NO_REG;\n"
 "    base = (*p) & 0x07;\n"
 "    scale = 0;\n"
 "  }\n"
 "  action modrm_base_disp {\n"
-"    index = REG_NONE;\n"
+"    index = NO_REG;\n"
 "    base = (*p) & 0x07;\n"
 "    scale = 0;\n"
 "  }\n"
 "  action modrm_pure_disp {\n"
-"    base = REG_NONE;\n"
-"    index = REG_NONE;\n"
+"    base = NO_REG;\n"
+"    index = NO_REG;\n"
 "    scale = 0;\n"
 "  }\n"
 "  action modrm_pure_index {\n"
 "    disp_type = DISPNONE;\n"
-"    base = REG_NONE;\n"
+"    base = NO_REG;\n"
 "    index = index_registers[((*p) & 0x38) >> 3];\n"
 "    scale = ((*p) & 0xc0) >> 6;\n"
 "  }\n"
 "  action modrm_parse_sib {\n"
 "    disp_type = DISPNONE;\n"
 "    base = (*p) & 0x7;\n"
 "    index = index_registers[((*p) & 0x38) >> 3];\n"
 "    scale = ((*p) & 0xc0) >> 6;\n"
 "  }\n");
       } else {
         fprintf(out_file, "  action modrm_only_base {\n"
 "    disp_type = DISPNONE;\n"
-"    index = REG_NONE;\n"
+"    index = NO_REG;\n"
 "    base = ((*p) & 0x07) |\n"
 "          ((rex_prefix & 0x01) << 3) |\n"
 "          (((~vex_prefix2) & 0x20) >> 2);\n"
 "    scale = 0;\n"
 "  }\n"
 "  action modrm_base_disp {\n"
-"    index = REG_NONE;\n"
+"    index = NO_REG;\n"
 "    base = ((*p) & 0x07) |\n"
 "          ((rex_prefix & 0x01) << 3) |\n"
 "          (((~vex_prefix2) & 0x20) >> 2);\n"
 "    scale = 0;\n"
 "  }\n"
 "  action modrm_rip {\n"
-"    index = REG_NONE;\n"
+"    index = NO_REG;\n"
 "    base = REG_RIP;\n"
 "    scale = 0;\n"
 "  }\n"
 "  action modrm_pure_index {\n"
 "    disp_type = DISPNONE;\n"
-"    base = REG_NONE;\n"
+"    base = NO_REG;\n"
 "    index = index_registers[(((*p) & 0x38) >> 3) |\n"
 "                           ((rex_prefix & 0x02) << 2) |\n"
 "                           (((~vex_prefix2) & 0x40) >> 3)];\n"
 "    scale = ((*p) & 0xc0) >> 6;\n"
 "  }\n"
 "  action modrm_parse_sib {\n"
 "    disp_type = DISPNONE;\n"
 "    base = ((*p) & 0x7) |\n"
 "          ((rex_prefix & 0x01) << 3) |\n"
 "          (((~vex_prefix2) & 0x20) >> 2);\n"
@@ skipping 232 matching lines @@
     static const T vex_fields[] = {
       T { "NONE",       0xe0 },
       T { "R",          0x60 },
       T { "X",          0xa0 },
       T { "B",          0xc0 },
       T { "RX",         0x20 },
       T { "RB",         0x40 },
       T { "XB",         0x80 },
       T { "RXB",        0x00 }
     };
-    for (int vex_it = 0; vex_it < arraysize(vex_fields); ++vex_it) {
+    for (size_t vex_it = 0; vex_it < arraysize(vex_fields); ++vex_it) {
       auto vex = vex_fields[vex_it];
       fprintf(out_file, "  VEX_%2$s = %3$s%1$s;\n"
 "", enabled(Actions::kVexPrefix) && !ia32_mode ? " @vex_prefix2" : "",
        vex.first, chartest((c & vex.second) == vex.second));
     }
     static const T vex_map[] = {
       T { "01",         1       },
       T { "02",         2       },
       T { "03",         3       },
       T { "08",         8       },
       T { "09",         9       },
       T { "0A",         10      },
       T { "00001",      1       },
       T { "00010",      2       },
       T { "00011",      3       },
       T { "01000",      8       },
       T { "01001",      9       },
       T { "01010",      10      },
     };
-    for (int vex_it = 0; vex_it < arraysize(vex_map); ++vex_it) {
+    for (size_t vex_it = 0; vex_it < arraysize(vex_map); ++vex_it) {
       auto vex = vex_map[vex_it];
       fprintf(out_file, "  VEX_map%1$s = %2$s;\n"
 "", vex.first, chartest((c & 0x1f) == vex.second));
     }
     if (enabled(Actions::kOpcode)) {
       fprintf(out_file, "\n"
 "  action begin_opcode {\n"
 "    begin_opcode = p;\n"
 "  }\n"
 "  action end_opcode {\n"
@@ skipping 34 matching lines @@
           T { "x87",                    "ST"                            },
           T { "mmx",                    "MMX"                           },
           T { "xmm",                    "XMM"                           },
           T { "ymm",                    "YMM"                           },
           T { "farptr",                 "FarPtr"                        },
           T { "segreg",                 "SegmentRegister"               },
           T { "creg",                   "ControlRegister"               },
           T { "dreg",                   "DebugRegister"                 },
           T { "selector",               "Selector"                      }
         };
-        for (int size_it = 0; size_it < arraysize(sizes); ++size_it) {
+        for (size_t size_it = 0; size_it < arraysize(sizes); ++size_it) {
           auto size = sizes[size_it];
           fprintf(out_file, "  action operand%1$d_%2$s {\n"
 "    operand%1$d_type = Operand%3$s;\n"
 "  }\n"
 "", i, size.first, size.second);
         }
         if (ia32_mode) {
           fprintf(out_file, "  action operand%1$d_absolute_disp {\n"
 "    operand%1$d = REG_RM;\n"
-"    base = REG_NONE;\n"
-"    index = REG_NONE;\n"
+"    base = NO_REG;\n"
+"    index = NO_REG;\n"
 "    scale = 0;\n"
 "  }\n"
 "  action operand%1$d_from_opcode {\n"
 "    operand%1$d = (*p) & 0x7;\n"
 "  }\n"
 "  action operand%1$d_from_is4 {\n"
 "    operand%1$d = p[0] >> 4;\n"
 "  }\n"
 "  action operand%1$d_from_modrm_rm {\n"
 "    operand%1$d = (*p) & 0x07;\n"
 "  }\n"
 "  action operand%1$d_from_modrm_reg {\n"
 "    operand%1$d = ((*p) & 0x38) >> 3;\n"
 "  }\n"
 "  action operand%1$d_from_modrm_reg_norex {\n"
 "    operand%1$d = ((*p) & 0x38) >> 3;\n"
 "  }\n"
 "  action operand%1$d_from_vex {\n"
 "    operand%1$d = ((~vex_prefix3) & 0x38) >> 3;\n"
 "  }\n"
 "", i);
         } else {
           fprintf(out_file, "  action operand%1$d_absolute_disp {\n"
 "    operand%1$d = REG_RM;\n"
-"    base = REG_NONE;\n"
+"    base = NO_REG;\n"
 "    index = REG_RIZ;\n"
 "    scale = 0;\n"
 "  }\n"
 "  action operand%1$d_from_opcode {\n"
 "    operand%1$d = ((*p) & 0x7) |\n"
 "              ((rex_prefix & 0x01) << 3) |\n"
 "              (((~vex_prefix2) & 0x20) >> 2);\n"
 "  }\n"
 "  action operand%1$d_from_is4 {\n"
 "    operand%1$d = p[0] >> 4;\n"
@@ skipping 22 matching lines @@
           T { "es_rdi",                 "REG_ES_RDI"    },
           T { "immediate",              "REG_IMM"       },
           T { "second_immediate",       "REG_IMM2"      },
           T { "port_dx",                "REG_PORT_DX"   },
           T { "rax",                    "REG_RAX"       },
           T { "rcx",                    "REG_RCX"       },
           T { "rdx",                    "REG_RDX"       },
           T { "rm",                     "REG_RM"        },
           T { "st",                     "REG_ST"        }
         };
-        for (int type_it = 0; type_it < arraysize(types); ++type_it) {
+        for (size_t type_it = 0; type_it < arraysize(types); ++type_it) {
           auto type = types[type_it];
           fprintf(out_file, "  action operand%1$d_%2$s {\n"
 "    operand%1$d = %3$s;\n"
 "  }\n"
 "", i, type.first, type.second);
         }
       }
     }
     if (enabled(Actions::kParseOperandsStates)) {
       for (auto i = 0 ; i < 5; ++i) {
         fprintf(out_file, "  action operand%1$d_unused {\n"
-"    operand%1$d_read = false;\n"
-"    operand%1$d_write = false;\n"
+"    operand%1$d_read = FALSE;\n"
+"    operand%1$d_write = FALSE;\n"
 "  }\n"
 "  action operand%1$d_read {\n"
-"    operand%1$d_read = true;\n"
-"    operand%1$d_write = false;\n"
+"    operand%1$d_read = TRUE;\n"
+"    operand%1$d_write = FALSE;\n"
 "  }\n"
 "  action operand%1$d_write {\n"
-"    operand%1$d_read = false;\n"
-"    operand%1$d_write = true;\n"
+"    operand%1$d_read = FALSE;\n"
+"    operand%1$d_write = TRUE;\n"
 "  }\n"
 "  action operand%1$d_readwrite {\n"
-"    operand%1$d_read = true;\n"
-"    operand%1$d_write = true;\n"
+"    operand%1$d_read = TRUE;\n"
+"    operand%1$d_write = TRUE;\n"
 "  }\n"
 "", i);
       }
     }
   }
 
   void print_name_actions(void) {
     for (auto pair_it = instruction_names.begin();
          pair_it != instruction_names.end(); ++pair_it) {
       auto &pair = *pair_it;
       fprintf(out_file, "  action instruction_%s"
         " { instruction_name = instruction_names + %zd; }\n",
                                  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 27 matching lines @@
                   }
                   opcode->push_back(')');
                   if (saved_opcode == "0x97") {
                     opcode->erase(1, 5);
                   }
                   break;
                 case '8':
                   (*opcode) = "(";
                   opcode->append(saved_opcode);
                   static const char cc[] = {'9', 'a', 'b', 'c', 'd', 'e', 'f'};
-                  for (int c_it = 0; c_it < arraysize(cc); ++c_it) {
+                  for (size_t c_it = 0; c_it < arraysize(cc); ++c_it) {
                     auto c = cc[c_it];
                     opcode->push_back('|');
                     (*(saved_opcode.rbegin())) = c;
                     opcode->append(saved_opcode);
                   }
                   opcode->push_back(')');
                   break;
                 default:
                   fprintf(stderr, "%s: error - can not use 'r' operand in "
                     "instruction '%s'", short_program_name, name.c_str());
@@ skipping 251 matching lines @@
               if (saved_class == InstructionClass::kLSetUnsetDefaultRexW) {
                 instruction_class = InstructionClass::kRexW;
                 print_one_size_definition_rexw();
               }
               opcode[Lbit] = '0';
               auto saved_operands = operands;
               for (auto operand_it = operands.begin();
                    operand_it != operands.end(); ++operand_it) {
                 auto &operand = *operand_it;
                 static const char cc[] = {'H', 'L', 'U', 'V', 'W'};
-                for (int c_it = 0; c_it < arraysize(cc); ++c_it) {
+                for (size_t c_it = 0; c_it < arraysize(cc); ++c_it) {
                   auto c = cc[c_it];
                   if ((operand.source == c) &&
                       (*(operand.size.rbegin()) == 'x') &&
                       (((operand.size.length() > 1) &&
                         (operand.size[0] == 'p')) ||
                        (operand.size.length() == 1))) {
                     operand.size.resize(operand.size.length() - 1);
                   }
                 }
               }
@@ skipping 18 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 102 matching lines @@
 
     void print_one_size_definition_modrm_memory(void) {
       typedef std::tuple<const char *, bool, bool> T;
       static const T modes[] = {
         T { " operand_disp",            false,  true    },
         T { " operand_rip",             false,  false   },
         T { " single_register_memory",  false,  true    },
         T { " operand_sib_pure_index",  true,   false   },
         T { " operand_sib_base_index",  true,   true    }
       };
-      for (int mode_it = 0; mode_it < arraysize(modes); ++mode_it) {
+      for (size_t mode_it = 0; mode_it < arraysize(modes); ++mode_it) {
         auto mode = modes[mode_it];
         print_operator_delimiter();
         if (mod_reg_is_used()) {
           rex.r = true;
         }
         if (mod_rm_is_used()) {
           rex.x = std::get<1>(mode);
           rex.b = std::get<2>(mode);
         }
         print_legacy_prefixes();
@@ skipping 59 matching lines @@
 
     bool mod_reg_is_used() {
       for (auto operand_it = operands.begin();
            operand_it != operands.end(); ++operand_it) {
         auto &operand = *operand_it;
         if (operand.source == 'C' &&
             required_prefixes.find("0xf0") == required_prefixes.end()) {
           return true;
         }
         static const char cc[] = { 'G', 'P', 'V' };
-        for (int c_it = 0; c_it < arraysize(cc); ++c_it) {
+        for (size_t c_it = 0; c_it < arraysize(cc); ++c_it) {
           auto c = cc[c_it];
           if (operand.source == c) {
             return true;
           }
         }
       }
       return false;
     }
 
     bool mod_rm_is_used() {
       for (auto operand_it = operands.begin();
            operand_it != operands.end(); ++operand_it) {
         auto &operand = *operand_it;
         static const char cc[] = { 'E', 'M', 'N', 'Q', 'R', 'U', 'W' };
-        for (int c_it = 0; c_it < arraysize(cc); ++c_it) {
+        for (size_t c_it = 0; c_it < arraysize(cc); ++c_it) {
           auto c = cc[c_it];
           if (operand.source == c) {
             return true;
           }
         }
       }
       return false;
     }
 
     void print_legacy_prefixes(void) {
@@ skipping 130 matching lines @@
         if (ia32_mode || (!rex.r && !rex.x & !rex.b)) {
           fprintf(out_file, "NONE");
         } else {
           if (rex.r) fprintf(out_file, "R");
           if (rex.x) fprintf(out_file, "X");
           if (rex.b) fprintf(out_file, "B");
         }
         fprintf(out_file, " & VEX_map%s) ", opcodes[1].c_str() + 4);
         auto third_byte = opcodes[2];
         static const char* symbolic_names[] = { "cntl", "dest", "src1", "src" };
-        for (int symbolic_it = 0;
+        for (size_t symbolic_it = 0;
              symbolic_it < arraysize(symbolic_names); ++symbolic_it) {
           auto symbolic = symbolic_names[symbolic_it];
           for (auto it = third_byte.begin(); it != third_byte.end(); ++it) {
-            if ((third_byte.end() - it) >= strlen(symbolic) &&
+            auto symbolic_len = strlen(symbolic);
+            if (static_cast<size_t>(third_byte.end() - it) >= symbolic_len &&
                 !strncmp(&*it, symbolic, strlen(symbolic))) {
               third_byte.replace(it, it + strlen(symbolic), "XXXX");
               break;
             }
           }
         }
         static const std::set<char> third_byte_check[] {
           { '0', '1', 'x', 'X', 'W' },
           { '.' },
           { '0', '1', 'x', 'X' },
           { '0', '1', 'x', 'X' },
           { '0', '1', 'x', 'X' },
           { '0', '1', 'x', 'X' },
           { '.' },
           { '0', '1', 'x', 'X' },
           { '.' },
           { '0', '1' },
           { '0', '1' }
         };
         auto third_byte_ok = (arraysize(third_byte_check) ==
-                                                           third_byte.length());
+            third_byte.length());
         if (third_byte_ok) {
-          for (int set_it = 0; set_it < arraysize(third_byte_check); ++set_it) {
+          for (size_t set_it = 0; set_it < arraysize(third_byte_check);
+              ++set_it) {
             auto &set = third_byte_check[set_it];
             if (set.find(third_byte[&set - third_byte_check]) == set.end()) {
               third_byte_ok = false;
               break;
             }
           }
         }
         if (third_byte_ok) {
           if (ia32_mode && third_byte[2] == 'X') {
             third_byte[2] = '1';
@@ skipping 403 matching lines @@
 
 int main(int argc, char *argv[]) {
   /* basename(3) may change the passed argument thus we are using copy
      of argv[0].  This creates tiny memory leak but since we only do that
      once per program invocation it's contained.  */
   short_program_name = basename(strdup(argv[0]));
 
   for (;;) {
     int option_index;
 
-    int option = getopt_long(argc, argv, "d:hm:o:v",
+    int option = getopt_long(argc, argv, "c:d:hm:o:v",
                              kProgramOptions, &option_index);
 
     if (option == -1) {
       break;
     }
 
     switch (option) {
+      case 'c': {
+        const_file_name = optarg;
+        break;
+      }
       case 'd': {
         for (auto action_to_disable = strtok(optarg, ",");
              action_to_disable;
              action_to_disable = strtok(NULL, ",")) {
           compare_action compare_with_action_to_disable(action_to_disable);
           auto action_number = std::find_if(
             kDisablableActionsList,
             kDisablableActionsList + arraysize(kDisablableActionsList),
             compare_with_action_to_disable);
           if (action_number !=
@@ skipping 33 matching lines @@
         return 1;
       default:
         abort();
     }
   }
 
   for (auto i = optind; i < argc; ++i) {
     load_instructions(argv[i]);
   }
 
-  if (!(out_file = fopen(out_file_name, "w"))) {
+  if (out_file_name && !(out_file = fopen(out_file_name, "w"))) {
     fprintf(stderr,
             "%s: can not open '%s' file (%s)\n",
             short_program_name, out_file_name, strerror(errno));
     return 1;
-  } else if (enabled(Actions::kInstructionName) ||
-             enabled(Actions::kParseOperands)) {
-    size_t const_name_len = strlen(out_file_name) + 10;
-    char* const_name = static_cast<char *>(malloc(const_name_len));
-    strncpy(const_name, out_file_name, const_name_len);
-    char* dot_position = strrchr(const_name, '.');
-    if (!dot_position) {
-      dot_position = strrchr(const_name, '\0');
+  } else if ((out_file_name || const_file_name) &&
+             (enabled(Actions::kInstructionName) ||
+              enabled(Actions::kParseOperands))) {
+    size_t const_name_len = 0;
+    if (out_file_name && !const_file_name) {
+      const_name_len = strlen(out_file_name) + 10;
+      const_file_name = static_cast<char *>(malloc(const_name_len));
+      strcpy(const_file_name, out_file_name);
+      char* dot_position = strrchr(const_file_name, '.');
+      if (!dot_position) {
+        dot_position = strrchr(const_file_name, '\0');
+      }
+      strcpy(dot_position, "-consts.c");
     }
-    strncpy(dot_position,
-            "-consts.c",
-            const_name_len - (dot_position - const_name));
-    if (!(const_file = fopen(const_name, "w"))) {
+    if (!(const_file = fopen(const_file_name, "w"))) {
       fprintf(stderr, "%s: can not open '%s' file (%s)\n",
-              short_program_name, const_name, strerror(errno));
+              short_program_name, const_file_name, strerror(errno));
        return 1;
     }
-    free(const_name);
+    if (const_name_len) {
+      free(const_file_name);
+      const_file_name = NULL;
+    }
   }
 
   if (enabled(Actions::kInstructionName) ||
       enabled(Actions::kParseOperands)) {
     print_consts();
 
     if (out_file == const_file) {
       for (auto i = 0; i < 80; ++i) {
         fputc('#', out_file);
       }
       fputc('\n', out_file);
     }
   }
 
   if (ia32_mode) {
     fprintf(out_file, "%%%%{\n"
 "  machine decode_x86_32;\n"
 "  alphtype unsigned char;\n"
 "");
   } else {
-    fprintf(out_file, "END(%%%%{\n"
+    fprintf(out_file, "%%%%{\n"
 "  machine decode_x86_64;\n"
 "  alphtype unsigned char;\n"
 "");
   }
 
   print_common_decoding();
 
   if (enabled(Actions::kInstructionName)) {
     print_name_actions();
   }
 
   fprintf(out_file, "\n  one_instruction =");
 
   print_one_instruction_definition();
 
   fprintf(out_file, ");\n"
 "}%%%%\n"
 "");
   return 0;
 }