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

runtime/vm/dart_api_impl.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 "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 55 matching lines @@
   return Api::NewError("%s expects argument '%s' to be non-null.",             \
                        CURRENT_FUNC, #parameter);
 
 
 #define CHECK_LENGTH(length, max_elements)                                     \
   do {                                                                         \
     intptr_t len = (length);                                                   \
     intptr_t max = (max_elements);                                             \
     if (len < 0 || len > max) {                                                \
       return Api::NewError(                                                    \
-          "%s expects argument '%s' to be in the range [0..%ld].",             \
+          "%s expects argument '%s' to be in the range [0..%"Pd"].",           \
           CURRENT_FUNC, #length, max);                                         \
     }                                                                          \
   } while (0)
 
 
 // Return error if isolate is in an inconsistent state.
 // Return NULL when no error condition exists.
 //
 // TODO(turnidge): Make this function return an error handle directly
 // rather than returning an error string.  The current behavior can
@@ skipping 747 matching lines @@
   DARTSCOPE(isolate);
   TIMERSCOPE(time_creating_snapshot);
   if (buffer == NULL) {
     RETURN_NULL_ERROR(buffer);
   }
   if (size == NULL) {
     RETURN_NULL_ERROR(size);
   }
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
-    return Api::NewError(msg);
+    return Api::NewError("%s", msg);
   }
   // Since this is only a snapshot the root library should not be set.
   isolate->object_store()->set_root_library(Library::Handle(isolate));
   FullSnapshotWriter writer(buffer, ApiReallocate);
   writer.WriteFullSnapshot();
   *size = writer.BytesWritten();
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_CreateScriptSnapshot(uint8_t** buffer,
                                                   intptr_t* size) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   TIMERSCOPE(time_creating_snapshot);
   if (buffer == NULL) {
     RETURN_NULL_ERROR(buffer);
   }
   if (size == NULL) {
     RETURN_NULL_ERROR(size);
   }
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
-    return Api::NewError(msg);
+    return Api::NewError("%s", msg);
   }
   Library& library =
       Library::Handle(isolate, isolate->object_store()->root_library());
   if (library.IsNull()) {
     return
         Api::NewError("%s expects the isolate to have a script loaded in it.",
                       CURRENT_FUNC);
   }
   ScriptSnapshotWriter writer(buffer, ApiReallocate);
   writer.WriteScriptSnapshot(library);
@@ skipping 301 matching lines @@
   if (obj.IsError()) {
     return object;
   } else if (!obj.IsNull() && !obj.IsInstance()) {
     return Api::NewError(
         "%s expects argument 'object' to be an instance of Object.",
         CURRENT_FUNC);
   }
   // Finalize all classes.
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
-    return Api::NewError(msg);
+    return Api::NewError("%s", msg);
   }
   if (obj.IsInstance()) {
     const Type& type = Type::Handle(isolate,
                                     Type::NewNonParameterizedType(cls));
     Error& malformed_type_error = Error::Handle(isolate);
     *value = Instance::Cast(obj).IsInstanceOf(type,
                                               TypeArguments::Handle(isolate),
                                               &malformed_type_error);
     ASSERT(malformed_type_error.IsNull());  // Type was created from a class.
   } else {
@@ skipping 1272 matching lines @@
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
   if (cls.IsNull()) {
     RETURN_TYPE_ERROR(isolate, clazz, Class);
   }
 
   // Finalize all classes.
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
-    return Api::NewError(msg);
+    return Api::NewError("%s", msg);
   }
 
   if (cls.HasFactoryClass() && cls.HasResolvedFactoryClass()) {
     return Api::NewHandle(isolate, cls.FactoryClass());
   }
   return Api::Null(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ClassGetInterfaceCount(Dart_Handle clazz,
@@ skipping 20 matching lines @@
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Class& cls = Api::UnwrapClassHandle(isolate, clazz);
   if (cls.IsNull()) {
     RETURN_TYPE_ERROR(isolate, clazz, Class);
   }
 
   // Finalize all classes.
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
-    return Api::NewError(msg);
+    return Api::NewError("%s", msg);
   }
 
   const Array& interface_types = Array::Handle(isolate, cls.interfaces());
   if (index < 0 || index >= interface_types.Length()) {
     return Api::NewError("%s: argument 'index' out of bounds.", CURRENT_FUNC);
   }
   Type& interface_type = Type::Handle(isolate);
   interface_type ^= interface_types.At(index);
   if (interface_type.HasResolvedTypeClass()) {
     return Api::NewHandle(isolate, interface_type.type_class());
@@ skipping 518 matching lines @@
   if (name_obj.IsNull()) {
     dot_name = Symbols::Dot();
   } else if (name_obj.IsString()) {
     const String& dot = String::Handle(isolate, Symbols::Dot());
     dot_name = String::Concat(dot, String::Cast(name_obj));
   } else {
     RETURN_TYPE_ERROR(isolate, constructor_name, String);
   }
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
-    return Api::NewError(msg);
+    return Api::NewError("%s", msg);
   }
 
   // Check for interfaces with default implementations.
   if (cls.is_interface()) {
     // Make sure that the constructor is found in the interface.
     result = ResolveConstructor(
         "Dart_New", cls, base_constructor_name, dot_name, number_of_arguments);
     if (result.IsError()) {
       return Api::NewHandle(isolate, result.raw());
     }
@@ skipping 134 matching lines @@
                            function_name.ToCString());
     }
     return Api::NewHandle(
         isolate,
         DartEntry::InvokeDynamic(instance, function, args, kNoArgNames));
 
   } else if (obj.IsClass()) {
     // Finalize all classes.
     const char* msg = CheckIsolateState(isolate);
     if (msg != NULL) {
-      return Api::NewError(msg);
+      return Api::NewError("%s", msg);
     }
 
     const Class& cls = Class::Cast(obj);
     const Function& function = Function::Handle(
         isolate,
         Resolver::ResolveStatic(cls,
                                 function_name,
                                 number_of_arguments,
                                 Array::Handle(isolate),
                                 Resolver::kIsQualified));
@@ skipping 18 matching lines @@
     Library& builtin =
         Library::Handle(isolate, isolate->object_store()->builtin_library());
     if (builtin.raw() == lib.raw()) {
       finalize_classes = false;
     }
 
     // Finalize all classes if needed.
     if (finalize_classes) {
       const char* msg = CheckIsolateState(isolate);
       if (msg != NULL) {
-        return Api::NewError(msg);
+        return Api::NewError("%s", msg);
       }
     }
 
     Function& function = Function::Handle(isolate);
     function = lib.LookupFunctionAllowPrivate(function_name);
     if (function.IsNull()) {
       return Api::NewError("%s: did not find top-level function '%s'.",
                            CURRENT_FUNC,
                            function_name.ToCString());
     }
@@ skipping 72 matching lines @@
     GrowableArray<const Object*> args;
     const Array& kNoArgNames = Array::Handle(isolate);
     return Api::NewHandle(
         isolate,
         DartEntry::InvokeDynamic(instance, getter, args, kNoArgNames));
 
   } else if (obj.IsClass()) {
     // Finalize all classes.
     const char* msg = CheckIsolateState(isolate);
     if (msg != NULL) {
-      return Api::NewError(msg);
+      return Api::NewError("%s", msg);
     }
     // To access a static field we may need to use the Field or the
     // getter Function.
     const Class& cls = Class::Cast(obj);
     field = cls.LookupStaticField(field_name);
     if (field.IsNull() || FieldIsUninitialized(isolate, field)) {
       const String& getter_name =
           String::Handle(isolate, Field::GetterName(field_name));
       getter = cls.LookupStaticFunction(getter_name);
     }
@@ skipping 536 matching lines @@
   }
 }
 
 
 DART_EXPORT Dart_Handle Dart_CompileAll() {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   Dart_Handle result;
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
-    return Api::NewError(msg);
+    return Api::NewError("%s", msg);
   }
   CompileAll(isolate, &result);
   return result;
 }
 
 
 DART_EXPORT bool Dart_IsLibrary(Dart_Handle object) {
   return Api::ClassId(object) == kLibraryCid;
 }
 
@@ skipping 130 matching lines @@
   // Propagate the error out right now.
   if (::Dart_IsError(result)) {
     return result;
   }
 
   // If this is the dart:builtin library, register it with the VM.
   if (url_str.Equals("dart:builtin")) {
     isolate->object_store()->set_builtin_library(library);
     const char* msg = CheckIsolateState(isolate);
     if (msg != NULL) {
-      return Api::NewError(msg);
+      return Api::NewError("%s", msg);
     }
   }
   return result;
 }
 
 
 DART_EXPORT Dart_Handle Dart_LibraryImportLibrary(Dart_Handle library,
                                                   Dart_Handle import,
                                                   Dart_Handle prefix) {
   Isolate* isolate = Isolate::Current();
@@ skipping 110 matching lines @@
 DART_EXPORT void Dart_InitPerfEventsSupport(Dart_FileWriterFunction function) {
   Dart::set_perf_events_writer(function);
 }
 
 
 DART_EXPORT void Dart_InitFlowGraphPrinting(Dart_FileWriterFunction function) {
   Dart::set_flow_graph_writer(function);
 }
 
 }  // namespace dart