OLD | NEW |
1 // Copyright 2012 the V8 project authors. All rights reserved. | 1 // Copyright 2012 the V8 project authors. All rights reserved. |
2 // Redistribution and use in source and binary forms, with or without | 2 // Redistribution and use in source and binary forms, with or without |
3 // modification, are permitted provided that the following conditions are | 3 // modification, are permitted provided that the following conditions are |
4 // met: | 4 // met: |
5 // | 5 // |
6 // * Redistributions of source code must retain the above copyright | 6 // * Redistributions of source code must retain the above copyright |
7 // notice, this list of conditions and the following disclaimer. | 7 // notice, this list of conditions and the following disclaimer. |
8 // * Redistributions in binary form must reproduce the above | 8 // * Redistributions in binary form must reproduce the above |
9 // copyright notice, this list of conditions and the following | 9 // copyright notice, this list of conditions and the following |
10 // disclaimer in the documentation and/or other materials provided | 10 // disclaimer in the documentation and/or other materials provided |
(...skipping 1031 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1042 | 1042 |
1043 | 1043 |
1044 void FunctionTemplate::Inherit(v8::Handle<FunctionTemplate> value) { | 1044 void FunctionTemplate::Inherit(v8::Handle<FunctionTemplate> value) { |
1045 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); | 1045 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); |
1046 if (IsDeadCheck(isolate, "v8::FunctionTemplate::Inherit()")) return; | 1046 if (IsDeadCheck(isolate, "v8::FunctionTemplate::Inherit()")) return; |
1047 ENTER_V8(isolate); | 1047 ENTER_V8(isolate); |
1048 Utils::OpenHandle(this)->set_parent_template(*Utils::OpenHandle(*value)); | 1048 Utils::OpenHandle(this)->set_parent_template(*Utils::OpenHandle(*value)); |
1049 } | 1049 } |
1050 | 1050 |
1051 | 1051 |
1052 // TODO(dcarney): Remove this abstraction when old callbacks are removed. | 1052 Local<FunctionTemplate> FunctionTemplate::New( |
1053 class CallHandlerHelper { | 1053 FunctionCallback callback, |
1054 public: | |
1055 static inline void Set(Local<FunctionTemplate> function_template, | |
1056 InvocationCallback callback, | |
1057 v8::Handle<Value> data) { | |
1058 function_template->SetCallHandlerInternal(callback, data); | |
1059 } | |
1060 static inline void Set(Local<FunctionTemplate> function_template, | |
1061 FunctionCallback callback, | |
1062 v8::Handle<Value> data) { | |
1063 function_template->SetCallHandler(callback, data); | |
1064 } | |
1065 }; | |
1066 | |
1067 | |
1068 template<typename Callback> | |
1069 static Local<FunctionTemplate> FunctionTemplateNew( | |
1070 Callback callback, | |
1071 v8::Handle<Value> data, | 1054 v8::Handle<Value> data, |
1072 v8::Handle<Signature> signature, | 1055 v8::Handle<Signature> signature, |
1073 int length) { | 1056 int length) { |
1074 i::Isolate* isolate = i::Isolate::Current(); | 1057 i::Isolate* isolate = i::Isolate::Current(); |
1075 EnsureInitializedForIsolate(isolate, "v8::FunctionTemplate::New()"); | 1058 EnsureInitializedForIsolate(isolate, "v8::FunctionTemplate::New()"); |
1076 LOG_API(isolate, "FunctionTemplate::New"); | 1059 LOG_API(isolate, "FunctionTemplate::New"); |
1077 ENTER_V8(isolate); | 1060 ENTER_V8(isolate); |
1078 i::Handle<i::Struct> struct_obj = | 1061 i::Handle<i::Struct> struct_obj = |
1079 isolate->factory()->NewStruct(i::FUNCTION_TEMPLATE_INFO_TYPE); | 1062 isolate->factory()->NewStruct(i::FUNCTION_TEMPLATE_INFO_TYPE); |
1080 i::Handle<i::FunctionTemplateInfo> obj = | 1063 i::Handle<i::FunctionTemplateInfo> obj = |
1081 i::Handle<i::FunctionTemplateInfo>::cast(struct_obj); | 1064 i::Handle<i::FunctionTemplateInfo>::cast(struct_obj); |
1082 InitializeFunctionTemplate(obj); | 1065 InitializeFunctionTemplate(obj); |
1083 int next_serial_number = isolate->next_serial_number(); | 1066 int next_serial_number = isolate->next_serial_number(); |
1084 isolate->set_next_serial_number(next_serial_number + 1); | 1067 isolate->set_next_serial_number(next_serial_number + 1); |
1085 obj->set_serial_number(i::Smi::FromInt(next_serial_number)); | 1068 obj->set_serial_number(i::Smi::FromInt(next_serial_number)); |
1086 if (callback != 0) { | 1069 if (callback != 0) { |
1087 if (data.IsEmpty()) data = v8::Undefined(); | 1070 if (data.IsEmpty()) data = v8::Undefined(); |
1088 CallHandlerHelper::Set(Utils::ToLocal(obj), callback, data); | 1071 Utils::ToLocal(obj)->SetCallHandler(callback, data); |
1089 } | 1072 } |
1090 obj->set_length(length); | 1073 obj->set_length(length); |
1091 obj->set_undetectable(false); | 1074 obj->set_undetectable(false); |
1092 obj->set_needs_access_check(false); | 1075 obj->set_needs_access_check(false); |
1093 | 1076 |
1094 if (!signature.IsEmpty()) | 1077 if (!signature.IsEmpty()) |
1095 obj->set_signature(*Utils::OpenHandle(*signature)); | 1078 obj->set_signature(*Utils::OpenHandle(*signature)); |
1096 return Utils::ToLocal(obj); | 1079 return Utils::ToLocal(obj); |
1097 } | 1080 } |
1098 | 1081 |
1099 | 1082 |
1100 Local<FunctionTemplate> FunctionTemplate::New( | |
1101 InvocationCallback callback, | |
1102 v8::Handle<Value> data, | |
1103 v8::Handle<Signature> signature, | |
1104 int length) { | |
1105 return FunctionTemplateNew(callback, data, signature, length); | |
1106 } | |
1107 | |
1108 | |
1109 Local<FunctionTemplate> FunctionTemplate::New( | |
1110 FunctionCallback callback, | |
1111 v8::Handle<Value> data, | |
1112 v8::Handle<Signature> signature, | |
1113 int length) { | |
1114 return FunctionTemplateNew(callback, data, signature, length); | |
1115 } | |
1116 | |
1117 | |
1118 Local<Signature> Signature::New(Handle<FunctionTemplate> receiver, | 1083 Local<Signature> Signature::New(Handle<FunctionTemplate> receiver, |
1119 int argc, Handle<FunctionTemplate> argv[]) { | 1084 int argc, Handle<FunctionTemplate> argv[]) { |
1120 i::Isolate* isolate = i::Isolate::Current(); | 1085 i::Isolate* isolate = i::Isolate::Current(); |
1121 EnsureInitializedForIsolate(isolate, "v8::Signature::New()"); | 1086 EnsureInitializedForIsolate(isolate, "v8::Signature::New()"); |
1122 LOG_API(isolate, "Signature::New"); | 1087 LOG_API(isolate, "Signature::New"); |
1123 ENTER_V8(isolate); | 1088 ENTER_V8(isolate); |
1124 i::Handle<i::Struct> struct_obj = | 1089 i::Handle<i::Struct> struct_obj = |
1125 isolate->factory()->NewStruct(i::SIGNATURE_INFO_TYPE); | 1090 isolate->factory()->NewStruct(i::SIGNATURE_INFO_TYPE); |
1126 i::Handle<i::SignatureInfo> obj = | 1091 i::Handle<i::SignatureInfo> obj = |
1127 i::Handle<i::SignatureInfo>::cast(struct_obj); | 1092 i::Handle<i::SignatureInfo>::cast(struct_obj); |
(...skipping 169 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1297 return 0; | 1262 return 0; |
1298 } | 1263 } |
1299 | 1264 |
1300 | 1265 |
1301 #define SET_FIELD_WRAPPED(obj, setter, cdata) do { \ | 1266 #define SET_FIELD_WRAPPED(obj, setter, cdata) do { \ |
1302 i::Handle<i::Object> foreign = FromCData(cdata); \ | 1267 i::Handle<i::Object> foreign = FromCData(cdata); \ |
1303 (obj)->setter(*foreign); \ | 1268 (obj)->setter(*foreign); \ |
1304 } while (false) | 1269 } while (false) |
1305 | 1270 |
1306 | 1271 |
1307 template<typename Callback> | 1272 void FunctionTemplate::SetCallHandler(FunctionCallback callback, |
1308 static void FunctionTemplateSetCallHandler(FunctionTemplate* function_template, | 1273 v8::Handle<Value> data) { |
1309 Callback callback_in, | 1274 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); |
1310 v8::Handle<Value> data) { | |
1311 i::Isolate* isolate = Utils::OpenHandle(function_template)->GetIsolate(); | |
1312 if (IsDeadCheck(isolate, "v8::FunctionTemplate::SetCallHandler()")) return; | 1275 if (IsDeadCheck(isolate, "v8::FunctionTemplate::SetCallHandler()")) return; |
1313 ENTER_V8(isolate); | 1276 ENTER_V8(isolate); |
1314 i::HandleScope scope(isolate); | 1277 i::HandleScope scope(isolate); |
1315 i::Handle<i::Struct> struct_obj = | 1278 i::Handle<i::Struct> struct_obj = |
1316 isolate->factory()->NewStruct(i::CALL_HANDLER_INFO_TYPE); | 1279 isolate->factory()->NewStruct(i::CALL_HANDLER_INFO_TYPE); |
1317 i::Handle<i::CallHandlerInfo> obj = | 1280 i::Handle<i::CallHandlerInfo> obj = |
1318 i::Handle<i::CallHandlerInfo>::cast(struct_obj); | 1281 i::Handle<i::CallHandlerInfo>::cast(struct_obj); |
1319 FunctionCallback callback = | |
1320 i::CallbackTable::Register(isolate, callback_in); | |
1321 SET_FIELD_WRAPPED(obj, set_callback, callback); | 1282 SET_FIELD_WRAPPED(obj, set_callback, callback); |
1322 if (data.IsEmpty()) data = v8::Undefined(); | 1283 if (data.IsEmpty()) data = v8::Undefined(); |
1323 obj->set_data(*Utils::OpenHandle(*data)); | 1284 obj->set_data(*Utils::OpenHandle(*data)); |
1324 Utils::OpenHandle(function_template)->set_call_code(*obj); | 1285 Utils::OpenHandle(this)->set_call_code(*obj); |
1325 } | 1286 } |
1326 | 1287 |
1327 void FunctionTemplate::SetCallHandler(InvocationCallback callback, | |
1328 v8::Handle<Value> data) { | |
1329 FunctionTemplateSetCallHandler(this, callback, data); | |
1330 } | |
1331 | |
1332 void FunctionTemplate::SetCallHandlerInternal(InvocationCallback callback, | |
1333 v8::Handle<Value> data) { | |
1334 FunctionTemplateSetCallHandler(this, callback, data); | |
1335 } | |
1336 | |
1337 void FunctionTemplate::SetCallHandler(FunctionCallback callback, | |
1338 v8::Handle<Value> data) { | |
1339 FunctionTemplateSetCallHandler(this, callback, data); | |
1340 } | |
1341 | 1288 |
1342 static i::Handle<i::AccessorInfo> SetAccessorInfoProperties( | 1289 static i::Handle<i::AccessorInfo> SetAccessorInfoProperties( |
1343 i::Handle<i::AccessorInfo> obj, | 1290 i::Handle<i::AccessorInfo> obj, |
1344 v8::Handle<String> name, | 1291 v8::Handle<String> name, |
1345 v8::AccessControl settings, | 1292 v8::AccessControl settings, |
1346 v8::PropertyAttribute attributes, | 1293 v8::PropertyAttribute attributes, |
1347 v8::Handle<AccessorSignature> signature) { | 1294 v8::Handle<AccessorSignature> signature) { |
1348 obj->set_name(*Utils::OpenHandle(*name)); | 1295 obj->set_name(*Utils::OpenHandle(*name)); |
1349 if (settings & ALL_CAN_READ) obj->set_all_can_read(true); | 1296 if (settings & ALL_CAN_READ) obj->set_all_can_read(true); |
1350 if (settings & ALL_CAN_WRITE) obj->set_all_can_write(true); | 1297 if (settings & ALL_CAN_WRITE) obj->set_all_can_write(true); |
1351 if (settings & PROHIBITS_OVERWRITING) obj->set_prohibits_overwriting(true); | 1298 if (settings & PROHIBITS_OVERWRITING) obj->set_prohibits_overwriting(true); |
1352 obj->set_property_attributes(static_cast<PropertyAttributes>(attributes)); | 1299 obj->set_property_attributes(static_cast<PropertyAttributes>(attributes)); |
1353 if (!signature.IsEmpty()) { | 1300 if (!signature.IsEmpty()) { |
1354 obj->set_expected_receiver_type(*Utils::OpenHandle(*signature)); | 1301 obj->set_expected_receiver_type(*Utils::OpenHandle(*signature)); |
1355 } | 1302 } |
1356 return obj; | 1303 return obj; |
1357 } | 1304 } |
1358 | 1305 |
1359 | 1306 |
1360 template<typename Getter, typename Setter> | 1307 template<typename Getter, typename Setter> |
1361 static i::Handle<i::AccessorInfo> MakeAccessorInfo( | 1308 static i::Handle<i::AccessorInfo> MakeAccessorInfo( |
1362 v8::Handle<String> name, | 1309 v8::Handle<String> name, |
1363 Getter getter_in, | 1310 Getter getter, |
1364 Setter setter_in, | 1311 Setter setter, |
1365 v8::Handle<Value> data, | 1312 v8::Handle<Value> data, |
1366 v8::AccessControl settings, | 1313 v8::AccessControl settings, |
1367 v8::PropertyAttribute attributes, | 1314 v8::PropertyAttribute attributes, |
1368 v8::Handle<AccessorSignature> signature) { | 1315 v8::Handle<AccessorSignature> signature) { |
1369 i::Isolate* isolate = Utils::OpenHandle(*name)->GetIsolate(); | 1316 i::Isolate* isolate = Utils::OpenHandle(*name)->GetIsolate(); |
1370 i::Handle<i::ExecutableAccessorInfo> obj = | 1317 i::Handle<i::ExecutableAccessorInfo> obj = |
1371 isolate->factory()->NewExecutableAccessorInfo(); | 1318 isolate->factory()->NewExecutableAccessorInfo(); |
1372 AccessorGetterCallback getter = | |
1373 i::CallbackTable::Register(isolate, getter_in); | |
1374 SET_FIELD_WRAPPED(obj, set_getter, getter); | 1319 SET_FIELD_WRAPPED(obj, set_getter, getter); |
1375 AccessorSetterCallback setter = | |
1376 i::CallbackTable::Register(isolate, setter_in); | |
1377 SET_FIELD_WRAPPED(obj, set_setter, setter); | 1320 SET_FIELD_WRAPPED(obj, set_setter, setter); |
1378 if (data.IsEmpty()) data = v8::Undefined(); | 1321 if (data.IsEmpty()) data = v8::Undefined(); |
1379 obj->set_data(*Utils::OpenHandle(*data)); | 1322 obj->set_data(*Utils::OpenHandle(*data)); |
1380 return SetAccessorInfoProperties(obj, name, settings, attributes, signature); | 1323 return SetAccessorInfoProperties(obj, name, settings, attributes, signature); |
1381 } | 1324 } |
1382 | 1325 |
1383 | 1326 |
1384 static i::Handle<i::AccessorInfo> MakeAccessorInfo( | 1327 static i::Handle<i::AccessorInfo> MakeAccessorInfo( |
1385 v8::Handle<String> name, | 1328 v8::Handle<String> name, |
1386 v8::Handle<v8::DeclaredAccessorDescriptor> descriptor, | 1329 v8::Handle<v8::DeclaredAccessorDescriptor> descriptor, |
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1455 void FunctionTemplate::RemovePrototype() { | 1398 void FunctionTemplate::RemovePrototype() { |
1456 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); | 1399 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); |
1457 if (IsDeadCheck(isolate, "v8::FunctionTemplate::RemovePrototype()")) { | 1400 if (IsDeadCheck(isolate, "v8::FunctionTemplate::RemovePrototype()")) { |
1458 return; | 1401 return; |
1459 } | 1402 } |
1460 ENTER_V8(isolate); | 1403 ENTER_V8(isolate); |
1461 Utils::OpenHandle(this)->set_remove_prototype(true); | 1404 Utils::OpenHandle(this)->set_remove_prototype(true); |
1462 } | 1405 } |
1463 | 1406 |
1464 | 1407 |
1465 template< | |
1466 typename Getter, | |
1467 typename Setter, | |
1468 typename Query, | |
1469 typename Deleter, | |
1470 typename Enumerator> | |
1471 static void SetNamedInstancePropertyHandler( | |
1472 i::Handle<i::FunctionTemplateInfo> function_template, | |
1473 Getter getter_in, | |
1474 Setter setter_in, | |
1475 Query query_in, | |
1476 Deleter remover_in, | |
1477 Enumerator enumerator_in, | |
1478 Handle<Value> data) { | |
1479 i::Isolate* isolate = function_template->GetIsolate(); | |
1480 if (IsDeadCheck(isolate, | |
1481 "v8::FunctionTemplate::SetNamedInstancePropertyHandler()")) { | |
1482 return; | |
1483 } | |
1484 ENTER_V8(isolate); | |
1485 i::HandleScope scope(isolate); | |
1486 i::Handle<i::Struct> struct_obj = | |
1487 isolate->factory()->NewStruct(i::INTERCEPTOR_INFO_TYPE); | |
1488 i::Handle<i::InterceptorInfo> obj = | |
1489 i::Handle<i::InterceptorInfo>::cast(struct_obj); | |
1490 | |
1491 NamedPropertyGetterCallback getter = | |
1492 i::CallbackTable::Register(isolate, getter_in); | |
1493 if (getter != 0) SET_FIELD_WRAPPED(obj, set_getter, getter); | |
1494 NamedPropertySetterCallback setter = | |
1495 i::CallbackTable::Register(isolate, setter_in); | |
1496 if (setter != 0) SET_FIELD_WRAPPED(obj, set_setter, setter); | |
1497 NamedPropertyQueryCallback query = | |
1498 i::CallbackTable::Register(isolate, query_in); | |
1499 if (query != 0) SET_FIELD_WRAPPED(obj, set_query, query); | |
1500 NamedPropertyDeleterCallback remover = | |
1501 i::CallbackTable::Register(isolate, remover_in); | |
1502 if (remover != 0) SET_FIELD_WRAPPED(obj, set_deleter, remover); | |
1503 NamedPropertyEnumeratorCallback enumerator = | |
1504 i::CallbackTable::Register(isolate, enumerator_in); | |
1505 if (enumerator != 0) SET_FIELD_WRAPPED(obj, set_enumerator, enumerator); | |
1506 | |
1507 if (data.IsEmpty()) data = v8::Undefined(); | |
1508 obj->set_data(*Utils::OpenHandle(*data)); | |
1509 function_template->set_named_property_handler(*obj); | |
1510 } | |
1511 | |
1512 | |
1513 template< | |
1514 typename Getter, | |
1515 typename Setter, | |
1516 typename Query, | |
1517 typename Deleter, | |
1518 typename Enumerator> | |
1519 static void SetIndexedInstancePropertyHandler( | |
1520 i::Handle<i::FunctionTemplateInfo> function_template, | |
1521 Getter getter_in, | |
1522 Setter setter_in, | |
1523 Query query_in, | |
1524 Deleter remover_in, | |
1525 Enumerator enumerator_in, | |
1526 Handle<Value> data) { | |
1527 i::Isolate* isolate = function_template->GetIsolate(); | |
1528 if (IsDeadCheck(isolate, | |
1529 "v8::FunctionTemplate::SetIndexedInstancePropertyHandler()")) { | |
1530 return; | |
1531 } | |
1532 ENTER_V8(isolate); | |
1533 i::HandleScope scope(isolate); | |
1534 i::Handle<i::Struct> struct_obj = | |
1535 isolate->factory()->NewStruct(i::INTERCEPTOR_INFO_TYPE); | |
1536 i::Handle<i::InterceptorInfo> obj = | |
1537 i::Handle<i::InterceptorInfo>::cast(struct_obj); | |
1538 | |
1539 IndexedPropertyGetterCallback getter = | |
1540 i::CallbackTable::Register(isolate, getter_in); | |
1541 if (getter != 0) SET_FIELD_WRAPPED(obj, set_getter, getter); | |
1542 IndexedPropertySetterCallback setter = | |
1543 i::CallbackTable::Register(isolate, setter_in); | |
1544 if (setter != 0) SET_FIELD_WRAPPED(obj, set_setter, setter); | |
1545 IndexedPropertyQueryCallback query = | |
1546 i::CallbackTable::Register(isolate, query_in); | |
1547 if (query != 0) SET_FIELD_WRAPPED(obj, set_query, query); | |
1548 IndexedPropertyDeleterCallback remover = | |
1549 i::CallbackTable::Register(isolate, remover_in); | |
1550 if (remover != 0) SET_FIELD_WRAPPED(obj, set_deleter, remover); | |
1551 IndexedPropertyEnumeratorCallback enumerator = | |
1552 i::CallbackTable::Register(isolate, enumerator_in); | |
1553 if (enumerator != 0) SET_FIELD_WRAPPED(obj, set_enumerator, enumerator); | |
1554 | |
1555 if (data.IsEmpty()) data = v8::Undefined(); | |
1556 obj->set_data(*Utils::OpenHandle(*data)); | |
1557 function_template->set_indexed_property_handler(*obj); | |
1558 } | |
1559 | |
1560 | |
1561 template<typename Callback> | |
1562 static void SetInstanceCallAsFunctionHandler( | |
1563 i::Handle<i::FunctionTemplateInfo> function_template, | |
1564 Callback callback_in, | |
1565 Handle<Value> data) { | |
1566 i::Isolate* isolate = function_template->GetIsolate(); | |
1567 if (IsDeadCheck(isolate, | |
1568 "v8::FunctionTemplate::SetInstanceCallAsFunctionHandler()")) { | |
1569 return; | |
1570 } | |
1571 ENTER_V8(isolate); | |
1572 i::HandleScope scope(isolate); | |
1573 i::Handle<i::Struct> struct_obj = | |
1574 isolate->factory()->NewStruct(i::CALL_HANDLER_INFO_TYPE); | |
1575 i::Handle<i::CallHandlerInfo> obj = | |
1576 i::Handle<i::CallHandlerInfo>::cast(struct_obj); | |
1577 FunctionCallback callback = | |
1578 i::CallbackTable::Register(isolate, callback_in); | |
1579 SET_FIELD_WRAPPED(obj, set_callback, callback); | |
1580 if (data.IsEmpty()) data = v8::Undefined(); | |
1581 obj->set_data(*Utils::OpenHandle(*data)); | |
1582 function_template->set_instance_call_handler(*obj); | |
1583 } | |
1584 | |
1585 | |
1586 // --- O b j e c t T e m p l a t e --- | 1408 // --- O b j e c t T e m p l a t e --- |
1587 | 1409 |
1588 | 1410 |
1589 Local<ObjectTemplate> ObjectTemplate::New() { | 1411 Local<ObjectTemplate> ObjectTemplate::New() { |
1590 return New(Local<FunctionTemplate>()); | 1412 return New(Local<FunctionTemplate>()); |
1591 } | 1413 } |
1592 | 1414 |
1593 | 1415 |
1594 Local<ObjectTemplate> ObjectTemplate::New( | 1416 Local<ObjectTemplate> ObjectTemplate::New( |
1595 v8::Handle<FunctionTemplate> constructor) { | 1417 v8::Handle<FunctionTemplate> constructor) { |
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1657 i::Handle<i::FunctionTemplateInfo> cons(constructor); | 1479 i::Handle<i::FunctionTemplateInfo> cons(constructor); |
1658 i::Handle<i::AccessorInfo> obj = MakeAccessorInfo( | 1480 i::Handle<i::AccessorInfo> obj = MakeAccessorInfo( |
1659 name, getter, setter, data, settings, attribute, signature); | 1481 name, getter, setter, data, settings, attribute, signature); |
1660 if (obj.is_null()) return false; | 1482 if (obj.is_null()) return false; |
1661 AddPropertyToFunctionTemplate(cons, obj); | 1483 AddPropertyToFunctionTemplate(cons, obj); |
1662 return true; | 1484 return true; |
1663 } | 1485 } |
1664 | 1486 |
1665 | 1487 |
1666 void ObjectTemplate::SetAccessor(v8::Handle<String> name, | 1488 void ObjectTemplate::SetAccessor(v8::Handle<String> name, |
1667 AccessorGetter getter, | |
1668 AccessorSetter setter, | |
1669 v8::Handle<Value> data, | |
1670 AccessControl settings, | |
1671 PropertyAttribute attribute, | |
1672 v8::Handle<AccessorSignature> signature) { | |
1673 ObjectTemplateSetAccessor( | |
1674 this, name, getter, setter, data, settings, attribute, signature); | |
1675 } | |
1676 | |
1677 | |
1678 void ObjectTemplate::SetAccessor(v8::Handle<String> name, | |
1679 AccessorGetterCallback getter, | 1489 AccessorGetterCallback getter, |
1680 AccessorSetterCallback setter, | 1490 AccessorSetterCallback setter, |
1681 v8::Handle<Value> data, | 1491 v8::Handle<Value> data, |
1682 AccessControl settings, | 1492 AccessControl settings, |
1683 PropertyAttribute attribute, | 1493 PropertyAttribute attribute, |
1684 v8::Handle<AccessorSignature> signature) { | 1494 v8::Handle<AccessorSignature> signature) { |
1685 ObjectTemplateSetAccessor( | 1495 ObjectTemplateSetAccessor( |
1686 this, name, getter, setter, data, settings, attribute, signature); | 1496 this, name, getter, setter, data, settings, attribute, signature); |
1687 } | 1497 } |
1688 | 1498 |
1689 | 1499 |
1690 bool ObjectTemplate::SetAccessor(Handle<String> name, | 1500 bool ObjectTemplate::SetAccessor(Handle<String> name, |
1691 Handle<DeclaredAccessorDescriptor> descriptor, | 1501 Handle<DeclaredAccessorDescriptor> descriptor, |
1692 AccessControl settings, | 1502 AccessControl settings, |
1693 PropertyAttribute attribute, | 1503 PropertyAttribute attribute, |
1694 Handle<AccessorSignature> signature) { | 1504 Handle<AccessorSignature> signature) { |
1695 void* null = NULL; | 1505 void* null = NULL; |
1696 return ObjectTemplateSetAccessor( | 1506 return ObjectTemplateSetAccessor( |
1697 this, name, descriptor, null, null, settings, attribute, signature); | 1507 this, name, descriptor, null, null, settings, attribute, signature); |
1698 } | 1508 } |
1699 | 1509 |
1700 | 1510 |
1701 template< | |
1702 typename Getter, | |
1703 typename Setter, | |
1704 typename Query, | |
1705 typename Deleter, | |
1706 typename Enumerator> | |
1707 static void ObjectTemplateSetNamedPropertyHandler( | |
1708 ObjectTemplate* object_template, | |
1709 Getter getter, | |
1710 Setter setter, | |
1711 Query query, | |
1712 Deleter remover, | |
1713 Enumerator enumerator, | |
1714 Handle<Value> data) { | |
1715 i::Isolate* isolate = Utils::OpenHandle(object_template)->GetIsolate(); | |
1716 if (IsDeadCheck(isolate, "v8::ObjectTemplate::SetNamedPropertyHandler()")) { | |
1717 return; | |
1718 } | |
1719 ENTER_V8(isolate); | |
1720 i::HandleScope scope(isolate); | |
1721 EnsureConstructor(object_template); | |
1722 i::FunctionTemplateInfo* constructor = i::FunctionTemplateInfo::cast( | |
1723 Utils::OpenHandle(object_template)->constructor()); | |
1724 i::Handle<i::FunctionTemplateInfo> cons(constructor); | |
1725 SetNamedInstancePropertyHandler(cons, | |
1726 getter, | |
1727 setter, | |
1728 query, | |
1729 remover, | |
1730 enumerator, | |
1731 data); | |
1732 } | |
1733 | |
1734 | |
1735 void ObjectTemplate::SetNamedPropertyHandler( | |
1736 NamedPropertyGetter getter, | |
1737 NamedPropertySetter setter, | |
1738 NamedPropertyQuery query, | |
1739 NamedPropertyDeleter remover, | |
1740 NamedPropertyEnumerator enumerator, | |
1741 Handle<Value> data) { | |
1742 ObjectTemplateSetNamedPropertyHandler( | |
1743 this, getter, setter, query, remover, enumerator, data); | |
1744 } | |
1745 | |
1746 | |
1747 void ObjectTemplate::SetNamedPropertyHandler( | 1511 void ObjectTemplate::SetNamedPropertyHandler( |
1748 NamedPropertyGetterCallback getter, | 1512 NamedPropertyGetterCallback getter, |
1749 NamedPropertySetterCallback setter, | 1513 NamedPropertySetterCallback setter, |
1750 NamedPropertyQueryCallback query, | 1514 NamedPropertyQueryCallback query, |
1751 NamedPropertyDeleterCallback remover, | 1515 NamedPropertyDeleterCallback remover, |
1752 NamedPropertyEnumeratorCallback enumerator, | 1516 NamedPropertyEnumeratorCallback enumerator, |
1753 Handle<Value> data) { | 1517 Handle<Value> data) { |
1754 ObjectTemplateSetNamedPropertyHandler( | 1518 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); |
1755 this, getter, setter, query, remover, enumerator, data); | 1519 if (IsDeadCheck(isolate, "v8::ObjectTemplate::SetNamedPropertyHandler()")) { |
| 1520 return; |
| 1521 } |
| 1522 ENTER_V8(isolate); |
| 1523 i::HandleScope scope(isolate); |
| 1524 EnsureConstructor(this); |
| 1525 i::FunctionTemplateInfo* constructor = i::FunctionTemplateInfo::cast( |
| 1526 Utils::OpenHandle(this)->constructor()); |
| 1527 i::Handle<i::FunctionTemplateInfo> cons(constructor); |
| 1528 i::Handle<i::Struct> struct_obj = |
| 1529 isolate->factory()->NewStruct(i::INTERCEPTOR_INFO_TYPE); |
| 1530 i::Handle<i::InterceptorInfo> obj = |
| 1531 i::Handle<i::InterceptorInfo>::cast(struct_obj); |
| 1532 |
| 1533 if (getter != 0) SET_FIELD_WRAPPED(obj, set_getter, getter); |
| 1534 if (setter != 0) SET_FIELD_WRAPPED(obj, set_setter, setter); |
| 1535 if (query != 0) SET_FIELD_WRAPPED(obj, set_query, query); |
| 1536 if (remover != 0) SET_FIELD_WRAPPED(obj, set_deleter, remover); |
| 1537 if (enumerator != 0) SET_FIELD_WRAPPED(obj, set_enumerator, enumerator); |
| 1538 |
| 1539 if (data.IsEmpty()) data = v8::Undefined(); |
| 1540 obj->set_data(*Utils::OpenHandle(*data)); |
| 1541 cons->set_named_property_handler(*obj); |
1756 } | 1542 } |
1757 | 1543 |
1758 | 1544 |
1759 void ObjectTemplate::MarkAsUndetectable() { | 1545 void ObjectTemplate::MarkAsUndetectable() { |
1760 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); | 1546 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); |
1761 if (IsDeadCheck(isolate, "v8::ObjectTemplate::MarkAsUndetectable()")) return; | 1547 if (IsDeadCheck(isolate, "v8::ObjectTemplate::MarkAsUndetectable()")) return; |
1762 ENTER_V8(isolate); | 1548 ENTER_V8(isolate); |
1763 i::HandleScope scope(isolate); | 1549 i::HandleScope scope(isolate); |
1764 EnsureConstructor(this); | 1550 EnsureConstructor(this); |
1765 i::FunctionTemplateInfo* constructor = | 1551 i::FunctionTemplateInfo* constructor = |
(...skipping 28 matching lines...) Expand all Loading... |
1794 info->set_data(*Utils::OpenHandle(*data)); | 1580 info->set_data(*Utils::OpenHandle(*data)); |
1795 | 1581 |
1796 i::FunctionTemplateInfo* constructor = | 1582 i::FunctionTemplateInfo* constructor = |
1797 i::FunctionTemplateInfo::cast(Utils::OpenHandle(this)->constructor()); | 1583 i::FunctionTemplateInfo::cast(Utils::OpenHandle(this)->constructor()); |
1798 i::Handle<i::FunctionTemplateInfo> cons(constructor); | 1584 i::Handle<i::FunctionTemplateInfo> cons(constructor); |
1799 cons->set_access_check_info(*info); | 1585 cons->set_access_check_info(*info); |
1800 cons->set_needs_access_check(turned_on_by_default); | 1586 cons->set_needs_access_check(turned_on_by_default); |
1801 } | 1587 } |
1802 | 1588 |
1803 | 1589 |
1804 template< | |
1805 typename Getter, | |
1806 typename Setter, | |
1807 typename Query, | |
1808 typename Deleter, | |
1809 typename Enumerator> | |
1810 void ObjectTemplateSetIndexedPropertyHandler( | |
1811 ObjectTemplate* object_template, | |
1812 Getter getter, | |
1813 Setter setter, | |
1814 Query query, | |
1815 Deleter remover, | |
1816 Enumerator enumerator, | |
1817 Handle<Value> data) { | |
1818 i::Isolate* isolate = Utils::OpenHandle(object_template)->GetIsolate(); | |
1819 if (IsDeadCheck(isolate, "v8::ObjectTemplate::SetIndexedPropertyHandler()")) { | |
1820 return; | |
1821 } | |
1822 ENTER_V8(isolate); | |
1823 i::HandleScope scope(isolate); | |
1824 EnsureConstructor(object_template); | |
1825 i::FunctionTemplateInfo* constructor = i::FunctionTemplateInfo::cast( | |
1826 Utils::OpenHandle(object_template)->constructor()); | |
1827 i::Handle<i::FunctionTemplateInfo> cons(constructor); | |
1828 SetIndexedInstancePropertyHandler(cons, | |
1829 getter, | |
1830 setter, | |
1831 query, | |
1832 remover, | |
1833 enumerator, | |
1834 data); | |
1835 } | |
1836 | |
1837 | |
1838 void ObjectTemplate::SetIndexedPropertyHandler( | |
1839 IndexedPropertyGetter getter, | |
1840 IndexedPropertySetter setter, | |
1841 IndexedPropertyQuery query, | |
1842 IndexedPropertyDeleter remover, | |
1843 IndexedPropertyEnumerator enumerator, | |
1844 Handle<Value> data) { | |
1845 ObjectTemplateSetIndexedPropertyHandler( | |
1846 this, getter, setter, query, remover, enumerator, data); | |
1847 } | |
1848 | |
1849 | |
1850 void ObjectTemplate::SetIndexedPropertyHandler( | 1590 void ObjectTemplate::SetIndexedPropertyHandler( |
1851 IndexedPropertyGetterCallback getter, | 1591 IndexedPropertyGetterCallback getter, |
1852 IndexedPropertySetterCallback setter, | 1592 IndexedPropertySetterCallback setter, |
1853 IndexedPropertyQueryCallback query, | 1593 IndexedPropertyQueryCallback query, |
1854 IndexedPropertyDeleterCallback remover, | 1594 IndexedPropertyDeleterCallback remover, |
1855 IndexedPropertyEnumeratorCallback enumerator, | 1595 IndexedPropertyEnumeratorCallback enumerator, |
1856 Handle<Value> data) { | 1596 Handle<Value> data) { |
1857 ObjectTemplateSetIndexedPropertyHandler( | 1597 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); |
1858 this, getter, setter, query, remover, enumerator, data); | 1598 if (IsDeadCheck(isolate, "v8::ObjectTemplate::SetIndexedPropertyHandler()")) { |
| 1599 return; |
| 1600 } |
| 1601 ENTER_V8(isolate); |
| 1602 i::HandleScope scope(isolate); |
| 1603 EnsureConstructor(this); |
| 1604 i::FunctionTemplateInfo* constructor = i::FunctionTemplateInfo::cast( |
| 1605 Utils::OpenHandle(this)->constructor()); |
| 1606 i::Handle<i::FunctionTemplateInfo> cons(constructor); |
| 1607 i::Handle<i::Struct> struct_obj = |
| 1608 isolate->factory()->NewStruct(i::INTERCEPTOR_INFO_TYPE); |
| 1609 i::Handle<i::InterceptorInfo> obj = |
| 1610 i::Handle<i::InterceptorInfo>::cast(struct_obj); |
| 1611 |
| 1612 if (getter != 0) SET_FIELD_WRAPPED(obj, set_getter, getter); |
| 1613 if (setter != 0) SET_FIELD_WRAPPED(obj, set_setter, setter); |
| 1614 if (query != 0) SET_FIELD_WRAPPED(obj, set_query, query); |
| 1615 if (remover != 0) SET_FIELD_WRAPPED(obj, set_deleter, remover); |
| 1616 if (enumerator != 0) SET_FIELD_WRAPPED(obj, set_enumerator, enumerator); |
| 1617 |
| 1618 if (data.IsEmpty()) data = v8::Undefined(); |
| 1619 obj->set_data(*Utils::OpenHandle(*data)); |
| 1620 cons->set_indexed_property_handler(*obj); |
1859 } | 1621 } |
1860 | 1622 |
1861 | 1623 |
1862 template<typename Callback> | 1624 void ObjectTemplate::SetCallAsFunctionHandler(FunctionCallback callback, |
1863 static void ObjectTemplateSetCallAsFunctionHandler( | 1625 Handle<Value> data) { |
1864 ObjectTemplate* object_template, | 1626 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); |
1865 Callback callback, | |
1866 Handle<Value> data) { | |
1867 i::Isolate* isolate = Utils::OpenHandle(object_template)->GetIsolate(); | |
1868 if (IsDeadCheck(isolate, | 1627 if (IsDeadCheck(isolate, |
1869 "v8::ObjectTemplate::SetCallAsFunctionHandler()")) { | 1628 "v8::ObjectTemplate::SetCallAsFunctionHandler()")) { |
1870 return; | 1629 return; |
1871 } | 1630 } |
1872 ENTER_V8(isolate); | 1631 ENTER_V8(isolate); |
1873 i::HandleScope scope(isolate); | 1632 i::HandleScope scope(isolate); |
1874 EnsureConstructor(object_template); | 1633 EnsureConstructor(this); |
1875 i::FunctionTemplateInfo* constructor = i::FunctionTemplateInfo::cast( | 1634 i::FunctionTemplateInfo* constructor = i::FunctionTemplateInfo::cast( |
1876 Utils::OpenHandle(object_template)->constructor()); | 1635 Utils::OpenHandle(this)->constructor()); |
1877 i::Handle<i::FunctionTemplateInfo> cons(constructor); | 1636 i::Handle<i::FunctionTemplateInfo> cons(constructor); |
1878 SetInstanceCallAsFunctionHandler(cons, callback, data); | 1637 i::Handle<i::Struct> struct_obj = |
| 1638 isolate->factory()->NewStruct(i::CALL_HANDLER_INFO_TYPE); |
| 1639 i::Handle<i::CallHandlerInfo> obj = |
| 1640 i::Handle<i::CallHandlerInfo>::cast(struct_obj); |
| 1641 SET_FIELD_WRAPPED(obj, set_callback, callback); |
| 1642 if (data.IsEmpty()) data = v8::Undefined(); |
| 1643 obj->set_data(*Utils::OpenHandle(*data)); |
| 1644 cons->set_instance_call_handler(*obj); |
1879 } | 1645 } |
1880 | 1646 |
1881 | 1647 |
1882 void ObjectTemplate::SetCallAsFunctionHandler(InvocationCallback callback, | |
1883 Handle<Value> data) { | |
1884 return ObjectTemplateSetCallAsFunctionHandler(this, callback, data); | |
1885 } | |
1886 | |
1887 | |
1888 void ObjectTemplate::SetCallAsFunctionHandler(FunctionCallback callback, | |
1889 Handle<Value> data) { | |
1890 return ObjectTemplateSetCallAsFunctionHandler(this, callback, data); | |
1891 } | |
1892 | |
1893 | |
1894 int ObjectTemplate::InternalFieldCount() { | 1648 int ObjectTemplate::InternalFieldCount() { |
1895 if (IsDeadCheck(Utils::OpenHandle(this)->GetIsolate(), | 1649 if (IsDeadCheck(Utils::OpenHandle(this)->GetIsolate(), |
1896 "v8::ObjectTemplate::InternalFieldCount()")) { | 1650 "v8::ObjectTemplate::InternalFieldCount()")) { |
1897 return 0; | 1651 return 0; |
1898 } | 1652 } |
1899 return i::Smi::cast(Utils::OpenHandle(this)->internal_field_count())->value(); | 1653 return i::Smi::cast(Utils::OpenHandle(this)->internal_field_count())->value(); |
1900 } | 1654 } |
1901 | 1655 |
1902 | 1656 |
1903 void ObjectTemplate::SetInternalFieldCount(int value) { | 1657 void ObjectTemplate::SetInternalFieldCount(int value) { |
(...skipping 1943 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3847 if (info.is_null()) return false; | 3601 if (info.is_null()) return false; |
3848 bool fast = Utils::OpenHandle(obj)->HasFastProperties(); | 3602 bool fast = Utils::OpenHandle(obj)->HasFastProperties(); |
3849 i::Handle<i::Object> result = i::SetAccessor(Utils::OpenHandle(obj), info); | 3603 i::Handle<i::Object> result = i::SetAccessor(Utils::OpenHandle(obj), info); |
3850 if (result.is_null() || result->IsUndefined()) return false; | 3604 if (result.is_null() || result->IsUndefined()) return false; |
3851 if (fast) i::JSObject::TransformToFastProperties(Utils::OpenHandle(obj), 0); | 3605 if (fast) i::JSObject::TransformToFastProperties(Utils::OpenHandle(obj), 0); |
3852 return true; | 3606 return true; |
3853 } | 3607 } |
3854 | 3608 |
3855 | 3609 |
3856 bool Object::SetAccessor(Handle<String> name, | 3610 bool Object::SetAccessor(Handle<String> name, |
3857 AccessorGetter getter, | |
3858 AccessorSetter setter, | |
3859 v8::Handle<Value> data, | |
3860 AccessControl settings, | |
3861 PropertyAttribute attributes) { | |
3862 return ObjectSetAccessor( | |
3863 this, name, getter, setter, data, settings, attributes); | |
3864 } | |
3865 | |
3866 | |
3867 bool Object::SetAccessor(Handle<String> name, | |
3868 AccessorGetterCallback getter, | 3611 AccessorGetterCallback getter, |
3869 AccessorSetterCallback setter, | 3612 AccessorSetterCallback setter, |
3870 v8::Handle<Value> data, | 3613 v8::Handle<Value> data, |
3871 AccessControl settings, | 3614 AccessControl settings, |
3872 PropertyAttribute attributes) { | 3615 PropertyAttribute attributes) { |
3873 return ObjectSetAccessor( | 3616 return ObjectSetAccessor( |
3874 this, name, getter, setter, data, settings, attributes); | 3617 this, name, getter, setter, data, settings, attributes); |
3875 } | 3618 } |
3876 | 3619 |
3877 | 3620 |
(...skipping 4298 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
8176 (first_block_limit_ <= &(blocks_.first())[kHandleBlockSize])); | 7919 (first_block_limit_ <= &(blocks_.first())[kHandleBlockSize])); |
8177 | 7920 |
8178 v->VisitPointers(blocks_.first(), first_block_limit_); | 7921 v->VisitPointers(blocks_.first(), first_block_limit_); |
8179 | 7922 |
8180 for (int i = 1; i < blocks_.length(); i++) { | 7923 for (int i = 1; i < blocks_.length(); i++) { |
8181 v->VisitPointers(blocks_[i], &blocks_[i][kHandleBlockSize]); | 7924 v->VisitPointers(blocks_[i], &blocks_[i][kHandleBlockSize]); |
8182 } | 7925 } |
8183 } | 7926 } |
8184 | 7927 |
8185 | 7928 |
8186 v8::Handle<v8::Value> InvokeAccessorGetter( | |
8187 v8::Local<v8::String> property, | |
8188 const v8::AccessorInfo& info, | |
8189 v8::AccessorGetter getter) { | |
8190 Isolate* isolate = reinterpret_cast<Isolate*>(info.GetIsolate()); | |
8191 Address getter_address = reinterpret_cast<Address>(reinterpret_cast<intptr_t>( | |
8192 getter)); | |
8193 // Leaving JavaScript. | |
8194 VMState<EXTERNAL> state(isolate); | |
8195 ExternalCallbackScope call_scope(isolate, getter_address); | |
8196 return getter(property, info); | |
8197 } | |
8198 | |
8199 | |
8200 void InvokeAccessorGetterCallback( | 7929 void InvokeAccessorGetterCallback( |
8201 v8::Local<v8::String> property, | 7930 v8::Local<v8::String> property, |
8202 const v8::PropertyCallbackInfo<v8::Value>& info, | 7931 const v8::PropertyCallbackInfo<v8::Value>& info, |
8203 v8::AccessorGetterCallback getter) { | 7932 v8::AccessorGetterCallback getter) { |
8204 // Leaving JavaScript. | 7933 // Leaving JavaScript. |
8205 Isolate* isolate = reinterpret_cast<Isolate*>(info.GetIsolate()); | 7934 Isolate* isolate = reinterpret_cast<Isolate*>(info.GetIsolate()); |
8206 Address getter_address = reinterpret_cast<Address>(reinterpret_cast<intptr_t>( | 7935 Address getter_address = reinterpret_cast<Address>(reinterpret_cast<intptr_t>( |
8207 getter)); | 7936 getter)); |
8208 VMState<EXTERNAL> state(isolate); | 7937 VMState<EXTERNAL> state(isolate); |
8209 ExternalCallbackScope call_scope(isolate, getter_address); | 7938 ExternalCallbackScope call_scope(isolate, getter_address); |
8210 return getter(property, info); | 7939 return getter(property, info); |
8211 } | 7940 } |
8212 | 7941 |
8213 | 7942 |
8214 v8::Handle<v8::Value> InvokeInvocationCallback( | |
8215 const v8::Arguments& args, | |
8216 v8::InvocationCallback callback) { | |
8217 Isolate* isolate = reinterpret_cast<Isolate*>(args.GetIsolate()); | |
8218 Address callback_address = | |
8219 reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback)); | |
8220 VMState<EXTERNAL> state(isolate); | |
8221 ExternalCallbackScope call_scope(isolate, callback_address); | |
8222 return callback(args); | |
8223 } | |
8224 | |
8225 | |
8226 void InvokeFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info, | 7943 void InvokeFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info, |
8227 v8::FunctionCallback callback) { | 7944 v8::FunctionCallback callback) { |
8228 Isolate* isolate = reinterpret_cast<Isolate*>(info.GetIsolate()); | 7945 Isolate* isolate = reinterpret_cast<Isolate*>(info.GetIsolate()); |
8229 Address callback_address = | 7946 Address callback_address = |
8230 reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback)); | 7947 reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback)); |
8231 VMState<EXTERNAL> state(isolate); | 7948 VMState<EXTERNAL> state(isolate); |
8232 ExternalCallbackScope call_scope(isolate, callback_address); | 7949 ExternalCallbackScope call_scope(isolate, callback_address); |
8233 return callback(info); | 7950 return callback(info); |
8234 } | 7951 } |
8235 | 7952 |
8236 | 7953 |
8237 } } // namespace v8::internal | 7954 } } // namespace v8::internal |
OLD | NEW |