Generation of sdk/lib files from 45 roll

tools/dom/scripts/generate_blink_file.py

 #!/usr/bin/python
 #
 # Copyright (c) 2014, 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.
 
 """Generates sdk/lib/_blink/dartium/_blink_dartium.dart file."""
 
 import os
 
@@ skipping 131 matching lines @@
 #(argument_count, arguments, interface_name, arguments)
 CONSTRUCTOR_ARGS = '  constructorCallback_%s_(%s) => new js.JsObject(Blink_JsNative_DomException.getProperty(js.context, "%s"), [%s]);\n\n'
 
 #(attribute_name, attribute_name)
 ATTRIBUTE_GETTER = '  %s_Getter_(mthis) => Blink_JsNative_DomException.getProperty(mthis, "%s");\n\n'
 ATTRIBUTE_SETTER = '  %s_Setter_(mthis, __arg_0) => mthis["%s"] = __arg_0;\n\n'
 
 #(operation_name, operationName)
 OPERATION_0 = '  %s_Callback_0_(mthis) => Blink_JsNative_DomException.callMethod(mthis, "%s", []);\n\n'
 
+# getter, setter, deleter and propertyQuery code
+OPERATION_1 = '  $%s_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException.callMethod(mthis, "%s", [__arg_0]);\n\n'
+OPERATION_2 = '  $%s_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException.callMethod(mthis, "%s", [__arg_0, __arg_1]);\n\n'
+OPERATION_PQ = '  $%s_Callback_1_(mthis, __arg_0) => mthis[__arg_0];\n\n'
+
 #(operation_name, argument_count, arguments, operation_name, arguments)
 ARGUMENT_NUM = "__arg_%s"
 OPERATION_ARGS = '  %s_Callback_%s_(mthis, %s) => Blink_JsNative_DomException.callMethod(mthis, "%s", [%s]);\n\n'
 
 CLASS_DEFINITION_END = """}
 
 """
 
 def ConstantOutputOrder(a, b):
   """Canonical output ordering for constants."""
   return cmp(a.id, b.id)
 
 def generate_parameter_entries(param_infos):
     optional_default_args = 0;
     for argument in param_infos:
       if argument.is_optional:
         optional_default_args += 1
 
     arg_count = len(param_infos)
     min_arg_count = arg_count - optional_default_args
     lb = min_arg_count - 2 if min_arg_count > 2 else 0
     return (lb, arg_count + 1)
 
+constructor_renames = {
+    'RTCPeerConnection': 'webkitRTCPeerConnection',
+}
+
+def rename_constructor(name):
+  return constructor_renames[name] if name in constructor_renames else name
+
 def Generate_Blink(output_dir, database, type_registry):
   blink_filename = os.path.join(output_dir, '_blink_dartium.dart')
   blink_file = open(blink_filename, 'w')
 
   blink_file.write(HEADER);
 
   interfaces = database.GetInterfaces()
   for interface in interfaces:
     name = interface.id
     resolver_entry = '  if (s == "%s") return Blink%s.instance;\n' % (name, name)
     blink_file.write(resolver_entry)
 
   blink_file.write(END_RESOLVER);
 
   for interface in interfaces:
     name = interface.id
 
     if interface.parents and len(interface.parents) > 0 and interface.parents[0].id:
       extends = interface.parents[0].id
       class_def = CLASS_DEFINITION_EXTENDS % (name, extends, name)
     else:
       class_def = CLASS_DEFINITION % (name, name)
     blink_file.write(class_def);
 
     analyzed_constructors = AnalyzeConstructor(interface)
     if analyzed_constructors:
       _Emit_Blink_Constructors(blink_file, analyzed_constructors)
     elif 'Constructor' in interface.ext_attrs:
       # Zero parameter constructor.
-      blink_file.write(CONSTRUCTOR_0 % name)
+      blink_file.write(CONSTRUCTOR_0 % rename_constructor(name))
 
     _Process_Attributes(blink_file, interface.attributes)
     _Process_Operations(blink_file, interface, interface.operations)
 
     secondary_parents = database.TransitiveSecondaryParents(interface, False)
     for secondary in secondary_parents:
       _Process_Attributes(blink_file, secondary.attributes)
       _Process_Operations(blink_file, secondary, secondary.operations)
 
     blink_file.write(CLASS_DEFINITION_END);
 
   blink_file.write(BLINK_UTILS)
 
   blink_file.close()
 
 def _Emit_Blink_Constructors(blink_file, analyzed_constructors):
   (arg_min_count, arg_max_count) = generate_parameter_entries(analyzed_constructors.param_infos)
   name = analyzed_constructors.js_name
   if not(name):
     name = analyzed_constructors.type_name
 
   for callback_index in range(arg_min_count, arg_max_count):
     if callback_index == 0:
-      blink_file.write(CONSTRUCTOR_0 % (name))
+      blink_file.write(CONSTRUCTOR_0 % (rename_constructor(name)))
     else:
       arguments = []
       for i in range(0, callback_index):
         arguments.append(ARGUMENT_NUM % i)
       argument_list = ', '.join(arguments)
-      blink_file.write(CONSTRUCTOR_ARGS % (callback_index, argument_list, name, argument_list))
+      blink_file.write(CONSTRUCTOR_ARGS % (callback_index, argument_list, rename_constructor(name), argument_list))
 
 def _Process_Attributes(blink_file, attributes):
   # Emit an interface's attributes and operations.
   for attribute in sorted(attributes, ConstantOutputOrder):
     name = attribute.id
     if attribute.is_read_only:
       blink_file.write(ATTRIBUTE_GETTER % (name, name))
     else:
       blink_file.write(ATTRIBUTE_GETTER % (name, name))
       blink_file.write(ATTRIBUTE_SETTER % (name, name))
@@ skipping 12 matching lines @@
         _Emit_Blink_Operation(blink_file, interface, analyzeOperations)
         analyzeOperations = [operation]
   if len(analyzeOperations) > 0:
     _Emit_Blink_Operation(blink_file, interface, analyzeOperations)
 
 def _Emit_Blink_Operation(blink_file, interface, analyzeOperations):
   analyzed = AnalyzeOperation(interface, analyzeOperations)
   (arg_min_count, arg_max_count) = generate_parameter_entries(analyzed.param_infos)
   name = analyzed.js_name
 
+  operation = analyzeOperations[0]
+  if (name.startswith('__') and \
+      ('getter' in operation.specials or \
+       'setter' in operation.specials or \
+       'deleter' in operation.specials)):
+    if name == '__propertyQuery__':
+      blink_file.write(OPERATION_PQ % (name))
+    else:
+      arg_min_count = arg_max_count
+      if arg_max_count == 2:
+        blink_file.write(OPERATION_1 % (name, name))
+      elif arg_max_count == 3:
+        blink_file.write(OPERATION_2 % (name, name))
+      else:
+        print "FATAL ERROR: _blink emitter operator %s.%s" % (interface.id, name)
+        exit
+
+    return
+
   for callback_index in range(arg_min_count, arg_max_count):
     if callback_index == 0:
       blink_file.write(OPERATION_0 % (name, name))
     else:
       arguments = []
       for i in range(0, callback_index):
         arguments.append(ARGUMENT_NUM % i)
       argument_list = ', '.join(arguments)
       blink_file.write(OPERATION_ARGS % (name, callback_index, argument_list, name, argument_list))