Not for committing. Proof that NaCl stuff is insane.

src/parser.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 541 matching lines @@
 
 
 int ParserTraits::NextMaterializedLiteralIndex() {
   return parser_->current_function_state_->NextMaterializedLiteralIndex();
 }
 
 
 void ParserTraits::ReportMessageAt(Scanner::Location source_location,
                                    const char* message,
                                    Vector<const char*> args) {
+  fprintf(stderr, "ParserTraits::ReportMessageAt\n");
   MessageLocation location(parser_->script_,
                            source_location.beg_pos,
                            source_location.end_pos);
+  fprintf(stderr, "message %s, args len %d\n", message, args.length());
   Factory* factory = parser_->isolate()->factory();
   Handle<FixedArray> elements = factory->NewFixedArray(args.length());
   for (int i = 0; i < args.length(); i++) {
+    fprintf(stderr, "looping %d %s\n", i, args[i]);
     Handle<String> arg_string = factory->NewStringFromUtf8(CStrVector(args[i]));
     elements->set(i, *arg_string);
   }
   Handle<JSArray> array = factory->NewJSArrayWithElements(elements);
   Handle<Object> result = factory->NewSyntaxError(message, array);
   parser_->isolate()->Throw(*result, &location);
+  fprintf(stderr, "ParserTraits::ReportMessageAt returns\n");
 }
 
 
 void ParserTraits::ReportMessage(const char* message,
                                  Vector<Handle<String> > args) {
+  fprintf(stderr, "ParserTraits::ReportMessage\n");
   Scanner::Location source_location = parser_->scanner().location();
   ReportMessageAt(source_location, message, args);
+  fprintf(stderr, "ParserTraits::ReportMessage returns\n");
 }
 
 
 void ParserTraits::ReportMessageAt(Scanner::Location source_location,
                                    const char* message,
                                    Vector<Handle<String> > args) {
+  fprintf(stderr, "ParserTraits::ReportMessageAtB\n");
   MessageLocation location(parser_->script_,
                            source_location.beg_pos,
                            source_location.end_pos);
   Factory* factory = parser_->isolate()->factory();
   Handle<FixedArray> elements = factory->NewFixedArray(args.length());
   for (int i = 0; i < args.length(); i++) {
     elements->set(i, *args[i]);
   }
   Handle<JSArray> array = factory->NewJSArrayWithElements(elements);
   Handle<Object> result = factory->NewSyntaxError(message, array);
   parser_->isolate()->Throw(*result, &location);
+  fprintf(stderr, "ParserTraits::ReportMessageAtB returns\n");
 }
 
 
 Handle<String> ParserTraits::GetSymbol() {
   int symbol_id = -1;
   if (parser_->pre_parse_data() != NULL) {
     symbol_id = parser_->pre_parse_data()->GetSymbolIdentifier();
   }
   return parser_->LookupSymbol(symbol_id);
 }
@@ skipping 2881 matching lines @@
   //   'debugger' ';'
 
   int pos = peek_position();
   Expect(Token::DEBUGGER, CHECK_OK);
   ExpectSemicolon(CHECK_OK);
   return factory()->NewDebuggerStatement(pos);
 }
 
 
 void Parser::ReportInvalidPreparseData(Handle<String> name, bool* ok) {
+  fprintf(stderr, "ReportInvalidPreparseData\n");
   SmartArrayPointer<char> name_string = name->ToCString(DISALLOW_NULLS);
   const char* element[1] = { name_string.get() };
-  ReportMessage("invalid_preparser_data",
-                Vector<const char*>(element, 1));
+  Vector<const char*> args_array(element, 1);
+  fprintf(stderr, "constructed args array, length is %d\n", args_array.length());
+
+  // WTF: Adding this line makes it pass!!!
+  //fprintf(stderr, "args_array is at %p\n", reinterpret_cast<void*>(&args_array));
+
+  // This is not enough:
+  // void* foo = reinterpret_cast<void*>(&args_array);
+  // USE(foo);
+
+  // This is not enough either:
+  // const char* foo = reinterpret_cast<const char*>(&args_array);
+  // foo++;
+
+  ReportMessage("invalid_preparser_data", args_array);
+  fprintf(stderr, "ReportInvalidPreparseData returns\n");
   *ok = false;
 }
 
 
 Expression* Parser::ParsePrimaryExpression(bool* ok) {
   // PrimaryExpression ::
   //   'this'
   //   'null'
   //   'true'
   //   'false'
@@ skipping 2013 matching lines @@
       ASSERT(info()->isolate()->has_pending_exception());
     } else {
       result = ParseProgram();
     }
   }
   info()->SetFunction(result);
   return (result != NULL);
 }
 
 } }  // namespace v8::internal