Move validator_x86_XX.rl out of unreviewed.

src/trusted/validator_ragel/unreviewed/validator_test.c

 /*
  * 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 <assert.h>
 #include <stdio.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "native_client/src/include/elf32.h"
 #include "native_client/src/include/elf64.h"
 #include "native_client/src/shared/platform/nacl_check.h"
 #include "native_client/src/shared/utils/types.h"
-#include "native_client/src/trusted/validator_ragel/unreviewed/validator_internal.h"
+#include "native_client/src/trusted/validator_ragel/validator_internal.h"
 
 /* This is a copy of NaClLog from shared/platform/nacl_log.c to avoid
  * linking in code in NaCl shared code in the unreviewed/Makefile and be able to
  *  use CHECK().
 
  * TODO(khim): remove the copy of NaClLog implementation as soon as
  * unreviewed/Makefile is eliminated.
  */
 void NaClLog(int detail_level, char const  *fmt, ...) {
   va_list ap;
@@ skipping 197 matching lines @@
 
   ReadImage(filename, &data, &data_size);
 
   for (count = 0; count < repeat_count; ++count) {
     Bool rc = FALSE;
     if (raw_bitness == 0)
       rc = ValidateElf(filename,
                        data, data_size,
                        options,
                        cpu_features);
     else if (raw_bitness == 32) {

[Brad Chen, 2012/10/05 16:47:21]

This looks like non-standard formatting for if statement. Please fix. I expected
to see {} for all multi-line blocks (even if they are only one statement) and no
newline for "} else {"

[khim, 2012/10/15 16:38:57]

Actually the style guide contains few recommendations (not requirements), and
one firm rule (if one part of an if-else statement uses curly braces, the other
part must too) and it's violated here.

Fixed

       struct ValidateState state;
       state.offset = data;
       CHECK(data_size % kBundleSize == 0);
       rc = ValidateChunkIA32(data, data_size,
                              options, cpu_features,
                              ProcessError, &state);
     }
     else if (raw_bitness == 64) {
       struct ValidateState state;
       state.offset = data;
       CHECK(data_size % kBundleSize == 0);
       rc = ValidateChunkAMD64(data, data_size,
                               options, cpu_features,
                               ProcessError, &state);
     }
     if (!rc) {
       printf("file '%s' can not be fully validated\n", filename);
       exit(1);
     }
   }
 }
 
 int main(int argc, char **argv) {
   int index, initial_index = 1, repeat_count = 1;
-  const NaClCPUFeaturesX86 *cpu_features = &full_cpuid_features;
+  const NaClCPUFeaturesX86 *cpu_features = &kFullCPUIDFeatures;
   int raw_bitness = 0;
   enum validation_options options = 0;
 
   if (argc == 1) {
     printf("%s: no input files\n", argv[0]);
     return 2;
   }
   while (initial_index < argc) {
     char *arg = argv[initial_index];
     if (!strcmp(arg, "--repeat")) {
       if (initial_index+1 >= argc) {
         printf("%s: no integer after --repeat\n", argv[0]);
         return 2;
       }
       repeat_count = atoi(argv[initial_index + 1]);
       initial_index += 2;
     }
     else if (!strcmp(arg, "--compatible")) {
-      cpu_features = &validator_cpuid_features;
+      cpu_features = &kValidatorCPUIDFeatures;
       initial_index++;
     }
     else if (!strcmp(arg, "--nobundles")) {
       options |= PROCESS_CHUNK_AS_A_CONTIGUOUS_STREAM;
       initial_index++;
     }
     else if (!strcmp(argv[initial_index], "--raw32")) {
       raw_bitness = 32;
       initial_index++;
     }
     else if (!strcmp(argv[initial_index], "--raw64")) {
       raw_bitness = 64;
       initial_index++;
     }
     else
       break;
   }
   for (index = initial_index; index < argc; ++index) {
     const char *filename = argv[index];
     ProcessFile(filename, repeat_count, raw_bitness, options, cpu_features);
   }
   return 0;
 }