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 965 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
976 | 976 |
977 | 977 |
978 void FunctionTemplate::Inherit(v8::Handle<FunctionTemplate> value) { | 978 void FunctionTemplate::Inherit(v8::Handle<FunctionTemplate> value) { |
979 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); | 979 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); |
980 if (IsDeadCheck(isolate, "v8::FunctionTemplate::Inherit()")) return; | 980 if (IsDeadCheck(isolate, "v8::FunctionTemplate::Inherit()")) return; |
981 ENTER_V8(isolate); | 981 ENTER_V8(isolate); |
982 Utils::OpenHandle(this)->set_parent_template(*Utils::OpenHandle(*value)); | 982 Utils::OpenHandle(this)->set_parent_template(*Utils::OpenHandle(*value)); |
983 } | 983 } |
984 | 984 |
985 | 985 |
986 Local<FunctionTemplate> FunctionTemplate::New(InvocationCallback callback, | 986 template<typename Callback> |
987 v8::Handle<Value> data, v8::Handle<Signature> signature, int length) { | 987 static Local<FunctionTemplate> FunctionTemplateNew( |
| 988 Callback callback_in, |
| 989 v8::Handle<Value> data, |
| 990 v8::Handle<Signature> signature, |
| 991 int length) { |
988 i::Isolate* isolate = i::Isolate::Current(); | 992 i::Isolate* isolate = i::Isolate::Current(); |
989 EnsureInitializedForIsolate(isolate, "v8::FunctionTemplate::New()"); | 993 EnsureInitializedForIsolate(isolate, "v8::FunctionTemplate::New()"); |
990 LOG_API(isolate, "FunctionTemplate::New"); | 994 LOG_API(isolate, "FunctionTemplate::New"); |
991 ENTER_V8(isolate); | 995 ENTER_V8(isolate); |
992 i::Handle<i::Struct> struct_obj = | 996 i::Handle<i::Struct> struct_obj = |
993 isolate->factory()->NewStruct(i::FUNCTION_TEMPLATE_INFO_TYPE); | 997 isolate->factory()->NewStruct(i::FUNCTION_TEMPLATE_INFO_TYPE); |
994 i::Handle<i::FunctionTemplateInfo> obj = | 998 i::Handle<i::FunctionTemplateInfo> obj = |
995 i::Handle<i::FunctionTemplateInfo>::cast(struct_obj); | 999 i::Handle<i::FunctionTemplateInfo>::cast(struct_obj); |
996 InitializeFunctionTemplate(obj); | 1000 InitializeFunctionTemplate(obj); |
997 int next_serial_number = isolate->next_serial_number(); | 1001 int next_serial_number = isolate->next_serial_number(); |
998 isolate->set_next_serial_number(next_serial_number + 1); | 1002 isolate->set_next_serial_number(next_serial_number + 1); |
999 obj->set_serial_number(i::Smi::FromInt(next_serial_number)); | 1003 obj->set_serial_number(i::Smi::FromInt(next_serial_number)); |
1000 if (callback != 0) { | 1004 if (callback_in != 0) { |
1001 if (data.IsEmpty()) data = v8::Undefined(); | 1005 if (data.IsEmpty()) data = v8::Undefined(); |
| 1006 InvocationCallback callback = |
| 1007 i::CallbackTable::Register(isolate, callback_in); |
1002 Utils::ToLocal(obj)->SetCallHandler(callback, data); | 1008 Utils::ToLocal(obj)->SetCallHandler(callback, data); |
1003 } | 1009 } |
1004 obj->set_length(length); | 1010 obj->set_length(length); |
1005 obj->set_undetectable(false); | 1011 obj->set_undetectable(false); |
1006 obj->set_needs_access_check(false); | 1012 obj->set_needs_access_check(false); |
1007 | 1013 |
1008 if (!signature.IsEmpty()) | 1014 if (!signature.IsEmpty()) |
1009 obj->set_signature(*Utils::OpenHandle(*signature)); | 1015 obj->set_signature(*Utils::OpenHandle(*signature)); |
1010 return Utils::ToLocal(obj); | 1016 return Utils::ToLocal(obj); |
1011 } | 1017 } |
1012 | 1018 |
1013 | 1019 |
| 1020 Local<FunctionTemplate> FunctionTemplate::New( |
| 1021 InvocationCallback callback, |
| 1022 v8::Handle<Value> data, |
| 1023 v8::Handle<Signature> signature, |
| 1024 int length) { |
| 1025 return FunctionTemplateNew(callback, data, signature, length); |
| 1026 } |
| 1027 |
| 1028 |
| 1029 Local<FunctionTemplate> FunctionTemplate::New( |
| 1030 FunctionCallback callback, |
| 1031 v8::Handle<Value> data, |
| 1032 v8::Handle<Signature> signature, |
| 1033 int length) { |
| 1034 return FunctionTemplateNew(callback, data, signature, length); |
| 1035 } |
| 1036 |
| 1037 |
1014 Local<Signature> Signature::New(Handle<FunctionTemplate> receiver, | 1038 Local<Signature> Signature::New(Handle<FunctionTemplate> receiver, |
1015 int argc, Handle<FunctionTemplate> argv[]) { | 1039 int argc, Handle<FunctionTemplate> argv[]) { |
1016 i::Isolate* isolate = i::Isolate::Current(); | 1040 i::Isolate* isolate = i::Isolate::Current(); |
1017 EnsureInitializedForIsolate(isolate, "v8::Signature::New()"); | 1041 EnsureInitializedForIsolate(isolate, "v8::Signature::New()"); |
1018 LOG_API(isolate, "Signature::New"); | 1042 LOG_API(isolate, "Signature::New"); |
1019 ENTER_V8(isolate); | 1043 ENTER_V8(isolate); |
1020 i::Handle<i::Struct> struct_obj = | 1044 i::Handle<i::Struct> struct_obj = |
1021 isolate->factory()->NewStruct(i::SIGNATURE_INFO_TYPE); | 1045 isolate->factory()->NewStruct(i::SIGNATURE_INFO_TYPE); |
1022 i::Handle<i::SignatureInfo> obj = | 1046 i::Handle<i::SignatureInfo> obj = |
1023 i::Handle<i::SignatureInfo>::cast(struct_obj); | 1047 i::Handle<i::SignatureInfo>::cast(struct_obj); |
(...skipping 171 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1195 return 0; | 1219 return 0; |
1196 } | 1220 } |
1197 | 1221 |
1198 | 1222 |
1199 #define SET_FIELD_WRAPPED(obj, setter, cdata) do { \ | 1223 #define SET_FIELD_WRAPPED(obj, setter, cdata) do { \ |
1200 i::Handle<i::Object> foreign = FromCData(cdata); \ | 1224 i::Handle<i::Object> foreign = FromCData(cdata); \ |
1201 (obj)->setter(*foreign); \ | 1225 (obj)->setter(*foreign); \ |
1202 } while (false) | 1226 } while (false) |
1203 | 1227 |
1204 | 1228 |
1205 void FunctionTemplate::SetCallHandler(InvocationCallback callback, | 1229 template<typename Callback> |
1206 v8::Handle<Value> data) { | 1230 static void FunctionTemplateSetCallHandler(FunctionTemplate* function_template, |
1207 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); | 1231 Callback callback, |
| 1232 v8::Handle<Value> data) { |
| 1233 i::Isolate* isolate = Utils::OpenHandle(function_template)->GetIsolate(); |
1208 if (IsDeadCheck(isolate, "v8::FunctionTemplate::SetCallHandler()")) return; | 1234 if (IsDeadCheck(isolate, "v8::FunctionTemplate::SetCallHandler()")) return; |
1209 ENTER_V8(isolate); | 1235 ENTER_V8(isolate); |
1210 i::HandleScope scope(isolate); | 1236 i::HandleScope scope(isolate); |
1211 i::Handle<i::Struct> struct_obj = | 1237 i::Handle<i::Struct> struct_obj = |
1212 isolate->factory()->NewStruct(i::CALL_HANDLER_INFO_TYPE); | 1238 isolate->factory()->NewStruct(i::CALL_HANDLER_INFO_TYPE); |
1213 i::Handle<i::CallHandlerInfo> obj = | 1239 i::Handle<i::CallHandlerInfo> obj = |
1214 i::Handle<i::CallHandlerInfo>::cast(struct_obj); | 1240 i::Handle<i::CallHandlerInfo>::cast(struct_obj); |
1215 SET_FIELD_WRAPPED(obj, set_callback, callback); | 1241 SET_FIELD_WRAPPED(obj, set_callback, callback); |
1216 if (data.IsEmpty()) data = v8::Undefined(); | 1242 if (data.IsEmpty()) data = v8::Undefined(); |
1217 obj->set_data(*Utils::OpenHandle(*data)); | 1243 obj->set_data(*Utils::OpenHandle(*data)); |
1218 Utils::OpenHandle(this)->set_call_code(*obj); | 1244 Utils::OpenHandle(function_template)->set_call_code(*obj); |
1219 } | 1245 } |
1220 | 1246 |
| 1247 void FunctionTemplate::SetCallHandler(InvocationCallback callback, |
| 1248 v8::Handle<Value> data) { |
| 1249 FunctionTemplateSetCallHandler(this, callback, data); |
| 1250 } |
| 1251 |
| 1252 void FunctionTemplate::SetCallHandler(FunctionCallback callback, |
| 1253 v8::Handle<Value> data) { |
| 1254 FunctionTemplateSetCallHandler(this, callback, data); |
| 1255 } |
1221 | 1256 |
1222 static i::Handle<i::AccessorInfo> SetAccessorInfoProperties( | 1257 static i::Handle<i::AccessorInfo> SetAccessorInfoProperties( |
1223 i::Handle<i::AccessorInfo> obj, | 1258 i::Handle<i::AccessorInfo> obj, |
1224 v8::Handle<String> name, | 1259 v8::Handle<String> name, |
1225 v8::AccessControl settings, | 1260 v8::AccessControl settings, |
1226 v8::PropertyAttribute attributes, | 1261 v8::PropertyAttribute attributes, |
1227 v8::Handle<AccessorSignature> signature) { | 1262 v8::Handle<AccessorSignature> signature) { |
1228 obj->set_name(*Utils::OpenHandle(*name)); | 1263 obj->set_name(*Utils::OpenHandle(*name)); |
1229 if (settings & ALL_CAN_READ) obj->set_all_can_read(true); | 1264 if (settings & ALL_CAN_READ) obj->set_all_can_read(true); |
1230 if (settings & ALL_CAN_WRITE) obj->set_all_can_write(true); | 1265 if (settings & ALL_CAN_WRITE) obj->set_all_can_write(true); |
1231 if (settings & PROHIBITS_OVERWRITING) obj->set_prohibits_overwriting(true); | 1266 if (settings & PROHIBITS_OVERWRITING) obj->set_prohibits_overwriting(true); |
1232 obj->set_property_attributes(static_cast<PropertyAttributes>(attributes)); | 1267 obj->set_property_attributes(static_cast<PropertyAttributes>(attributes)); |
1233 if (!signature.IsEmpty()) { | 1268 if (!signature.IsEmpty()) { |
1234 obj->set_expected_receiver_type(*Utils::OpenHandle(*signature)); | 1269 obj->set_expected_receiver_type(*Utils::OpenHandle(*signature)); |
1235 } | 1270 } |
1236 return obj; | 1271 return obj; |
1237 } | 1272 } |
1238 | 1273 |
1239 | 1274 |
| 1275 template<typename Getter, typename Setter> |
1240 static i::Handle<i::AccessorInfo> MakeAccessorInfo( | 1276 static i::Handle<i::AccessorInfo> MakeAccessorInfo( |
1241 v8::Handle<String> name, | 1277 v8::Handle<String> name, |
1242 AccessorGetter getter, | 1278 Getter getter_in, |
1243 AccessorSetter setter, | 1279 Setter setter_in, |
1244 v8::Handle<Value> data, | 1280 v8::Handle<Value> data, |
1245 v8::AccessControl settings, | 1281 v8::AccessControl settings, |
1246 v8::PropertyAttribute attributes, | 1282 v8::PropertyAttribute attributes, |
1247 v8::Handle<AccessorSignature> signature) { | 1283 v8::Handle<AccessorSignature> signature) { |
1248 i::Isolate* isolate = Utils::OpenHandle(*name)->GetIsolate(); | 1284 i::Isolate* isolate = Utils::OpenHandle(*name)->GetIsolate(); |
1249 i::Handle<i::ExecutableAccessorInfo> obj = | 1285 i::Handle<i::ExecutableAccessorInfo> obj = |
1250 isolate->factory()->NewExecutableAccessorInfo(); | 1286 isolate->factory()->NewExecutableAccessorInfo(); |
| 1287 AccessorGetter getter = i::CallbackTable::Register(isolate, getter_in); |
1251 SET_FIELD_WRAPPED(obj, set_getter, getter); | 1288 SET_FIELD_WRAPPED(obj, set_getter, getter); |
| 1289 AccessorSetter setter = i::CallbackTable::Register(isolate, setter_in); |
1252 SET_FIELD_WRAPPED(obj, set_setter, setter); | 1290 SET_FIELD_WRAPPED(obj, set_setter, setter); |
1253 if (data.IsEmpty()) data = v8::Undefined(); | 1291 if (data.IsEmpty()) data = v8::Undefined(); |
1254 obj->set_data(*Utils::OpenHandle(*data)); | 1292 obj->set_data(*Utils::OpenHandle(*data)); |
1255 return SetAccessorInfoProperties(obj, name, settings, attributes, signature); | 1293 return SetAccessorInfoProperties(obj, name, settings, attributes, signature); |
1256 } | 1294 } |
1257 | 1295 |
1258 | 1296 |
1259 static i::Handle<i::AccessorInfo> MakeAccessorInfo( | 1297 static i::Handle<i::AccessorInfo> MakeAccessorInfo( |
1260 v8::Handle<String> name, | 1298 v8::Handle<String> name, |
1261 v8::Handle<v8::DeclaredAccessorDescriptor> descriptor, | 1299 v8::Handle<v8::DeclaredAccessorDescriptor> descriptor, |
| 1300 void* setter_ignored, |
| 1301 void* data_ignored, |
1262 v8::AccessControl settings, | 1302 v8::AccessControl settings, |
1263 v8::PropertyAttribute attributes, | 1303 v8::PropertyAttribute attributes, |
1264 v8::Handle<AccessorSignature> signature) { | 1304 v8::Handle<AccessorSignature> signature) { |
1265 i::Isolate* isolate = Utils::OpenHandle(*name)->GetIsolate(); | 1305 i::Isolate* isolate = Utils::OpenHandle(*name)->GetIsolate(); |
1266 if (descriptor.IsEmpty()) return i::Handle<i::DeclaredAccessorInfo>(); | 1306 if (descriptor.IsEmpty()) return i::Handle<i::DeclaredAccessorInfo>(); |
1267 i::Handle<i::DeclaredAccessorInfo> obj = | 1307 i::Handle<i::DeclaredAccessorInfo> obj = |
1268 isolate->factory()->NewDeclaredAccessorInfo(); | 1308 isolate->factory()->NewDeclaredAccessorInfo(); |
1269 obj->set_descriptor(*Utils::OpenHandle(*descriptor)); | 1309 obj->set_descriptor(*Utils::OpenHandle(*descriptor)); |
1270 return SetAccessorInfoProperties(obj, name, settings, attributes, signature); | 1310 return SetAccessorInfoProperties(obj, name, settings, attributes, signature); |
1271 } | 1311 } |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1316 | 1356 |
1317 void FunctionTemplate::ReadOnlyPrototype() { | 1357 void FunctionTemplate::ReadOnlyPrototype() { |
1318 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); | 1358 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); |
1319 if (IsDeadCheck(isolate, "v8::FunctionTemplate::ReadOnlyPrototype()")) { | 1359 if (IsDeadCheck(isolate, "v8::FunctionTemplate::ReadOnlyPrototype()")) { |
1320 return; | 1360 return; |
1321 } | 1361 } |
1322 ENTER_V8(isolate); | 1362 ENTER_V8(isolate); |
1323 Utils::OpenHandle(this)->set_read_only_prototype(true); | 1363 Utils::OpenHandle(this)->set_read_only_prototype(true); |
1324 } | 1364 } |
1325 | 1365 |
1326 | 1366 template< |
1327 void FunctionTemplate::SetNamedInstancePropertyHandler( | 1367 typename Getter, |
1328 NamedPropertyGetter getter, | 1368 typename Setter, |
1329 NamedPropertySetter setter, | 1369 typename Query, |
1330 NamedPropertyQuery query, | 1370 typename Deleter, |
1331 NamedPropertyDeleter remover, | 1371 typename Enumerator> |
1332 NamedPropertyEnumerator enumerator, | 1372 static void SetNamedInstancePropertyHandler( |
| 1373 i::Handle<i::FunctionTemplateInfo> function_template, |
| 1374 Getter getter_in, |
| 1375 Setter setter_in, |
| 1376 Query query_in, |
| 1377 Deleter remover_in, |
| 1378 Enumerator enumerator_in, |
1333 Handle<Value> data) { | 1379 Handle<Value> data) { |
1334 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); | 1380 i::Isolate* isolate = function_template->GetIsolate(); |
1335 if (IsDeadCheck(isolate, | 1381 if (IsDeadCheck(isolate, |
1336 "v8::FunctionTemplate::SetNamedInstancePropertyHandler()")) { | 1382 "v8::FunctionTemplate::SetNamedInstancePropertyHandler()")) { |
1337 return; | 1383 return; |
1338 } | 1384 } |
1339 ENTER_V8(isolate); | 1385 ENTER_V8(isolate); |
1340 i::HandleScope scope(isolate); | 1386 i::HandleScope scope(isolate); |
1341 i::Handle<i::Struct> struct_obj = | 1387 i::Handle<i::Struct> struct_obj = |
1342 isolate->factory()->NewStruct(i::INTERCEPTOR_INFO_TYPE); | 1388 isolate->factory()->NewStruct(i::INTERCEPTOR_INFO_TYPE); |
1343 i::Handle<i::InterceptorInfo> obj = | 1389 i::Handle<i::InterceptorInfo> obj = |
1344 i::Handle<i::InterceptorInfo>::cast(struct_obj); | 1390 i::Handle<i::InterceptorInfo>::cast(struct_obj); |
1345 | 1391 |
| 1392 NamedPropertyGetter getter = i::CallbackTable::Register(isolate, getter_in); |
1346 if (getter != 0) SET_FIELD_WRAPPED(obj, set_getter, getter); | 1393 if (getter != 0) SET_FIELD_WRAPPED(obj, set_getter, getter); |
| 1394 NamedPropertySetter setter = i::CallbackTable::Register(isolate, setter_in); |
1347 if (setter != 0) SET_FIELD_WRAPPED(obj, set_setter, setter); | 1395 if (setter != 0) SET_FIELD_WRAPPED(obj, set_setter, setter); |
| 1396 NamedPropertyQuery query = i::CallbackTable::Register(isolate, query_in); |
1348 if (query != 0) SET_FIELD_WRAPPED(obj, set_query, query); | 1397 if (query != 0) SET_FIELD_WRAPPED(obj, set_query, query); |
| 1398 NamedPropertyDeleter remover = |
| 1399 i::CallbackTable::Register(isolate, remover_in); |
1349 if (remover != 0) SET_FIELD_WRAPPED(obj, set_deleter, remover); | 1400 if (remover != 0) SET_FIELD_WRAPPED(obj, set_deleter, remover); |
| 1401 NamedPropertyEnumerator enumerator = |
| 1402 i::CallbackTable::Register(isolate, enumerator_in); |
1350 if (enumerator != 0) SET_FIELD_WRAPPED(obj, set_enumerator, enumerator); | 1403 if (enumerator != 0) SET_FIELD_WRAPPED(obj, set_enumerator, enumerator); |
1351 | 1404 |
1352 if (data.IsEmpty()) data = v8::Undefined(); | 1405 if (data.IsEmpty()) data = v8::Undefined(); |
1353 obj->set_data(*Utils::OpenHandle(*data)); | 1406 obj->set_data(*Utils::OpenHandle(*data)); |
1354 Utils::OpenHandle(this)->set_named_property_handler(*obj); | 1407 function_template->set_named_property_handler(*obj); |
1355 } | 1408 } |
1356 | 1409 |
1357 | 1410 |
1358 void FunctionTemplate::SetIndexedInstancePropertyHandler( | 1411 template< |
1359 IndexedPropertyGetter getter, | 1412 typename Getter, |
1360 IndexedPropertySetter setter, | 1413 typename Setter, |
1361 IndexedPropertyQuery query, | 1414 typename Query, |
1362 IndexedPropertyDeleter remover, | 1415 typename Deleter, |
1363 IndexedPropertyEnumerator enumerator, | 1416 typename Enumerator> |
| 1417 static void SetIndexedInstancePropertyHandler( |
| 1418 i::Handle<i::FunctionTemplateInfo> function_template, |
| 1419 Getter getter_in, |
| 1420 Setter setter_in, |
| 1421 Query query_in, |
| 1422 Deleter remover_in, |
| 1423 Enumerator enumerator_in, |
1364 Handle<Value> data) { | 1424 Handle<Value> data) { |
1365 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); | 1425 i::Isolate* isolate = function_template->GetIsolate(); |
1366 if (IsDeadCheck(isolate, | 1426 if (IsDeadCheck(isolate, |
1367 "v8::FunctionTemplate::SetIndexedInstancePropertyHandler()")) { | 1427 "v8::FunctionTemplate::SetIndexedInstancePropertyHandler()")) { |
1368 return; | 1428 return; |
1369 } | 1429 } |
1370 ENTER_V8(isolate); | 1430 ENTER_V8(isolate); |
1371 i::HandleScope scope(isolate); | 1431 i::HandleScope scope(isolate); |
1372 i::Handle<i::Struct> struct_obj = | 1432 i::Handle<i::Struct> struct_obj = |
1373 isolate->factory()->NewStruct(i::INTERCEPTOR_INFO_TYPE); | 1433 isolate->factory()->NewStruct(i::INTERCEPTOR_INFO_TYPE); |
1374 i::Handle<i::InterceptorInfo> obj = | 1434 i::Handle<i::InterceptorInfo> obj = |
1375 i::Handle<i::InterceptorInfo>::cast(struct_obj); | 1435 i::Handle<i::InterceptorInfo>::cast(struct_obj); |
1376 | 1436 |
| 1437 IndexedPropertyGetter getter = |
| 1438 i::CallbackTable::Register(isolate, getter_in); |
1377 if (getter != 0) SET_FIELD_WRAPPED(obj, set_getter, getter); | 1439 if (getter != 0) SET_FIELD_WRAPPED(obj, set_getter, getter); |
| 1440 IndexedPropertySetter setter = |
| 1441 i::CallbackTable::Register(isolate, setter_in); |
1378 if (setter != 0) SET_FIELD_WRAPPED(obj, set_setter, setter); | 1442 if (setter != 0) SET_FIELD_WRAPPED(obj, set_setter, setter); |
| 1443 IndexedPropertyQuery query = i::CallbackTable::Register(isolate, query_in); |
1379 if (query != 0) SET_FIELD_WRAPPED(obj, set_query, query); | 1444 if (query != 0) SET_FIELD_WRAPPED(obj, set_query, query); |
| 1445 IndexedPropertyDeleter remover = |
| 1446 i::CallbackTable::Register(isolate, remover_in); |
1380 if (remover != 0) SET_FIELD_WRAPPED(obj, set_deleter, remover); | 1447 if (remover != 0) SET_FIELD_WRAPPED(obj, set_deleter, remover); |
| 1448 IndexedPropertyEnumerator enumerator = |
| 1449 i::CallbackTable::Register(isolate, enumerator_in); |
1381 if (enumerator != 0) SET_FIELD_WRAPPED(obj, set_enumerator, enumerator); | 1450 if (enumerator != 0) SET_FIELD_WRAPPED(obj, set_enumerator, enumerator); |
1382 | 1451 |
1383 if (data.IsEmpty()) data = v8::Undefined(); | 1452 if (data.IsEmpty()) data = v8::Undefined(); |
1384 obj->set_data(*Utils::OpenHandle(*data)); | 1453 obj->set_data(*Utils::OpenHandle(*data)); |
1385 Utils::OpenHandle(this)->set_indexed_property_handler(*obj); | 1454 function_template->set_indexed_property_handler(*obj); |
1386 } | 1455 } |
1387 | 1456 |
1388 | 1457 |
1389 void FunctionTemplate::SetInstanceCallAsFunctionHandler( | 1458 template<typename Callback> |
1390 InvocationCallback callback, | 1459 static void SetInstanceCallAsFunctionHandler( |
| 1460 i::Handle<i::FunctionTemplateInfo> function_template, |
| 1461 Callback callback_in, |
1391 Handle<Value> data) { | 1462 Handle<Value> data) { |
1392 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); | 1463 i::Isolate* isolate = function_template->GetIsolate(); |
1393 if (IsDeadCheck(isolate, | 1464 if (IsDeadCheck(isolate, |
1394 "v8::FunctionTemplate::SetInstanceCallAsFunctionHandler()")) { | 1465 "v8::FunctionTemplate::SetInstanceCallAsFunctionHandler()")) { |
1395 return; | 1466 return; |
1396 } | 1467 } |
1397 ENTER_V8(isolate); | 1468 ENTER_V8(isolate); |
1398 i::HandleScope scope(isolate); | 1469 i::HandleScope scope(isolate); |
1399 i::Handle<i::Struct> struct_obj = | 1470 i::Handle<i::Struct> struct_obj = |
1400 isolate->factory()->NewStruct(i::CALL_HANDLER_INFO_TYPE); | 1471 isolate->factory()->NewStruct(i::CALL_HANDLER_INFO_TYPE); |
1401 i::Handle<i::CallHandlerInfo> obj = | 1472 i::Handle<i::CallHandlerInfo> obj = |
1402 i::Handle<i::CallHandlerInfo>::cast(struct_obj); | 1473 i::Handle<i::CallHandlerInfo>::cast(struct_obj); |
| 1474 InvocationCallback callback = |
| 1475 i::CallbackTable::Register(isolate, callback_in); |
1403 SET_FIELD_WRAPPED(obj, set_callback, callback); | 1476 SET_FIELD_WRAPPED(obj, set_callback, callback); |
1404 if (data.IsEmpty()) data = v8::Undefined(); | 1477 if (data.IsEmpty()) data = v8::Undefined(); |
1405 obj->set_data(*Utils::OpenHandle(*data)); | 1478 obj->set_data(*Utils::OpenHandle(*data)); |
1406 Utils::OpenHandle(this)->set_instance_call_handler(*obj); | 1479 function_template->set_instance_call_handler(*obj); |
1407 } | 1480 } |
1408 | 1481 |
1409 | 1482 |
1410 // --- O b j e c t T e m p l a t e --- | 1483 // --- O b j e c t T e m p l a t e --- |
1411 | 1484 |
1412 | 1485 |
1413 Local<ObjectTemplate> ObjectTemplate::New() { | 1486 Local<ObjectTemplate> ObjectTemplate::New() { |
1414 return New(Local<FunctionTemplate>()); | 1487 return New(Local<FunctionTemplate>()); |
1415 } | 1488 } |
1416 | 1489 |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1454 i::Handle<i::Object> list(cons->property_accessors(), cons->GetIsolate()); | 1527 i::Handle<i::Object> list(cons->property_accessors(), cons->GetIsolate()); |
1455 if (list->IsUndefined()) { | 1528 if (list->IsUndefined()) { |
1456 list = NeanderArray().value(); | 1529 list = NeanderArray().value(); |
1457 cons->set_property_accessors(*list); | 1530 cons->set_property_accessors(*list); |
1458 } | 1531 } |
1459 NeanderArray array(list); | 1532 NeanderArray array(list); |
1460 array.add(obj); | 1533 array.add(obj); |
1461 } | 1534 } |
1462 | 1535 |
1463 | 1536 |
| 1537 template<typename Setter, typename Getter, typename Data> |
| 1538 static bool ObjectTemplateSetAccessor( |
| 1539 ObjectTemplate* object_template, |
| 1540 v8::Handle<String> name, |
| 1541 Getter getter, |
| 1542 Setter setter, |
| 1543 Data data, |
| 1544 AccessControl settings, |
| 1545 PropertyAttribute attribute, |
| 1546 v8::Handle<AccessorSignature> signature) { |
| 1547 i::Isolate* isolate = Utils::OpenHandle(object_template)->GetIsolate(); |
| 1548 if (IsDeadCheck(isolate, "v8::ObjectTemplate::SetAccessor()")) return false; |
| 1549 ENTER_V8(isolate); |
| 1550 i::HandleScope scope(isolate); |
| 1551 EnsureConstructor(object_template); |
| 1552 i::FunctionTemplateInfo* constructor = i::FunctionTemplateInfo::cast( |
| 1553 Utils::OpenHandle(object_template)->constructor()); |
| 1554 i::Handle<i::FunctionTemplateInfo> cons(constructor); |
| 1555 i::Handle<i::AccessorInfo> obj = MakeAccessorInfo( |
| 1556 name, getter, setter, data, settings, attribute, signature); |
| 1557 if (obj.is_null()) return false; |
| 1558 AddPropertyToFunctionTemplate(cons, obj); |
| 1559 return true; |
| 1560 } |
| 1561 |
| 1562 |
1464 void ObjectTemplate::SetAccessor(v8::Handle<String> name, | 1563 void ObjectTemplate::SetAccessor(v8::Handle<String> name, |
1465 AccessorGetter getter, | 1564 AccessorGetter getter, |
1466 AccessorSetter setter, | 1565 AccessorSetter setter, |
1467 v8::Handle<Value> data, | 1566 v8::Handle<Value> data, |
1468 AccessControl settings, | 1567 AccessControl settings, |
1469 PropertyAttribute attribute, | 1568 PropertyAttribute attribute, |
1470 v8::Handle<AccessorSignature> signature) { | 1569 v8::Handle<AccessorSignature> signature) { |
1471 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); | 1570 ObjectTemplateSetAccessor( |
1472 if (IsDeadCheck(isolate, "v8::ObjectTemplate::SetAccessor()")) return; | 1571 this, name, getter, setter, data, settings, attribute, signature); |
1473 ENTER_V8(isolate); | 1572 } |
1474 i::HandleScope scope(isolate); | 1573 |
1475 EnsureConstructor(this); | 1574 |
1476 i::FunctionTemplateInfo* constructor = | 1575 void ObjectTemplate::SetAccessor(v8::Handle<String> name, |
1477 i::FunctionTemplateInfo::cast(Utils::OpenHandle(this)->constructor()); | 1576 AccessorGetterCallback getter, |
1478 i::Handle<i::FunctionTemplateInfo> cons(constructor); | 1577 AccessorSetterCallback setter, |
1479 i::Handle<i::AccessorInfo> obj = MakeAccessorInfo(name, getter, setter, data, | 1578 v8::Handle<Value> data, |
1480 settings, attribute, | 1579 AccessControl settings, |
1481 signature); | 1580 PropertyAttribute attribute, |
1482 AddPropertyToFunctionTemplate(cons, obj); | 1581 v8::Handle<AccessorSignature> signature) { |
| 1582 ObjectTemplateSetAccessor( |
| 1583 this, name, getter, setter, data, settings, attribute, signature); |
1483 } | 1584 } |
1484 | 1585 |
1485 | 1586 |
1486 bool ObjectTemplate::SetAccessor(Handle<String> name, | 1587 bool ObjectTemplate::SetAccessor(Handle<String> name, |
1487 Handle<DeclaredAccessorDescriptor> descriptor, | 1588 Handle<DeclaredAccessorDescriptor> descriptor, |
1488 AccessControl settings, | 1589 AccessControl settings, |
1489 PropertyAttribute attribute, | 1590 PropertyAttribute attribute, |
1490 Handle<AccessorSignature> signature) { | 1591 Handle<AccessorSignature> signature) { |
1491 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); | 1592 void* null = NULL; |
1492 if (IsDeadCheck(isolate, "v8::ObjectTemplate::SetAccessor()")) return false; | 1593 return ObjectTemplateSetAccessor( |
1493 ENTER_V8(isolate); | 1594 this, name, descriptor, null, null, settings, attribute, signature); |
1494 i::HandleScope scope(isolate); | |
1495 EnsureConstructor(this); | |
1496 i::FunctionTemplateInfo* constructor = | |
1497 i::FunctionTemplateInfo::cast(Utils::OpenHandle(this)->constructor()); | |
1498 i::Handle<i::FunctionTemplateInfo> cons(constructor); | |
1499 i::Handle<i::AccessorInfo> obj = MakeAccessorInfo( | |
1500 name, descriptor, settings, attribute, signature); | |
1501 if (obj.is_null()) return false; | |
1502 AddPropertyToFunctionTemplate(cons, obj); | |
1503 return true; | |
1504 } | 1595 } |
1505 | 1596 |
1506 | 1597 |
1507 void ObjectTemplate::SetNamedPropertyHandler(NamedPropertyGetter getter, | 1598 template< |
1508 NamedPropertySetter setter, | 1599 typename Getter, |
1509 NamedPropertyQuery query, | 1600 typename Setter, |
1510 NamedPropertyDeleter remover, | 1601 typename Query, |
1511 NamedPropertyEnumerator enumerator, | 1602 typename Deleter, |
1512 Handle<Value> data) { | 1603 typename Enumerator> |
1513 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); | 1604 static void ObjectTemplateSetNamedPropertyHandler( |
| 1605 ObjectTemplate* object_template, |
| 1606 Getter getter, |
| 1607 Setter setter, |
| 1608 Query query, |
| 1609 Deleter remover, |
| 1610 Enumerator enumerator, |
| 1611 Handle<Value> data) { |
| 1612 i::Isolate* isolate = Utils::OpenHandle(object_template)->GetIsolate(); |
1514 if (IsDeadCheck(isolate, "v8::ObjectTemplate::SetNamedPropertyHandler()")) { | 1613 if (IsDeadCheck(isolate, "v8::ObjectTemplate::SetNamedPropertyHandler()")) { |
1515 return; | 1614 return; |
1516 } | 1615 } |
1517 ENTER_V8(isolate); | 1616 ENTER_V8(isolate); |
1518 i::HandleScope scope(isolate); | 1617 i::HandleScope scope(isolate); |
1519 EnsureConstructor(this); | 1618 EnsureConstructor(object_template); |
1520 i::FunctionTemplateInfo* constructor = | 1619 i::FunctionTemplateInfo* constructor = i::FunctionTemplateInfo::cast( |
1521 i::FunctionTemplateInfo::cast(Utils::OpenHandle(this)->constructor()); | 1620 Utils::OpenHandle(object_template)->constructor()); |
1522 i::Handle<i::FunctionTemplateInfo> cons(constructor); | 1621 i::Handle<i::FunctionTemplateInfo> cons(constructor); |
1523 Utils::ToLocal(cons)->SetNamedInstancePropertyHandler(getter, | 1622 SetNamedInstancePropertyHandler(cons, |
1524 setter, | 1623 getter, |
1525 query, | 1624 setter, |
1526 remover, | 1625 query, |
1527 enumerator, | 1626 remover, |
1528 data); | 1627 enumerator, |
| 1628 data); |
1529 } | 1629 } |
1530 | 1630 |
1531 | 1631 |
| 1632 void ObjectTemplate::SetNamedPropertyHandler( |
| 1633 NamedPropertyGetter getter, |
| 1634 NamedPropertySetter setter, |
| 1635 NamedPropertyQuery query, |
| 1636 NamedPropertyDeleter remover, |
| 1637 NamedPropertyEnumerator enumerator, |
| 1638 Handle<Value> data) { |
| 1639 ObjectTemplateSetNamedPropertyHandler( |
| 1640 this, getter, setter, query, remover, enumerator, data); |
| 1641 } |
| 1642 |
| 1643 |
| 1644 void ObjectTemplate::SetNamedPropertyHandler( |
| 1645 NamedPropertyGetterCallback getter, |
| 1646 NamedPropertySetterCallback setter, |
| 1647 NamedPropertyQueryCallback query, |
| 1648 NamedPropertyDeleterCallback remover, |
| 1649 NamedPropertyEnumeratorCallback enumerator, |
| 1650 Handle<Value> data) { |
| 1651 ObjectTemplateSetNamedPropertyHandler( |
| 1652 this, getter, setter, query, remover, enumerator, data); |
| 1653 } |
| 1654 |
| 1655 |
1532 void ObjectTemplate::MarkAsUndetectable() { | 1656 void ObjectTemplate::MarkAsUndetectable() { |
1533 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); | 1657 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); |
1534 if (IsDeadCheck(isolate, "v8::ObjectTemplate::MarkAsUndetectable()")) return; | 1658 if (IsDeadCheck(isolate, "v8::ObjectTemplate::MarkAsUndetectable()")) return; |
1535 ENTER_V8(isolate); | 1659 ENTER_V8(isolate); |
1536 i::HandleScope scope(isolate); | 1660 i::HandleScope scope(isolate); |
1537 EnsureConstructor(this); | 1661 EnsureConstructor(this); |
1538 i::FunctionTemplateInfo* constructor = | 1662 i::FunctionTemplateInfo* constructor = |
1539 i::FunctionTemplateInfo::cast(Utils::OpenHandle(this)->constructor()); | 1663 i::FunctionTemplateInfo::cast(Utils::OpenHandle(this)->constructor()); |
1540 i::Handle<i::FunctionTemplateInfo> cons(constructor); | 1664 i::Handle<i::FunctionTemplateInfo> cons(constructor); |
1541 cons->set_undetectable(true); | 1665 cons->set_undetectable(true); |
(...skipping 25 matching lines...) Expand all Loading... |
1567 info->set_data(*Utils::OpenHandle(*data)); | 1691 info->set_data(*Utils::OpenHandle(*data)); |
1568 | 1692 |
1569 i::FunctionTemplateInfo* constructor = | 1693 i::FunctionTemplateInfo* constructor = |
1570 i::FunctionTemplateInfo::cast(Utils::OpenHandle(this)->constructor()); | 1694 i::FunctionTemplateInfo::cast(Utils::OpenHandle(this)->constructor()); |
1571 i::Handle<i::FunctionTemplateInfo> cons(constructor); | 1695 i::Handle<i::FunctionTemplateInfo> cons(constructor); |
1572 cons->set_access_check_info(*info); | 1696 cons->set_access_check_info(*info); |
1573 cons->set_needs_access_check(turned_on_by_default); | 1697 cons->set_needs_access_check(turned_on_by_default); |
1574 } | 1698 } |
1575 | 1699 |
1576 | 1700 |
| 1701 template< |
| 1702 typename Getter, |
| 1703 typename Setter, |
| 1704 typename Query, |
| 1705 typename Deleter, |
| 1706 typename Enumerator> |
| 1707 void ObjectTemplateSetIndexedPropertyHandler( |
| 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::SetIndexedPropertyHandler()")) { |
| 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 SetIndexedInstancePropertyHandler(cons, |
| 1726 getter, |
| 1727 setter, |
| 1728 query, |
| 1729 remover, |
| 1730 enumerator, |
| 1731 data); |
| 1732 } |
| 1733 |
| 1734 |
1577 void ObjectTemplate::SetIndexedPropertyHandler( | 1735 void ObjectTemplate::SetIndexedPropertyHandler( |
1578 IndexedPropertyGetter getter, | 1736 IndexedPropertyGetter getter, |
1579 IndexedPropertySetter setter, | 1737 IndexedPropertySetter setter, |
1580 IndexedPropertyQuery query, | 1738 IndexedPropertyQuery query, |
1581 IndexedPropertyDeleter remover, | 1739 IndexedPropertyDeleter remover, |
1582 IndexedPropertyEnumerator enumerator, | 1740 IndexedPropertyEnumerator enumerator, |
1583 Handle<Value> data) { | 1741 Handle<Value> data) { |
1584 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); | 1742 ObjectTemplateSetIndexedPropertyHandler( |
1585 if (IsDeadCheck(isolate, "v8::ObjectTemplate::SetIndexedPropertyHandler()")) { | 1743 this, getter, setter, query, remover, enumerator, data); |
1586 return; | |
1587 } | |
1588 ENTER_V8(isolate); | |
1589 i::HandleScope scope(isolate); | |
1590 EnsureConstructor(this); | |
1591 i::FunctionTemplateInfo* constructor = | |
1592 i::FunctionTemplateInfo::cast(Utils::OpenHandle(this)->constructor()); | |
1593 i::Handle<i::FunctionTemplateInfo> cons(constructor); | |
1594 Utils::ToLocal(cons)->SetIndexedInstancePropertyHandler(getter, | |
1595 setter, | |
1596 query, | |
1597 remover, | |
1598 enumerator, | |
1599 data); | |
1600 } | 1744 } |
1601 | 1745 |
1602 | 1746 |
1603 void ObjectTemplate::SetCallAsFunctionHandler(InvocationCallback callback, | 1747 void ObjectTemplate::SetIndexedPropertyHandler( |
1604 Handle<Value> data) { | 1748 IndexedPropertyGetterCallback getter, |
1605 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); | 1749 IndexedPropertySetterCallback setter, |
| 1750 IndexedPropertyQueryCallback query, |
| 1751 IndexedPropertyDeleterCallback remover, |
| 1752 IndexedPropertyEnumeratorCallback enumerator, |
| 1753 Handle<Value> data) { |
| 1754 ObjectTemplateSetIndexedPropertyHandler( |
| 1755 this, getter, setter, query, remover, enumerator, data); |
| 1756 } |
| 1757 |
| 1758 |
| 1759 template<typename Callback> |
| 1760 static void ObjectTemplateSetCallAsFunctionHandler( |
| 1761 ObjectTemplate* object_template, |
| 1762 Callback callback, |
| 1763 Handle<Value> data) { |
| 1764 i::Isolate* isolate = Utils::OpenHandle(object_template)->GetIsolate(); |
1606 if (IsDeadCheck(isolate, | 1765 if (IsDeadCheck(isolate, |
1607 "v8::ObjectTemplate::SetCallAsFunctionHandler()")) { | 1766 "v8::ObjectTemplate::SetCallAsFunctionHandler()")) { |
1608 return; | 1767 return; |
1609 } | 1768 } |
1610 ENTER_V8(isolate); | 1769 ENTER_V8(isolate); |
1611 i::HandleScope scope(isolate); | 1770 i::HandleScope scope(isolate); |
1612 EnsureConstructor(this); | 1771 EnsureConstructor(object_template); |
1613 i::FunctionTemplateInfo* constructor = | 1772 i::FunctionTemplateInfo* constructor = i::FunctionTemplateInfo::cast( |
1614 i::FunctionTemplateInfo::cast(Utils::OpenHandle(this)->constructor()); | 1773 Utils::OpenHandle(object_template)->constructor()); |
1615 i::Handle<i::FunctionTemplateInfo> cons(constructor); | 1774 i::Handle<i::FunctionTemplateInfo> cons(constructor); |
1616 Utils::ToLocal(cons)->SetInstanceCallAsFunctionHandler(callback, data); | 1775 SetInstanceCallAsFunctionHandler(cons, callback, data); |
1617 } | 1776 } |
1618 | 1777 |
1619 | 1778 |
| 1779 void ObjectTemplate::SetCallAsFunctionHandler(InvocationCallback callback, |
| 1780 Handle<Value> data) { |
| 1781 return ObjectTemplateSetCallAsFunctionHandler(this, callback, data); |
| 1782 } |
| 1783 |
| 1784 |
| 1785 void ObjectTemplate::SetCallAsFunctionHandler(FunctionCallback callback, |
| 1786 Handle<Value> data) { |
| 1787 return ObjectTemplateSetCallAsFunctionHandler(this, callback, data); |
| 1788 } |
| 1789 |
| 1790 |
1620 int ObjectTemplate::InternalFieldCount() { | 1791 int ObjectTemplate::InternalFieldCount() { |
1621 if (IsDeadCheck(Utils::OpenHandle(this)->GetIsolate(), | 1792 if (IsDeadCheck(Utils::OpenHandle(this)->GetIsolate(), |
1622 "v8::ObjectTemplate::InternalFieldCount()")) { | 1793 "v8::ObjectTemplate::InternalFieldCount()")) { |
1623 return 0; | 1794 return 0; |
1624 } | 1795 } |
1625 return i::Smi::cast(Utils::OpenHandle(this)->internal_field_count())->value(); | 1796 return i::Smi::cast(Utils::OpenHandle(this)->internal_field_count())->value(); |
1626 } | 1797 } |
1627 | 1798 |
1628 | 1799 |
1629 void ObjectTemplate::SetInternalFieldCount(int value) { | 1800 void ObjectTemplate::SetInternalFieldCount(int value) { |
(...skipping 1809 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3439 | 3610 |
3440 | 3611 |
3441 bool v8::Object::Has(uint32_t index) { | 3612 bool v8::Object::Has(uint32_t index) { |
3442 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); | 3613 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); |
3443 ON_BAILOUT(isolate, "v8::Object::HasProperty()", return false); | 3614 ON_BAILOUT(isolate, "v8::Object::HasProperty()", return false); |
3444 i::Handle<i::JSObject> self = Utils::OpenHandle(this); | 3615 i::Handle<i::JSObject> self = Utils::OpenHandle(this); |
3445 return self->HasElement(index); | 3616 return self->HasElement(index); |
3446 } | 3617 } |
3447 | 3618 |
3448 | 3619 |
3449 static inline bool SetAccessor(Object* obj, i::Handle<i::AccessorInfo> info) { | 3620 template<typename Setter, typename Getter, typename Data> |
| 3621 static inline bool ObjectSetAccessor(Object* obj, |
| 3622 Handle<String> name, |
| 3623 Setter getter, |
| 3624 Getter setter, |
| 3625 Data data, |
| 3626 AccessControl settings, |
| 3627 PropertyAttribute attributes) { |
| 3628 i::Isolate* isolate = Utils::OpenHandle(obj)->GetIsolate(); |
| 3629 ON_BAILOUT(isolate, "v8::Object::SetAccessor()", return false); |
| 3630 ENTER_V8(isolate); |
| 3631 i::HandleScope scope(isolate); |
| 3632 v8::Handle<AccessorSignature> signature; |
| 3633 i::Handle<i::AccessorInfo> info = MakeAccessorInfo( |
| 3634 name, getter, setter, data, settings, attributes, signature); |
3450 if (info.is_null()) return false; | 3635 if (info.is_null()) return false; |
3451 bool fast = Utils::OpenHandle(obj)->HasFastProperties(); | 3636 bool fast = Utils::OpenHandle(obj)->HasFastProperties(); |
3452 i::Handle<i::Object> result = i::SetAccessor(Utils::OpenHandle(obj), info); | 3637 i::Handle<i::Object> result = i::SetAccessor(Utils::OpenHandle(obj), info); |
3453 if (result.is_null() || result->IsUndefined()) return false; | 3638 if (result.is_null() || result->IsUndefined()) return false; |
3454 if (fast) i::JSObject::TransformToFastProperties(Utils::OpenHandle(obj), 0); | 3639 if (fast) i::JSObject::TransformToFastProperties(Utils::OpenHandle(obj), 0); |
3455 return true; | 3640 return true; |
3456 } | 3641 } |
3457 | 3642 |
3458 | 3643 |
3459 bool Object::SetAccessor(Handle<String> name, | 3644 bool Object::SetAccessor(Handle<String> name, |
3460 AccessorGetter getter, | 3645 AccessorGetter getter, |
3461 AccessorSetter setter, | 3646 AccessorSetter setter, |
3462 v8::Handle<Value> data, | 3647 v8::Handle<Value> data, |
3463 AccessControl settings, | 3648 AccessControl settings, |
3464 PropertyAttribute attributes) { | 3649 PropertyAttribute attributes) { |
3465 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); | 3650 return ObjectSetAccessor( |
3466 ON_BAILOUT(isolate, "v8::Object::SetAccessor()", return false); | 3651 this, name, getter, setter, data, settings, attributes); |
3467 ENTER_V8(isolate); | |
3468 i::HandleScope scope(isolate); | |
3469 v8::Handle<AccessorSignature> signature; | |
3470 i::Handle<i::AccessorInfo> info = MakeAccessorInfo(name, getter, setter, data, | |
3471 settings, attributes, | |
3472 signature); | |
3473 return v8::SetAccessor(this, info); | |
3474 } | 3652 } |
3475 | 3653 |
3476 | 3654 |
| 3655 bool Object::SetAccessor(Handle<String> name, |
| 3656 AccessorGetterCallback getter, |
| 3657 AccessorSetterCallback setter, |
| 3658 v8::Handle<Value> data, |
| 3659 AccessControl settings, |
| 3660 PropertyAttribute attributes) { |
| 3661 return ObjectSetAccessor( |
| 3662 this, name, getter, setter, data, settings, attributes); |
| 3663 } |
| 3664 |
| 3665 |
3477 bool Object::SetAccessor(Handle<String> name, | 3666 bool Object::SetAccessor(Handle<String> name, |
3478 Handle<DeclaredAccessorDescriptor> descriptor, | 3667 Handle<DeclaredAccessorDescriptor> descriptor, |
3479 AccessControl settings, | 3668 AccessControl settings, |
3480 PropertyAttribute attributes) { | 3669 PropertyAttribute attributes) { |
3481 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); | 3670 void* null = NULL; |
3482 ON_BAILOUT(isolate, "v8::Object::SetAccessor()", return false); | 3671 return ObjectSetAccessor( |
3483 ENTER_V8(isolate); | 3672 this, name, descriptor, null, null, settings, attributes); |
3484 i::HandleScope scope(isolate); | |
3485 v8::Handle<AccessorSignature> signature; | |
3486 i::Handle<i::AccessorInfo> info = MakeAccessorInfo( | |
3487 name, descriptor, settings, attributes, signature); | |
3488 return v8::SetAccessor(this, info); | |
3489 } | 3673 } |
3490 | 3674 |
3491 | 3675 |
3492 bool v8::Object::HasOwnProperty(Handle<String> key) { | 3676 bool v8::Object::HasOwnProperty(Handle<String> key) { |
3493 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); | 3677 i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); |
3494 ON_BAILOUT(isolate, "v8::Object::HasOwnProperty()", | 3678 ON_BAILOUT(isolate, "v8::Object::HasOwnProperty()", |
3495 return false); | 3679 return false); |
3496 return Utils::OpenHandle(this)->HasLocalProperty( | 3680 return Utils::OpenHandle(this)->HasLocalProperty( |
3497 *Utils::OpenHandle(*key)); | 3681 *Utils::OpenHandle(*key)); |
3498 } | 3682 } |
(...skipping 4184 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7683 | 7867 |
7684 v->VisitPointers(blocks_.first(), first_block_limit_); | 7868 v->VisitPointers(blocks_.first(), first_block_limit_); |
7685 | 7869 |
7686 for (int i = 1; i < blocks_.length(); i++) { | 7870 for (int i = 1; i < blocks_.length(); i++) { |
7687 v->VisitPointers(blocks_[i], &blocks_[i][kHandleBlockSize]); | 7871 v->VisitPointers(blocks_[i], &blocks_[i][kHandleBlockSize]); |
7688 } | 7872 } |
7689 } | 7873 } |
7690 | 7874 |
7691 | 7875 |
7692 } } // namespace v8::internal | 7876 } } // namespace v8::internal |
OLD | NEW |