Add attributions so printf like functions can have their arguments checked.

runtime/vm/parser.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 32 matching lines @@
 
 class TraceParser : public ValueObject {
  public:
   TraceParser(intptr_t token_pos, const Script& script, const char* msg) {
     if (FLAG_trace_parser) {
       // Skips tracing of bootstrap libraries.
       if (script.HasSource()) {
         intptr_t line, column;
         script.GetTokenLocation(token_pos, &line, &column);
         PrintIndent();
-        OS::Print("%s (line %d, col %d, token %d)\n",
+        OS::Print("%s (line %"Pd", col %"Pd", token %"Pd")\n",
                   msg, line, column, token_pos);
       }
       indent_++;
     }
   }
   ~TraceParser() { indent_--; }
  private:
   void PrintIndent() {
     for (int i = 0; i < indent_; i++) { OS::Print(". "); }
   }
@@ skipping 275 matching lines @@
   TimerScope timer(FLAG_compiler_stats, &CompilerStats::parser_timer);
   Parser parser(script, library);
   parser.ParseTopLevel();
 }
 
 
 Token::Kind Parser::CurrentToken() {
   if (token_kind_ == Token::kILLEGAL) {
     token_kind_ = tokens_iterator_.CurrentTokenKind();
     if (token_kind_ == Token::kERROR) {
-      ErrorMsg(TokenPos(), CurrentLiteral()->ToCString());
+      ErrorMsg(TokenPos(), "%s", CurrentLiteral()->ToCString());
     }
   }
   CompilerStats::num_token_checks++;
   return token_kind_;
 }
 
 
 Token::Kind Parser::LookaheadToken(int num_tokens) {
   CompilerStats::num_tokens_lookahead++;
   CompilerStats::num_token_checks++;
@@ skipping 2377 matching lines @@
       (operator_token == Token::kBIT_NOT)) {
     // TODO(hausner): Remove support for keyword 'negate'.
     expected_num_parameters = 1;
   } else {
     expected_num_parameters = 2;
   }
   if ((member.params.num_optional_parameters > 0) ||
       (member.params.has_named_optional_parameters) ||
       (member.params.num_fixed_parameters != expected_num_parameters)) {
     // Subtract receiver when reporting number of expected arguments.
-    ErrorMsg(member.name_pos, "operator %s expects %d argument(s)",
+    ErrorMsg(member.name_pos, "operator %s expects %"Pd" argument(s)",
         member.name->ToCString(), (expected_num_parameters - 1));
   }
 }
 
 
 void Parser::ParseClassMemberDefinition(ClassDesc* members) {
   TRACE_PARSER("ParseClassMemberDefinition");
   MemberDesc member;
   current_member_ = &member;
   if ((CurrentToken() == Token::kABSTRACT) &&
@@ skipping 3410 matching lines @@
                            intptr_t message_buffer_size,
                            const char* format, va_list args) {
   intptr_t msg_len = 0;
   if (!script.IsNull()) {
     const String& script_url = String::CheckedHandle(script.url());
     if (token_pos >= 0) {
       intptr_t line, column;
       script.GetTokenLocation(token_pos, &line, &column);
       msg_len += OS::SNPrint(message_buffer + msg_len,
                              message_buffer_size - msg_len,
-                             "'%s': %s: line %d pos %d: ",
+                             "'%s': %s: line %"Pd" pos %"Pd": ",
                              script_url.ToCString(),
                              message_header,
                              line,
                              column);
       if (msg_len < message_buffer_size) {
         // Append the formatted error or warning message.
         msg_len += OS::VSNPrint(message_buffer + msg_len,
                                 message_buffer_size - msg_len,
                                 format,
                                 args);
         if (msg_len < message_buffer_size) {
           // Append the source line.
           const String& script_line = String::Handle(script.GetLine(line));
           ASSERT(!script_line.IsNull());
           msg_len += OS::SNPrint(message_buffer + msg_len,
                                  message_buffer_size - msg_len,
                                  "\n%s\n%*s\n",
                                  script_line.ToCString(),
-                                 column,
+                                 static_cast<int>(column),
                                  "^");
         }
       }
     } else {
       // Token position is unknown.
       msg_len += OS::SNPrint(message_buffer + msg_len,
                              message_buffer_size - msg_len,
                              "'%s': %s: ",
                              script_url.ToCString(),
                              message_header);
@@ skipping 98 matching lines @@
   if (FLAG_warning_as_error) {
     Isolate::Current()->long_jump_base()->Jump(1, error);
     UNREACHABLE();
   } else {
     OS::Print("%s", error.ToErrorCString());
   }
 }
 
 
 void Parser::Unimplemented(const char* msg) {
-  ErrorMsg(TokenPos(), msg);
+  ErrorMsg(TokenPos(), "%s", msg);
 }
 
 
 void Parser::ExpectToken(Token::Kind token_expected) {
   if (CurrentToken() != token_expected) {
     ErrorMsg("'%s' expected", Token::Str(token_expected));
   }
   ConsumeToken();
 }
 
 
 void Parser::ExpectSemicolon() {
   if (CurrentToken() != Token::kSEMICOLON) {
     ErrorMsg("semicolon expected");
   }
   ConsumeToken();
 }
 
 
 void Parser::UnexpectedToken() {
   ErrorMsg("unexpected token '%s'",
            CurrentToken() == Token::kIDENT ?
                CurrentLiteral()->ToCString() : Token::Str(CurrentToken()));
 }
 
 
 String* Parser::ExpectClassIdentifier(const char* msg) {
   if (CurrentToken() != Token::kIDENT) {
-    ErrorMsg(msg);
+    ErrorMsg("%s", msg);
   }
   String* ident = CurrentLiteral();
   if (ident->Equals("Dynamic")) {
-    ErrorMsg(msg);
+    ErrorMsg("%s", msg);
   }
   ConsumeToken();
   return ident;
 }
 
 
 // Check whether current token is an identifier or a built-in identifier.
 String* Parser::ExpectIdentifier(const char* msg) {
   if (!IsIdentifier()) {
-    ErrorMsg(msg);
+    ErrorMsg("%s", msg);
   }
   String* ident = CurrentLiteral();
   ConsumeToken();
   return ident;
 }
 
 
 bool Parser::IsLiteral(const char* literal) {
   const uint8_t* characters = reinterpret_cast<const uint8_t*>(literal);
   intptr_t len = strlen(literal);
@@ skipping 157 matching lines @@
 
 void Parser::EnsureExpressionTemp() {
   // Temporary used later by the flow_graph_builder.
   GetIncrementTempLocal();
 }
 
 
 LocalVariable* Parser::CreateTempConstVariable(intptr_t token_pos,
                                                const char* s) {
   char name[64];
-  OS::SNPrint(name, 64, ":%s%d", s, token_pos);
+  OS::SNPrint(name, 64, ":%s%"Pd, s, token_pos);
   LocalVariable* temp =
       new LocalVariable(token_pos,
                         String::ZoneHandle(Symbols::New(name)),
                         Type::ZoneHandle(Type::DynamicType()));
   temp->set_is_final();
   current_block_->scope->AddVariable(temp);
   return temp;
 }
 
 
@@ skipping 2372 matching lines @@
   intptr_t param_index;
   if (!IsFormalParameter(*ident, &owner_function, &owner_scope, &param_index)) {
     ErrorMsg(ident_pos, "formal parameter name expected");
   }
   if (param_index < owner_function.num_fixed_parameters()) {
     // The formal parameter is not optional, therefore the corresponding
     // argument is always passed and defined.
     return new LiteralNode(test_pos, Bool::ZoneHandle(Bool::True()));
   }
   char name[64];
-  OS::SNPrint(name, 64, "%s_%d",
+  OS::SNPrint(name, 64, "%s_%"Pd"",
               Symbols::Name(Symbols::kSavedArgDescVarPrefix),
               owner_function.token_pos());
   const String& saved_args_desc_name = String::ZoneHandle(Symbols::New(name));
   LocalVariable* saved_args_desc_var = LookupLocalScope(saved_args_desc_name);
   if (saved_args_desc_var == NULL) {
     ASSERT(owner_scope != NULL);
     saved_args_desc_var =
         new LocalVariable(owner_function.token_pos(),
                           saved_args_desc_name,
                           Type::ZoneHandle(Type::ListInterface()));
@@ skipping 444 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart