1 # Copyright (C) 2013 Google Inc. All rights reserved. 2 # 3 # Redistribution and use in source and binary forms, with or without 4 # modification, are permitted provided that the following conditions are 5 # met: 6 # 7 # * Redistributions of source code must retain the above copyright 8 # notice, this list of conditions and the following disclaimer. 9 # * Redistributions in binary form must reproduce the above 10 # copyright notice, this list of conditions and the following disclaimer 11 # in the documentation and/or other materials provided with the 12 # distribution. 13 # * Neither the name of Google Inc. nor the names of its 14 # contributors may be used to endorse or promote products derived from 15 # this software without specific prior written permission. 16 # 17 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 29 """Functions for type handling and type conversion (Blink/C++ <-> V8/JS). 30 31 Extends IdlType and IdlUnionType with V8-specific properties, methods, and 32 class methods. 33 34 Spec: 35 http://www.w3.org/TR/WebIDL/#es-type-mapping 36 37 Design doc: http://www.chromium.org/developers/design-documents/idl-compiler 38 """ 39 40 import posixpath 41 42 from idl_types import IdlTypeBase, IdlType, IdlUnionType, IdlArrayOrSequenceType, IdlNullableType 43 import v8_attributes # for IdlType.constructor_type_name 44 from v8_globals import includes 45 46 47 ################################################################################ 48 # V8-specific handling of IDL types 49 ################################################################################ 50 51 NON_WRAPPER_TYPES = frozenset([ 52 'Dictionary', 53 'EventHandler', 54 'EventListener', 55 'NodeFilter', 56 'SerializedScriptValue', 57 ]) 58 TYPED_ARRAYS = { 59 # (cpp_type, v8_type), used by constructor templates 60 'ArrayBuffer': None, 61 'ArrayBufferView': None, 62 'Float32Array': ('float', 'v8::kExternalFloatArray'), 63 'Float64Array': ('double', 'v8::kExternalDoubleArray'), 64 'Int8Array': ('signed char', 'v8::kExternalByteArray'), 65 'Int16Array': ('short', 'v8::kExternalShortArray'), 66 'Int32Array': ('int', 'v8::kExternalIntArray'), 67 'Uint8Array': ('unsigned char', 'v8::kExternalUnsignedByteArray'), 68 'Uint8ClampedArray': ('unsigned char', 'v8::kExternalPixelArray'), 69 'Uint16Array': ('unsigned short', 'v8::kExternalUnsignedShortArray'), 70 'Uint32Array': ('unsigned int', 'v8::kExternalUnsignedIntArray'), 71 } 72 73 IdlType.is_typed_array_element_type = property( 74 lambda self: self.base_type in TYPED_ARRAYS) 75 76 IdlType.is_wrapper_type = property( 77 lambda self: (self.is_interface_type and 78 self.base_type not in NON_WRAPPER_TYPES)) 79 80 81 ################################################################################ 82 # C++ types 83 ################################################################################ 84 85 CPP_TYPE_SAME_AS_IDL_TYPE = set([ 86 'double', 87 'float', 88 'long long', 89 'unsigned long long', 90 ]) 91 CPP_INT_TYPES = set([ 92 'byte', 93 'long', 94 'short', 95 ]) 96 CPP_UNSIGNED_TYPES = set([ 97 'octet', 98 'unsigned int', 99 'unsigned long', 100 'unsigned short', 101 ]) 102 CPP_SPECIAL_CONVERSION_RULES = { 103 'Date': 'double', 104 'Dictionary': 'Dictionary', 105 'EventHandler': 'EventListener*', 106 'NodeFilter': 'RefPtrWillBeRawPtr<NodeFilter>', 107 'Promise': 'ScriptPromise', 108 'ScriptValue': 'ScriptValue', 109 # FIXME: Eliminate custom bindings for XPathNSResolver http://crbug.com/345529 110 'XPathNSResolver': 'RefPtrWillBeRawPtr<XPathNSResolver>', 111 'boolean': 'bool', 112 'unrestricted double': 'double', 113 'unrestricted float': 'float', 114 } 115 116 117 def cpp_type(idl_type, extended_attributes=None, raw_type=False, used_as_rvalue_type=False, used_as_variadic_argument=False, used_in_cpp_sequence=False): 118 """Returns C++ type corresponding to IDL type. 119 120 |idl_type| argument is of type IdlType, while return value is a string 121 122 Args: 123 idl_type: 124 IdlType 125 raw_type: 126 bool, True if idl_type's raw/primitive C++ type should be returned. 127 used_as_rvalue_type: 128 bool, True if the C++ type is used as an argument or the return 129 type of a method. 130 used_as_variadic_argument: 131 bool, True if the C++ type is used as a variadic argument of a method. 132 used_in_cpp_sequence: 133 bool, True if the C++ type is used as an element of a container. 134 Containers can be an array, a sequence or a dictionary. 135 """ 136 def string_mode(): 137 if extended_attributes.get('TreatNullAs') == 'EmptyString': 138 return 'TreatNullAsEmptyString' 139 if idl_type.is_nullable or extended_attributes.get('TreatNullAs') == 'NullString': 140 if extended_attributes.get('TreatUndefinedAs') == 'NullString': 141 return 'TreatNullAndUndefinedAsNullString' 142 return 'TreatNullAsNullString' 143 return '' 144 145 extended_attributes = extended_attributes or {} 146 idl_type = idl_type.preprocessed_type 147 148 # Array or sequence types 149 if used_as_variadic_argument: 150 native_array_element_type = idl_type 151 else: 152 native_array_element_type = idl_type.native_array_element_type 153 if native_array_element_type: 154 vector_type = cpp_ptr_type('Vector', 'HeapVector', native_array_element_type.gc_type) 155 vector_template_type = cpp_template_type(vector_type, native_array_element_type.cpp_type_args(used_in_cpp_sequence=True)) 156 if used_as_rvalue_type: 157 return 'const %s&' % vector_template_type 158 return vector_template_type 159 160 # Simple types 161 base_idl_type = idl_type.base_type 162 163 if base_idl_type in CPP_TYPE_SAME_AS_IDL_TYPE: 164 return base_idl_type 165 if base_idl_type in CPP_INT_TYPES: 166 return 'int' 167 if base_idl_type in CPP_UNSIGNED_TYPES: 168 return 'unsigned' 169 if base_idl_type in CPP_SPECIAL_CONVERSION_RULES: 170 return CPP_SPECIAL_CONVERSION_RULES[base_idl_type] 171 172 if base_idl_type in NON_WRAPPER_TYPES: 173 return ('PassRefPtr<%s>' if used_as_rvalue_type else 'RefPtr<%s>') % base_idl_type 174 if idl_type.is_string_type: 175 if not raw_type: 176 return 'String' 177 return 'V8StringResource<%s>' % string_mode() 178 179 if idl_type.is_typed_array_element_type and raw_type: 180 return base_idl_type + '*' 181 if idl_type.is_interface_type: 182 implemented_as_class = idl_type.implemented_as 183 if raw_type: 184 return implemented_as_class + '*' 185 new_type = 'Member' if used_in_cpp_sequence else 'RawPtr' 186 ptr_type = cpp_ptr_type(('PassRefPtr' if used_as_rvalue_type else 'RefPtr'), new_type, idl_type.gc_type) 187 return cpp_template_type(ptr_type, implemented_as_class) 188 # Default, assume native type is a pointer with same type name as idl type 189 return base_idl_type + '*' 190 191 192 def cpp_type_initializer(idl_type): 193 """Returns a string containing a C++ initialization statement for the 194 corresponding type. 195 196 |idl_type| argument is of type IdlType. 197 """ 198 199 base_idl_type = idl_type.base_type 200 201 if idl_type.native_array_element_type: 202 return '' 203 if idl_type.is_numeric_type: 204 return ' = 0' 205 if base_idl_type == 'boolean': 206 return ' = false' 207 if (base_idl_type in NON_WRAPPER_TYPES or 208 base_idl_type in CPP_SPECIAL_CONVERSION_RULES or 209 base_idl_type == 'any' or 210 idl_type.is_string_type or 211 idl_type.is_enum): 212 return '' 213 return ' = nullptr' 214 215 216 def cpp_type_union(idl_type, extended_attributes=None, raw_type=False): 217 # FIXME: Need to revisit the design of union support. 218 # http://crbug.com/240176 219 return None 220 221 222 def cpp_type_initializer_union(idl_type): 223 return (member_type.cpp_type_initializer for member_type in idl_type.member_types) 224 225 226 # Allow access as idl_type.cpp_type if no arguments 227 IdlTypeBase.cpp_type = property(cpp_type) 228 IdlTypeBase.cpp_type_initializer = property(cpp_type_initializer) 229 IdlTypeBase.cpp_type_args = cpp_type 230 IdlUnionType.cpp_type = property(cpp_type_union) 231 IdlUnionType.cpp_type_initializer = property(cpp_type_initializer_union) 232 IdlUnionType.cpp_type_args = cpp_type_union 233 234 235 IdlArrayOrSequenceType.native_array_element_type = property( 236 lambda self: self.element_type) 237 238 239 def cpp_template_type(template, inner_type): 240 """Returns C++ template specialized to type, with space added if needed.""" 241 if inner_type.endswith('>'): 242 format_string = '{template}<{inner_type} >' 243 else: 244 format_string = '{template}<{inner_type}>' 245 return format_string.format(template=template, inner_type=inner_type) 246 247 248 def cpp_ptr_type(old_type, new_type, gc_type): 249 if gc_type == 'GarbageCollectedObject': 250 return new_type 251 if gc_type == 'WillBeGarbageCollectedObject': 252 if old_type == 'Vector': 253 return 'WillBe' + new_type 254 return old_type + 'WillBe' + new_type 255 return old_type 256 257 258 def v8_type(interface_name): 259 return 'V8' + interface_name 260 261 262 # [ImplementedAs] 263 # This handles [ImplementedAs] on interface types, not [ImplementedAs] in the 264 # interface being generated. e.g., given: 265 # Foo.idl: interface Foo {attribute Bar bar}; 266 # Bar.idl: [ImplementedAs=Zork] interface Bar {}; 267 # when generating bindings for Foo, the [ImplementedAs] on Bar is needed. 268 # This data is external to Foo.idl, and hence computed as global information in 269 # compute_interfaces_info.py to avoid having to parse IDLs of all used interfaces. 270 IdlType.implemented_as_interfaces = {} 271 272 273 def implemented_as(idl_type): 274 base_idl_type = idl_type.base_type 275 if base_idl_type in IdlType.implemented_as_interfaces: 276 return IdlType.implemented_as_interfaces[base_idl_type] 277 return base_idl_type 278 279 280 IdlType.implemented_as = property(implemented_as) 281 282 IdlType.set_implemented_as_interfaces = classmethod( 283 lambda cls, new_implemented_as_interfaces: 284 cls.implemented_as_interfaces.update(new_implemented_as_interfaces)) 285 286 287 # [GarbageCollected] 288 IdlType.garbage_collected_types = set() 289 290 IdlType.is_garbage_collected = property( 291 lambda self: self.base_type in IdlType.garbage_collected_types) 292 293 IdlType.set_garbage_collected_types = classmethod( 294 lambda cls, new_garbage_collected_types: 295 cls.garbage_collected_types.update(new_garbage_collected_types)) 296 297 298 # [WillBeGarbageCollected] 299 IdlType.will_be_garbage_collected_types = set() 300 301 IdlType.is_will_be_garbage_collected = property( 302 lambda self: self.base_type in IdlType.will_be_garbage_collected_types) 303 304 IdlType.set_will_be_garbage_collected_types = classmethod( 305 lambda cls, new_will_be_garbage_collected_types: 306 cls.will_be_garbage_collected_types.update(new_will_be_garbage_collected_types)) 307 308 309 def gc_type(idl_type): 310 if idl_type.is_garbage_collected: 311 return 'GarbageCollectedObject' 312 if idl_type.is_will_be_garbage_collected: 313 return 'WillBeGarbageCollectedObject' 314 return 'RefCountedObject' 315 316 IdlTypeBase.gc_type = property(gc_type) 317 318 319 ################################################################################ 320 # Includes 321 ################################################################################ 322 323 def includes_for_cpp_class(class_name, relative_dir_posix): 324 return set([posixpath.join('bindings', relative_dir_posix, class_name + '.h')]) 325 326 327 INCLUDES_FOR_TYPE = { 328 'object': set(), 329 'Dictionary': set(['bindings/core/v8/Dictionary.h']), 330 'EventHandler': set(['bindings/core/v8/V8AbstractEventListener.h', 331 'bindings/core/v8/V8EventListenerList.h']), 332 'EventListener': set(['bindings/core/v8/BindingSecurity.h', 333 'bindings/core/v8/V8EventListenerList.h', 334 'core/frame/LocalDOMWindow.h']), 335 'HTMLCollection': set(['bindings/core/v8/V8HTMLCollection.h', 336 'core/dom/ClassCollection.h', 337 'core/dom/TagCollection.h', 338 'core/html/HTMLCollection.h', 339 'core/html/HTMLDataListOptionsCollection.h', 340 'core/html/HTMLFormControlsCollection.h', 341 'core/html/HTMLTableRowsCollection.h']), 342 'NodeList': set(['bindings/core/v8/V8NodeList.h', 343 'core/dom/NameNodeList.h', 344 'core/dom/NodeList.h', 345 'core/dom/StaticNodeList.h', 346 'core/html/LabelsNodeList.h']), 347 'Promise': set(['bindings/core/v8/ScriptPromise.h']), 348 'SerializedScriptValue': set(['bindings/core/v8/SerializedScriptValue.h']), 349 'ScriptValue': set(['bindings/core/v8/ScriptValue.h']), 350 } 351 352 353 def includes_for_type(idl_type): 354 idl_type = idl_type.preprocessed_type 355 356 # Simple types 357 base_idl_type = idl_type.base_type 358 if base_idl_type in INCLUDES_FOR_TYPE: 359 return INCLUDES_FOR_TYPE[base_idl_type] 360 if idl_type.is_basic_type: 361 return set() 362 if idl_type.is_typed_array_element_type: 363 return set(['bindings/core/v8/custom/V8%sCustom.h' % base_idl_type]) 364 if base_idl_type.endswith('ConstructorConstructor'): 365 # FIXME: rename to NamedConstructor 366 # FIXME: replace with a [NamedConstructorAttribute] extended attribute 367 # Ending with 'ConstructorConstructor' indicates a named constructor, 368 # and these do not have header files, as they are part of the generated 369 # bindings for the interface 370 return set() 371 if base_idl_type.endswith('Constructor'): 372 # FIXME: replace with a [ConstructorAttribute] extended attribute 373 base_idl_type = idl_type.constructor_type_name 374 if base_idl_type not in component_dir: 375 return set() 376 return set(['bindings/%s/v8/V8%s.h' % (component_dir[base_idl_type], 377 base_idl_type)]) 378 379 IdlType.includes_for_type = property(includes_for_type) 380 IdlUnionType.includes_for_type = property( 381 lambda self: set.union(*[member_type.includes_for_type 382 for member_type in self.member_types])) 383 IdlArrayOrSequenceType.includes_for_type = property( 384 lambda self: self.element_type.includes_for_type) 385 386 387 def add_includes_for_type(idl_type): 388 includes.update(idl_type.includes_for_type) 389 390 IdlTypeBase.add_includes_for_type = add_includes_for_type 391 392 393 def includes_for_interface(interface_name): 394 return IdlType(interface_name).includes_for_type 395 396 397 def add_includes_for_interface(interface_name): 398 includes.update(includes_for_interface(interface_name)) 399 400 401 def impl_should_use_nullable_container(idl_type): 402 return not(idl_type.cpp_type_has_null_value) 403 404 IdlTypeBase.impl_should_use_nullable_container = property( 405 impl_should_use_nullable_container) 406 407 408 def impl_includes_for_type(idl_type, interfaces_info): 409 includes_for_type = set() 410 if idl_type.impl_should_use_nullable_container: 411 includes_for_type.add('bindings/core/v8/Nullable.h') 412 413 idl_type = idl_type.preprocessed_type 414 native_array_element_type = idl_type.native_array_element_type 415 if native_array_element_type: 416 includes_for_type.update(impl_includes_for_type( 417 native_array_element_type, interfaces_info)) 418 includes_for_type.add('wtf/Vector.h') 419 420 base_idl_type = idl_type.base_type 421 if idl_type.is_string_type: 422 includes_for_type.add('wtf/text/WTFString.h') 423 if base_idl_type in interfaces_info: 424 interface_info = interfaces_info[idl_type.base_type] 425 includes_for_type.add(interface_info['include_path']) 426 if base_idl_type in INCLUDES_FOR_TYPE: 427 includes_for_type.update(INCLUDES_FOR_TYPE[base_idl_type]) 428 return includes_for_type 429 430 IdlTypeBase.impl_includes_for_type = impl_includes_for_type 431 432 433 component_dir = {} 434 435 436 def set_component_dirs(new_component_dirs): 437 component_dir.update(new_component_dirs) 438 439 440 ################################################################################ 441 # V8 -> C++ 442 ################################################################################ 443 444 V8_VALUE_TO_CPP_VALUE = { 445 # Basic 446 'Date': 'toCoreDate({v8_value})', 447 'DOMString': '{v8_value}', 448 'ByteString': 'toByteString({arguments})', 449 'ScalarValueString': 'toScalarValueString({arguments})', 450 'boolean': '{v8_value}->BooleanValue()', 451 'float': 'toFloat({arguments})', 452 'unrestricted float': 'toFloat({arguments})', 453 'double': 'toDouble({arguments})', 454 'unrestricted double': 'toDouble({arguments})', 455 'byte': 'toInt8({arguments})', 456 'octet': 'toUInt8({arguments})', 457 'short': 'toInt16({arguments})', 458 'unsigned short': 'toUInt16({arguments})', 459 'long': 'toInt32({arguments})', 460 'unsigned long': 'toUInt32({arguments})', 461 'long long': 'toInt64({arguments})', 462 'unsigned long long': 'toUInt64({arguments})', 463 # Interface types 464 'Dictionary': 'Dictionary({v8_value}, {isolate})', 465 'EventTarget': 'V8DOMWrapper::isDOMWrapper({v8_value}) ? toWrapperTypeInfo(v8::Handle<v8::Object>::Cast({v8_value}))->toEventTarget(v8::Handle<v8::Object>::Cast({v8_value})) : 0', 466 'NodeFilter': 'toNodeFilter({v8_value}, info.Holder(), ScriptState::current({isolate}))', 467 'Promise': 'ScriptPromise::cast(ScriptState::current({isolate}), {v8_value})', 468 'SerializedScriptValue': 'SerializedScriptValue::create({v8_value}, 0, 0, exceptionState, {isolate})', 469 'ScriptValue': 'ScriptValue(ScriptState::current({isolate}), {v8_value})', 470 'Window': 'toDOMWindow({v8_value}, {isolate})', 471 'XPathNSResolver': 'toXPathNSResolver({v8_value}, {isolate})', 472 } 473 474 475 def v8_conversion_needs_exception_state(idl_type): 476 return (idl_type.is_numeric_type or 477 idl_type.is_dictionary or 478 idl_type.name in ('ByteString', 'ScalarValueString', 'SerializedScriptValue')) 479 480 IdlType.v8_conversion_needs_exception_state = property(v8_conversion_needs_exception_state) 481 IdlArrayOrSequenceType.v8_conversion_needs_exception_state = True 482 483 484 TRIVIAL_CONVERSIONS = frozenset([ 485 'any', 486 'boolean', 487 'Date', 488 'Dictionary', 489 'NodeFilter', 490 'XPathNSResolver', 491 'Promise' 492 ]) 493 494 495 def v8_conversion_is_trivial(idl_type): 496 # The conversion is a simple expression that returns the converted value and 497 # cannot raise an exception. 498 return (idl_type.base_type in TRIVIAL_CONVERSIONS or 499 idl_type.is_wrapper_type) 500 501 IdlType.v8_conversion_is_trivial = property(v8_conversion_is_trivial) 502 503 504 def v8_value_to_cpp_value(idl_type, extended_attributes, v8_value, index, isolate): 505 if idl_type.name == 'void': 506 return '' 507 508 # Array or sequence types 509 native_array_element_type = idl_type.native_array_element_type 510 if native_array_element_type: 511 return v8_value_to_cpp_value_array_or_sequence(native_array_element_type, v8_value, index) 512 513 # Simple types 514 idl_type = idl_type.preprocessed_type 515 add_includes_for_type(idl_type) 516 base_idl_type = idl_type.base_type 517 518 if 'EnforceRange' in extended_attributes: 519 arguments = ', '.join([v8_value, 'EnforceRange', 'exceptionState']) 520 elif 'Clamp' in extended_attributes: 521 arguments = ', '.join([v8_value, 'Clamp', 'exceptionState']) 522 elif idl_type.v8_conversion_needs_exception_state: 523 arguments = ', '.join([v8_value, 'exceptionState']) 524 else: 525 arguments = v8_value 526 527 if base_idl_type in V8_VALUE_TO_CPP_VALUE: 528 cpp_expression_format = V8_VALUE_TO_CPP_VALUE[base_idl_type] 529 elif idl_type.is_typed_array_element_type: 530 cpp_expression_format = ( 531 '{v8_value}->Is{idl_type}() ? ' 532 'V8{idl_type}::toImpl(v8::Handle<v8::{idl_type}>::Cast({v8_value})) : 0') 533 elif idl_type.is_dictionary: 534 cpp_expression_format = 'V8{idl_type}::toImpl({isolate}, {v8_value}, exceptionState)' 535 else: 536 cpp_expression_format = ( 537 'V8{idl_type}::toImplWithTypeCheck({isolate}, {v8_value})') 538 539 return cpp_expression_format.format(arguments=arguments, idl_type=base_idl_type, v8_value=v8_value, isolate=isolate) 540 541 542 def v8_value_to_cpp_value_array_or_sequence(native_array_element_type, v8_value, index, isolate='info.GetIsolate()'): 543 # Index is None for setters, index (starting at 0) for method arguments, 544 # and is used to provide a human-readable exception message 545 if index is None: 546 index = 0 # special case, meaning "setter" 547 else: 548 index += 1 # human-readable index 549 if (native_array_element_type.is_interface_type and 550 native_array_element_type.name != 'Dictionary'): 551 this_cpp_type = None 552 ref_ptr_type = cpp_ptr_type('RefPtr', 'Member', native_array_element_type.gc_type) 553 expression_format = '(to{ref_ptr_type}NativeArray<{native_array_element_type}, V8{native_array_element_type}>({v8_value}, {index}, {isolate}, exceptionState))' 554 add_includes_for_type(native_array_element_type) 555 else: 556 ref_ptr_type = None 557 this_cpp_type = native_array_element_type.cpp_type 558 expression_format = 'toImplArray<{cpp_type}>({v8_value}, {index}, {isolate}, exceptionState)' 559 expression = expression_format.format(native_array_element_type=native_array_element_type.name, cpp_type=this_cpp_type, index=index, ref_ptr_type=ref_ptr_type, v8_value=v8_value, isolate=isolate) 560 return expression 561 562 563 def v8_value_to_local_cpp_value(idl_type, extended_attributes, v8_value, variable_name, index=None, declare_variable=True, isolate='info.GetIsolate()', used_in_private_script=False, return_promise=False): 564 """Returns an expression that converts a V8 value to a C++ value and stores it as a local value.""" 565 566 # FIXME: Support union type. 567 if idl_type.is_union_type: 568 return '/* no V8 -> C++ conversion for IDL union type: %s */' % idl_type.name 569 570 this_cpp_type = idl_type.cpp_type_args(extended_attributes=extended_attributes, raw_type=True) 571 idl_type = idl_type.preprocessed_type 572 573 if idl_type.base_type in ('void', 'object', 'EventHandler', 'EventListener'): 574 return '/* no V8 -> C++ conversion for IDL type: %s */' % idl_type.name 575 576 cpp_value = v8_value_to_cpp_value(idl_type, extended_attributes, v8_value, index, isolate) 577 if idl_type.is_string_type or idl_type.v8_conversion_needs_exception_state: 578 # Types that need error handling and use one of a group of (C++) macros 579 # to take care of this. 580 581 args = [variable_name, cpp_value] 582 583 if idl_type.v8_conversion_needs_exception_state: 584 macro = 'TONATIVE_DEFAULT_EXCEPTIONSTATE' if used_in_private_script else 'TONATIVE_VOID_EXCEPTIONSTATE' 585 elif return_promise: 586 macro = 'TOSTRING_VOID_EXCEPTIONSTATE' 587 else: 588 macro = 'TOSTRING_DEFAULT' if used_in_private_script else 'TOSTRING_VOID' 589 590 if macro.endswith('_EXCEPTIONSTATE'): 591 args.append('exceptionState') 592 593 if used_in_private_script: 594 args.append('false') 595 596 suffix = '' 597 598 if return_promise: 599 suffix += '_PROMISE' 600 args.append('info') 601 if macro.endswith('_EXCEPTIONSTATE'): 602 args.append('ScriptState::current(%s)' % isolate) 603 604 if declare_variable: 605 args.insert(0, this_cpp_type) 606 else: 607 suffix += '_INTERNAL' 608 609 return '%s(%s)' % (macro + suffix, ', '.join(args)) 610 611 # Types that don't need error handling, and simply assign a value to the 612 # local variable. 613 614 if not idl_type.v8_conversion_is_trivial: 615 raise Exception('unclassified V8 -> C++ conversion for IDL type: %s' % idl_type.name) 616 617 assignment = '%s = %s' % (variable_name, cpp_value) 618 if declare_variable: 619 return '%s %s' % (this_cpp_type, assignment) 620 return assignment 621 622 623 IdlTypeBase.v8_value_to_local_cpp_value = v8_value_to_local_cpp_value 624 625 626 ################################################################################ 627 # C++ -> V8 628 ################################################################################ 629 630 def preprocess_idl_type(idl_type): 631 if idl_type.is_enum: 632 # Enumerations are internally DOMStrings 633 return IdlType('DOMString') 634 if (idl_type.name in ['Any', 'Object'] or idl_type.is_callback_function): 635 return IdlType('ScriptValue') 636 return idl_type 637 638 IdlTypeBase.preprocessed_type = property(preprocess_idl_type) 639 640 641 def preprocess_idl_type_and_value(idl_type, cpp_value, extended_attributes): 642 """Returns IDL type and value, with preliminary type conversions applied.""" 643 idl_type = idl_type.preprocessed_type 644 if idl_type.name == 'Promise': 645 idl_type = IdlType('ScriptValue') 646 if idl_type.base_type in ['long long', 'unsigned long long']: 647 # long long and unsigned long long are not representable in ECMAScript; 648 # we represent them as doubles. 649 is_nullable = idl_type.is_nullable 650 idl_type = IdlType('double') 651 if is_nullable: 652 idl_type = IdlNullableType(idl_type) 653 cpp_value = 'static_cast<double>(%s)' % cpp_value 654 # HTML5 says that unsigned reflected attributes should be in the range 655 # [0, 2^31). When a value isn't in this range, a default value (or 0) 656 # should be returned instead. 657 extended_attributes = extended_attributes or {} 658 if ('Reflect' in extended_attributes and 659 idl_type.base_type in ['unsigned long', 'unsigned short']): 660 cpp_value = cpp_value.replace('getUnsignedIntegralAttribute', 661 'getIntegralAttribute') 662 cpp_value = 'std::max(0, static_cast<int>(%s))' % cpp_value 663 return idl_type, cpp_value 664 665 666 def v8_conversion_type(idl_type, extended_attributes): 667 """Returns V8 conversion type, adding any additional includes. 668 669 The V8 conversion type is used to select the C++ -> V8 conversion function 670 or v8SetReturnValue* function; it can be an idl_type, a cpp_type, or a 671 separate name for the type of conversion (e.g., 'DOMWrapper'). 672 """ 673 extended_attributes = extended_attributes or {} 674 675 # FIXME: Support union type. 676 if idl_type.is_union_type: 677 return '' 678 679 # Array or sequence types 680 native_array_element_type = idl_type.native_array_element_type 681 if native_array_element_type: 682 if native_array_element_type.is_interface_type: 683 add_includes_for_type(native_array_element_type) 684 return 'array' 685 686 # Simple types 687 base_idl_type = idl_type.base_type 688 # Basic types, without additional includes 689 if base_idl_type in CPP_INT_TYPES: 690 return 'int' 691 if base_idl_type in CPP_UNSIGNED_TYPES: 692 return 'unsigned' 693 if idl_type.is_string_type: 694 if idl_type.is_nullable: 695 return 'StringOrNull' 696 if 'TreatReturnedNullStringAs' not in extended_attributes: 697 return base_idl_type 698 treat_returned_null_string_as = extended_attributes['TreatReturnedNullStringAs'] 699 if treat_returned_null_string_as == 'Null': 700 return 'StringOrNull' 701 if treat_returned_null_string_as == 'Undefined': 702 return 'StringOrUndefined' 703 raise 'Unrecognized TreatReturnedNullStringAs value: "%s"' % treat_returned_null_string_as 704 if idl_type.is_basic_type or base_idl_type == 'ScriptValue': 705 return base_idl_type 706 707 # Data type with potential additional includes 708 add_includes_for_type(idl_type) 709 if base_idl_type in V8_SET_RETURN_VALUE: # Special v8SetReturnValue treatment 710 return base_idl_type 711 712 # Pointer type 713 return 'DOMWrapper' 714 715 IdlTypeBase.v8_conversion_type = v8_conversion_type 716 717 718 V8_SET_RETURN_VALUE = { 719 'boolean': 'v8SetReturnValueBool(info, {cpp_value})', 720 'int': 'v8SetReturnValueInt(info, {cpp_value})', 721 'unsigned': 'v8SetReturnValueUnsigned(info, {cpp_value})', 722 'DOMString': 'v8SetReturnValueString(info, {cpp_value}, info.GetIsolate())', 723 'ByteString': 'v8SetReturnValueString(info, {cpp_value}, info.GetIsolate())', 724 'ScalarValueString': 'v8SetReturnValueString(info, {cpp_value}, info.GetIsolate())', 725 # [TreatReturnedNullStringAs] 726 'StringOrNull': 'v8SetReturnValueStringOrNull(info, {cpp_value}, info.GetIsolate())', 727 'StringOrUndefined': 'v8SetReturnValueStringOrUndefined(info, {cpp_value}, info.GetIsolate())', 728 'void': '', 729 # No special v8SetReturnValue* function (set value directly) 730 'float': 'v8SetReturnValue(info, {cpp_value})', 731 'unrestricted float': 'v8SetReturnValue(info, {cpp_value})', 732 'double': 'v8SetReturnValue(info, {cpp_value})', 733 'unrestricted double': 'v8SetReturnValue(info, {cpp_value})', 734 # No special v8SetReturnValue* function, but instead convert value to V8 735 # and then use general v8SetReturnValue. 736 'array': 'v8SetReturnValue(info, {cpp_value})', 737 'Date': 'v8SetReturnValue(info, {cpp_value})', 738 'EventHandler': 'v8SetReturnValue(info, {cpp_value})', 739 'ScriptValue': 'v8SetReturnValue(info, {cpp_value})', 740 'SerializedScriptValue': 'v8SetReturnValue(info, {cpp_value})', 741 # DOMWrapper 742 'DOMWrapperForMainWorld': 'v8SetReturnValueForMainWorld(info, WTF::getPtr({cpp_value}))', 743 'DOMWrapperFast': 'v8SetReturnValueFast(info, WTF::getPtr({cpp_value}), {script_wrappable})', 744 'DOMWrapperDefault': 'v8SetReturnValue(info, {cpp_value})', 745 } 746 747 748 def v8_set_return_value(idl_type, cpp_value, extended_attributes=None, script_wrappable='', release=False, for_main_world=False): 749 """Returns a statement that converts a C++ value to a V8 value and sets it as a return value. 750 751 """ 752 def dom_wrapper_conversion_type(): 753 if not script_wrappable: 754 return 'DOMWrapperDefault' 755 if for_main_world: 756 return 'DOMWrapperForMainWorld' 757 return 'DOMWrapperFast' 758 759 idl_type, cpp_value = preprocess_idl_type_and_value(idl_type, cpp_value, extended_attributes) 760 this_v8_conversion_type = idl_type.v8_conversion_type(extended_attributes) 761 # SetReturn-specific overrides 762 if this_v8_conversion_type in ['Date', 'EventHandler', 'ScriptValue', 'SerializedScriptValue', 'array']: 763 # Convert value to V8 and then use general v8SetReturnValue 764 cpp_value = idl_type.cpp_value_to_v8_value(cpp_value, extended_attributes=extended_attributes) 765 if this_v8_conversion_type == 'DOMWrapper': 766 this_v8_conversion_type = dom_wrapper_conversion_type() 767 768 format_string = V8_SET_RETURN_VALUE[this_v8_conversion_type] 769 # FIXME: oilpan: Remove .release() once we remove all RefPtrs from generated code. 770 if release: 771 cpp_value = '%s.release()' % cpp_value 772 statement = format_string.format(cpp_value=cpp_value, script_wrappable=script_wrappable) 773 return statement 774 775 776 def v8_set_return_value_union(idl_type, cpp_value, extended_attributes=None, script_wrappable='', release=False, for_main_world=False): 777 # FIXME: Need to revisit the design of union support. 778 # http://crbug.com/240176 779 return None 780 781 782 IdlTypeBase.v8_set_return_value = v8_set_return_value 783 IdlUnionType.v8_set_return_value = v8_set_return_value_union 784 785 IdlType.release = property(lambda self: self.is_interface_type) 786 IdlUnionType.release = property( 787 lambda self: [member_type.is_interface_type 788 for member_type in self.member_types]) 789 790 791 CPP_VALUE_TO_V8_VALUE = { 792 # Built-in types 793 'Date': 'v8DateOrNaN({cpp_value}, {isolate})', 794 'DOMString': 'v8String({isolate}, {cpp_value})', 795 'ByteString': 'v8String({isolate}, {cpp_value})', 796 'ScalarValueString': 'v8String({isolate}, {cpp_value})', 797 'boolean': 'v8Boolean({cpp_value}, {isolate})', 798 'int': 'v8::Integer::New({isolate}, {cpp_value})', 799 'unsigned': 'v8::Integer::NewFromUnsigned({isolate}, {cpp_value})', 800 'float': 'v8::Number::New({isolate}, {cpp_value})', 801 'unrestricted float': 'v8::Number::New({isolate}, {cpp_value})', 802 'double': 'v8::Number::New({isolate}, {cpp_value})', 803 'unrestricted double': 'v8::Number::New({isolate}, {cpp_value})', 804 'void': 'v8Undefined()', 805 # [TreatReturnedNullStringAs] 806 'StringOrNull': '{cpp_value}.isNull() ? v8::Handle<v8::Value>(v8::Null({isolate})) : v8String({isolate}, {cpp_value})', 807 'StringOrUndefined': '{cpp_value}.isNull() ? v8Undefined() : v8String({isolate}, {cpp_value})', 808 # Special cases 809 'EventHandler': '{cpp_value} ? v8::Handle<v8::Value>(V8AbstractEventListener::cast({cpp_value})->getListenerObject(impl->executionContext())) : v8::Handle<v8::Value>(v8::Null({isolate}))', 810 'ScriptValue': '{cpp_value}.v8Value()', 811 'SerializedScriptValue': '{cpp_value} ? {cpp_value}->deserialize() : v8::Handle<v8::Value>(v8::Null({isolate}))', 812 # General 813 'array': 'v8Array({cpp_value}, {creation_context}, {isolate})', 814 'DOMWrapper': 'toV8({cpp_value}, {creation_context}, {isolate})', 815 } 816 817 818 def cpp_value_to_v8_value(idl_type, cpp_value, isolate='info.GetIsolate()', creation_context='info.Holder()', extended_attributes=None): 819 """Returns an expression that converts a C++ value to a V8 value.""" 820 # the isolate parameter is needed for callback interfaces 821 idl_type, cpp_value = preprocess_idl_type_and_value(idl_type, cpp_value, extended_attributes) 822 this_v8_conversion_type = idl_type.v8_conversion_type(extended_attributes) 823 format_string = CPP_VALUE_TO_V8_VALUE[this_v8_conversion_type] 824 statement = format_string.format(cpp_value=cpp_value, isolate=isolate, creation_context=creation_context) 825 return statement 826 827 IdlTypeBase.cpp_value_to_v8_value = cpp_value_to_v8_value 828 829 830 def literal_cpp_value(idl_type, idl_literal): 831 """Converts an expression that is a valid C++ literal for this type.""" 832 # FIXME: add validation that idl_type and idl_literal are compatible 833 literal_value = str(idl_literal) 834 if idl_type.base_type in CPP_UNSIGNED_TYPES: 835 return literal_value + 'u' 836 return literal_value 837 838 IdlType.literal_cpp_value = literal_cpp_value 839 840 841 ################################################################################ 842 # Utility properties for nullable types 843 ################################################################################ 844 845 846 def cpp_type_has_null_value(idl_type): 847 # - String types (String/AtomicString) represent null as a null string, 848 # i.e. one for which String::isNull() returns true. 849 # - Enum types, as they are implemented as Strings. 850 # - Wrapper types (raw pointer or RefPtr/PassRefPtr) represent null as 851 # a null pointer. 852 # - Dictionary types represent null as a null pointer. They are garbage 853 # collected so their type is raw pointer. 854 # - 'Object' type. We use ScriptValue for object type. 855 return (idl_type.is_string_type or idl_type.is_wrapper_type or 856 idl_type.is_enum or idl_type.is_dictionary or idl_type.base_type == 'object') 857 858 IdlTypeBase.cpp_type_has_null_value = property(cpp_type_has_null_value) 859 860 861 def is_implicit_nullable(idl_type): 862 # Nullable type where the corresponding C++ type supports a null value. 863 return idl_type.is_nullable and idl_type.cpp_type_has_null_value 864 865 866 def is_explicit_nullable(idl_type): 867 # Nullable type that isn't implicit nullable (see above.) For such types, 868 # we use Nullable<T> or similar explicit ways to represent a null value. 869 return idl_type.is_nullable and not idl_type.is_implicit_nullable 870 871 IdlTypeBase.is_implicit_nullable = property(is_implicit_nullable) 872 IdlUnionType.is_implicit_nullable = False 873 IdlTypeBase.is_explicit_nullable = property(is_explicit_nullable) 874
