Changeset 143305 in webkit


Ignore:
Timestamp:
Feb 19, 2013 12:21:57 AM (11 years ago)
Author:
haraken@chromium.org
Message:

[V8] Remove redundant usage of MAYBE_MISSING_PARAMETER() macro
​https://bugs.webkit.org/show_bug.cgi?id=109899

Reviewed by Adam Barth.

Currently:

  • MAYBE_MISSING_PARAMETER(args, index, DefaultIsUndefined) returns args[index].
  • MAYBE_MISSING_PARAMETER(args, index, DefaultIsNullString) returns Local<Value>()

if args[index] is missing (i.e. the length of |args| is less than |index|).
It returns args[index] otherwise.

No one other than CodeGeneratorV8.pm uses
MAYBE_MISSING_PARAMETER(args, index, DefaultIsUndefined). Instead, we simply use
args[index]. We should remove the redundant usage from CodeGeneratorV8.pm too.
The long-name macro has been making generated code less readable.

In addition, we can rename MAYBE_MISSING_PARAMETER() to argumentOrNull().

No tests. No change in behavior.

  • bindings/scripts/CodeGeneratorV8.pm:

(GenerateParametersCheck):

  • bindings/scripts/test/V8/V8Float64Array.cpp:

(WebCore::Float64ArrayV8Internal::fooCallback):

  • bindings/scripts/test/V8/V8TestActiveDOMObject.cpp:

(WebCore::TestActiveDOMObjectV8Internal::excitingFunctionCallback):
(WebCore::TestActiveDOMObjectV8Internal::postMessageCallback):

  • bindings/scripts/test/V8/V8TestCustomNamedGetter.cpp:

(WebCore::TestCustomNamedGetterV8Internal::anotherFunctionCallback):

  • bindings/scripts/test/V8/V8TestEventTarget.cpp:

(WebCore::TestEventTargetV8Internal::itemCallback):
(WebCore::TestEventTargetV8Internal::dispatchEventCallback):

  • bindings/scripts/test/V8/V8TestInterface.cpp:

(WebCore::TestInterfaceV8Internal::supplementalMethod2Callback):
(WebCore::V8TestInterface::constructorCallback):

  • bindings/scripts/test/V8/V8TestMediaQueryListListener.cpp:

(WebCore::TestMediaQueryListListenerV8Internal::methodCallback):

  • bindings/scripts/test/V8/V8TestNamedConstructor.cpp:

(WebCore::V8TestNamedConstructorConstructorCallback):

  • bindings/scripts/test/V8/V8TestObj.cpp:

(WebCore::TestObjV8Internal::voidMethodWithArgsCallback):
(WebCore::TestObjV8Internal::longMethodWithArgsCallback):
(WebCore::TestObjV8Internal::objMethodWithArgsCallback):
(WebCore::TestObjV8Internal::methodWithSequenceArgCallback):
(WebCore::TestObjV8Internal::methodReturningSequenceCallback):
(WebCore::TestObjV8Internal::methodThatRequiresAllArgsAndThrowsCallback):
(WebCore::TestObjV8Internal::optionsObjectCallback):
(WebCore::TestObjV8Internal::methodWithOptionalArgCallback):
(WebCore::TestObjV8Internal::methodWithNonOptionalArgAndOptionalArgCallback):
(WebCore::TestObjV8Internal::methodWithNonOptionalArgAndTwoOptionalArgsCallback):
(WebCore::TestObjV8Internal::methodWithOptionalStringCallback):
(WebCore::TestObjV8Internal::methodWithOptionalStringIsUndefinedCallback):
(WebCore::TestObjV8Internal::methodWithOptionalStringIsNullStringCallback):
(WebCore::TestObjV8Internal::methodWithNonCallbackArgAndCallbackArgCallback):
(WebCore::TestObjV8Internal::overloadedMethod1Callback):
(WebCore::TestObjV8Internal::overloadedMethod2Callback):
(WebCore::TestObjV8Internal::overloadedMethod3Callback):
(WebCore::TestObjV8Internal::overloadedMethod4Callback):
(WebCore::TestObjV8Internal::overloadedMethod6Callback):
(WebCore::TestObjV8Internal::overloadedMethod7Callback):
(WebCore::TestObjV8Internal::overloadedMethod8Callback):
(WebCore::TestObjV8Internal::overloadedMethod9Callback):
(WebCore::TestObjV8Internal::overloadedMethod10Callback):
(WebCore::TestObjV8Internal::overloadedMethod11Callback):
(WebCore::TestObjV8Internal::classMethodWithOptionalCallback):
(WebCore::TestObjV8Internal::overloadedMethod12Callback):
(WebCore::TestObjV8Internal::enabledAtRuntimeMethod1Callback):
(WebCore::TestObjV8Internal::enabledAtRuntimeMethod2Callback):
(WebCore::TestObjV8Internal::enabledPerContextMethod1Callback):
(WebCore::TestObjV8Internal::enabledPerContextMethod2Callback):
(WebCore::TestObjV8Internal::stringArrayFunctionCallback):
(WebCore::TestObjV8Internal::domStringListFunctionCallback):
(WebCore::TestObjV8Internal::convert1Callback):
(WebCore::TestObjV8Internal::convert2Callback):
(WebCore::TestObjV8Internal::convert4Callback):
(WebCore::TestObjV8Internal::convert5Callback):
(WebCore::TestObjV8Internal::strictFunctionCallback):
(WebCore::TestObjV8Internal::variadicStringMethodCallback):
(WebCore::TestObjV8Internal::variadicDoubleMethodCallback):
(WebCore::TestObjV8Internal::variadicNodeMethodCallback):

  • bindings/scripts/test/V8/V8TestOverloadedConstructors.cpp:

(WebCore::V8TestOverloadedConstructors::constructor1Callback):
(WebCore::V8TestOverloadedConstructors::constructor2Callback):
(WebCore::V8TestOverloadedConstructors::constructor3Callback):
(WebCore::V8TestOverloadedConstructors::constructor4Callback):

  • bindings/scripts/test/V8/V8TestSerializedScriptValueInterface.cpp:

(WebCore::V8TestSerializedScriptValueInterface::constructorCallback):

  • bindings/scripts/test/V8/V8TestTypedefs.cpp:

(WebCore::TestTypedefsV8Internal::funcCallback):
(WebCore::TestTypedefsV8Internal::setShadowCallback):
(WebCore::TestTypedefsV8Internal::methodWithSequenceArgCallback):
(WebCore::TestTypedefsV8Internal::nullableArrayArgCallback):
(WebCore::TestTypedefsV8Internal::stringArrayFunctionCallback):
(WebCore::TestTypedefsV8Internal::stringArrayFunction2Callback):
(WebCore::V8TestTypedefs::constructorCallback):

  • bindings/v8/V8BindingMacros.h:

(WebCore):

  • bindings/v8/custom/V8HistoryCustom.cpp:

(WebCore::V8History::pushStateCallbackCustom):
(WebCore::V8History::replaceStateCallbackCustom):

Location:
trunk/Source/WebCore
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r143304 r143305  
     12013-02-19  Kentaro Hara  <haraken@chromium.org>
     2
     3        [V8] Remove redundant usage of MAYBE_MISSING_PARAMETER() macro
     4        https://bugs.webkit.org/show_bug.cgi?id=109899
     5
     6        Reviewed by Adam Barth.
     7
     8        Currently:
     9
     10        - MAYBE_MISSING_PARAMETER(args, index, DefaultIsUndefined) returns args[index].
     11        - MAYBE_MISSING_PARAMETER(args, index, DefaultIsNullString) returns Local<Value>()
     12        if args[index] is missing (i.e. the length of |args| is less than |index|).
     13        It returns args[index] otherwise.
     14
     15        No one other than CodeGeneratorV8.pm uses
     16        MAYBE_MISSING_PARAMETER(args, index, DefaultIsUndefined). Instead, we simply use
     17        args[index]. We should remove the redundant usage from CodeGeneratorV8.pm too.
     18        The long-name macro has been making generated code less readable.
     19
     20        In addition, we can rename MAYBE_MISSING_PARAMETER() to argumentOrNull().
     21
     22        No tests. No change in behavior.
     23
     24        * bindings/scripts/CodeGeneratorV8.pm:
     25        (GenerateParametersCheck):
     26        * bindings/scripts/test/V8/V8Float64Array.cpp:
     27        (WebCore::Float64ArrayV8Internal::fooCallback):
     28        * bindings/scripts/test/V8/V8TestActiveDOMObject.cpp:
     29        (WebCore::TestActiveDOMObjectV8Internal::excitingFunctionCallback):
     30        (WebCore::TestActiveDOMObjectV8Internal::postMessageCallback):
     31        * bindings/scripts/test/V8/V8TestCustomNamedGetter.cpp:
     32        (WebCore::TestCustomNamedGetterV8Internal::anotherFunctionCallback):
     33        * bindings/scripts/test/V8/V8TestEventTarget.cpp:
     34        (WebCore::TestEventTargetV8Internal::itemCallback):
     35        (WebCore::TestEventTargetV8Internal::dispatchEventCallback):
     36        * bindings/scripts/test/V8/V8TestInterface.cpp:
     37        (WebCore::TestInterfaceV8Internal::supplementalMethod2Callback):
     38        (WebCore::V8TestInterface::constructorCallback):
     39        * bindings/scripts/test/V8/V8TestMediaQueryListListener.cpp:
     40        (WebCore::TestMediaQueryListListenerV8Internal::methodCallback):
     41        * bindings/scripts/test/V8/V8TestNamedConstructor.cpp:
     42        (WebCore::V8TestNamedConstructorConstructorCallback):
     43        * bindings/scripts/test/V8/V8TestObj.cpp:
     44        (WebCore::TestObjV8Internal::voidMethodWithArgsCallback):
     45        (WebCore::TestObjV8Internal::longMethodWithArgsCallback):
     46        (WebCore::TestObjV8Internal::objMethodWithArgsCallback):
     47        (WebCore::TestObjV8Internal::methodWithSequenceArgCallback):
     48        (WebCore::TestObjV8Internal::methodReturningSequenceCallback):
     49        (WebCore::TestObjV8Internal::methodThatRequiresAllArgsAndThrowsCallback):
     50        (WebCore::TestObjV8Internal::optionsObjectCallback):
     51        (WebCore::TestObjV8Internal::methodWithOptionalArgCallback):
     52        (WebCore::TestObjV8Internal::methodWithNonOptionalArgAndOptionalArgCallback):
     53        (WebCore::TestObjV8Internal::methodWithNonOptionalArgAndTwoOptionalArgsCallback):
     54        (WebCore::TestObjV8Internal::methodWithOptionalStringCallback):
     55        (WebCore::TestObjV8Internal::methodWithOptionalStringIsUndefinedCallback):
     56        (WebCore::TestObjV8Internal::methodWithOptionalStringIsNullStringCallback):
     57        (WebCore::TestObjV8Internal::methodWithNonCallbackArgAndCallbackArgCallback):
     58        (WebCore::TestObjV8Internal::overloadedMethod1Callback):
     59        (WebCore::TestObjV8Internal::overloadedMethod2Callback):
     60        (WebCore::TestObjV8Internal::overloadedMethod3Callback):
     61        (WebCore::TestObjV8Internal::overloadedMethod4Callback):
     62        (WebCore::TestObjV8Internal::overloadedMethod6Callback):
     63        (WebCore::TestObjV8Internal::overloadedMethod7Callback):
     64        (WebCore::TestObjV8Internal::overloadedMethod8Callback):
     65        (WebCore::TestObjV8Internal::overloadedMethod9Callback):
     66        (WebCore::TestObjV8Internal::overloadedMethod10Callback):
     67        (WebCore::TestObjV8Internal::overloadedMethod11Callback):
     68        (WebCore::TestObjV8Internal::classMethodWithOptionalCallback):
     69        (WebCore::TestObjV8Internal::overloadedMethod12Callback):
     70        (WebCore::TestObjV8Internal::enabledAtRuntimeMethod1Callback):
     71        (WebCore::TestObjV8Internal::enabledAtRuntimeMethod2Callback):
     72        (WebCore::TestObjV8Internal::enabledPerContextMethod1Callback):
     73        (WebCore::TestObjV8Internal::enabledPerContextMethod2Callback):
     74        (WebCore::TestObjV8Internal::stringArrayFunctionCallback):
     75        (WebCore::TestObjV8Internal::domStringListFunctionCallback):
     76        (WebCore::TestObjV8Internal::convert1Callback):
     77        (WebCore::TestObjV8Internal::convert2Callback):
     78        (WebCore::TestObjV8Internal::convert4Callback):
     79        (WebCore::TestObjV8Internal::convert5Callback):
     80        (WebCore::TestObjV8Internal::strictFunctionCallback):
     81        (WebCore::TestObjV8Internal::variadicStringMethodCallback):
     82        (WebCore::TestObjV8Internal::variadicDoubleMethodCallback):
     83        (WebCore::TestObjV8Internal::variadicNodeMethodCallback):
     84        * bindings/scripts/test/V8/V8TestOverloadedConstructors.cpp:
     85        (WebCore::V8TestOverloadedConstructors::constructor1Callback):
     86        (WebCore::V8TestOverloadedConstructors::constructor2Callback):
     87        (WebCore::V8TestOverloadedConstructors::constructor3Callback):
     88        (WebCore::V8TestOverloadedConstructors::constructor4Callback):
     89        * bindings/scripts/test/V8/V8TestSerializedScriptValueInterface.cpp:
     90        (WebCore::V8TestSerializedScriptValueInterface::constructorCallback):
     91        * bindings/scripts/test/V8/V8TestTypedefs.cpp:
     92        (WebCore::TestTypedefsV8Internal::funcCallback):
     93        (WebCore::TestTypedefsV8Internal::setShadowCallback):
     94        (WebCore::TestTypedefsV8Internal::methodWithSequenceArgCallback):
     95        (WebCore::TestTypedefsV8Internal::nullableArrayArgCallback):
     96        (WebCore::TestTypedefsV8Internal::stringArrayFunctionCallback):
     97        (WebCore::TestTypedefsV8Internal::stringArrayFunction2Callback):
     98        (WebCore::V8TestTypedefs::constructorCallback):
     99        * bindings/v8/V8BindingMacros.h:
     100        (WebCore):
     101        * bindings/v8/custom/V8HistoryCustom.cpp:
     102        (WebCore::V8History::pushStateCallbackCustom):
     103        (WebCore::V8History::replaceStateCallbackCustom):
     104
    11052013-02-19  Kentaro Hara  <haraken@chromium.org>
    2106

  • trunk/Source/WebCore/bindings/scripts/CodeGeneratorV8.pm

    r143075 r143305  
    18131813            }
    18141814        } elsif ($nativeType =~ /^V8StringResource/) {
    1815             my $value = JSValueToNative($parameter, "MAYBE_MISSING_PARAMETER(args, $paramIndex, $parameterDefaultPolicy)", "args.GetIsolate()");
     1815            my $value = JSValueToNative($parameter, $optional eq "DefaultIsNullString" ? "argumentOrNull(args, $paramIndex)" : "args[$paramIndex]", "args.GetIsolate()");
    18161816            $parameterCheckString .= "    " . ConvertToV8StringResource($parameter, $nativeType, $parameterName, $value) . "\n";
    18171817        } else {
    … …  
    18311831            }
    18321832            $parameterCheckString .= "    V8TRYCATCH($nativeType, $parameterName, " .
    1833                  JSValueToNative($parameter, "MAYBE_MISSING_PARAMETER(args, $paramIndex, $parameterDefaultPolicy)", "args.GetIsolate()") . ");\n";
     1833                 JSValueToNative($parameter, $optional eq "DefaultIsNullString" ? "argumentOrNull(args, $paramIndex)" : "args[$paramIndex]", "args.GetIsolate()") . ");\n";
    18341834            if ($nativeType eq 'Dictionary') {
    18351835               $parameterCheckString .= "    if (!$parameterName.isUndefinedOrNull() && !$parameterName.isObject())\n";

  • trunk/Source/WebCore/bindings/scripts/test/V8/V8Float64Array.cpp

    r142250 r143305  
    7777        return throwNotEnoughArgumentsError(args.GetIsolate());
    7878    Float64Array* imp = V8Float64Array::toNative(args.Holder());
    79     V8TRYCATCH(Float32Array*, array, V8Float32Array::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined), args.GetIsolate()) ? V8Float32Array::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
     79    V8TRYCATCH(Float32Array*, array, V8Float32Array::HasInstance(args[0], args.GetIsolate()) ? V8Float32Array::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
    8080    return toV8(imp->foo(array), args.Holder(), args.GetIsolate());
    8181}

  • trunk/Source/WebCore/bindings/scripts/test/V8/V8TestActiveDOMObject.cpp

    r142250 r143305  
    7676    if (!BindingSecurity::shouldAllowAccessToFrame(BindingState::instance(), imp->frame()))
    7777        return v8Undefined();
    78     V8TRYCATCH(Node*, nextChild, V8Node::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined), args.GetIsolate()) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
     78    V8TRYCATCH(Node*, nextChild, V8Node::HasInstance(args[0], args.GetIsolate()) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
    7979    imp->excitingFunction(nextChild);
    8080    return v8Undefined();
    … …  
    8686        return throwNotEnoughArgumentsError(args.GetIsolate());
    8787    TestActiveDOMObject* imp = V8TestActiveDOMObject::toNative(args.Holder());
    88     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, message, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
     88    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, message, args[0]);
    8989    imp->postMessage(message);
    9090    return v8Undefined();

  • trunk/Source/WebCore/bindings/scripts/test/V8/V8TestCustomNamedGetter.cpp

    r142250 r143305  
    6767        return throwNotEnoughArgumentsError(args.GetIsolate());
    6868    TestCustomNamedGetter* imp = V8TestCustomNamedGetter::toNative(args.Holder());
    69     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
     69    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str, args[0]);
    7070    imp->anotherFunction(str);
    7171    return v8Undefined();

  • trunk/Source/WebCore/bindings/scripts/test/V8/V8TestEventTarget.cpp

    r142250 r143305  
    7373    ExceptionCode ec = 0;
    7474    {
    75     V8TRYCATCH(int, index, toUInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     75    V8TRYCATCH(int, index, toUInt32(args[0]));
    7676    if (UNLIKELY(index < 0)) {
    7777        ec = INDEX_SIZE_ERR;
    … …  
    113113    ExceptionCode ec = 0;
    114114    {
    115     V8TRYCATCH(Event*, evt, V8Event::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined), args.GetIsolate()) ? V8Event::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
     115    V8TRYCATCH(Event*, evt, V8Event::HasInstance(args[0], args.GetIsolate()) ? V8Event::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
    116116    bool result = imp->dispatchEvent(evt, ec);
    117117    if (UNLIKELY(ec))

  • trunk/Source/WebCore/bindings/scripts/test/V8/V8TestInterface.cpp

    r142849 r143305  
    190190    ExceptionCode ec = 0;
    191191    {
    192     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
    193     V8TRYCATCH(TestObj*, objArg, V8TestObj::HasInstance(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined), args.GetIsolate()) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined))) : 0);
     192    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[0]);
     193    V8TRYCATCH(TestObj*, objArg, V8TestObj::HasInstance(args[1], args.GetIsolate()) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(args[1])) : 0);
    194194    ScriptExecutionContext* scriptContext = getScriptExecutionContext();
    195195    RefPtr<TestObj> result = TestSupplemental::supplementalMethod2(scriptContext, imp, strArg, objArg, ec);
    … …  
    290290
    291291    ExceptionCode ec = 0;
    292     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str1, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
    293     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str2, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
     292    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str1, args[0]);
     293    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str2, args[1]);
    294294
    295295    ScriptExecutionContext* context = getScriptExecutionContext();

  • trunk/Source/WebCore/bindings/scripts/test/V8/V8TestMediaQueryListListener.cpp

    r142250 r143305  
    6868        return throwNotEnoughArgumentsError(args.GetIsolate());
    6969    TestMediaQueryListListener* imp = V8TestMediaQueryListListener::toNative(args.Holder());
    70     V8TRYCATCH(RefPtr<MediaQueryListListener>, listener, MediaQueryListListener::create(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     70    V8TRYCATCH(RefPtr<MediaQueryListListener>, listener, MediaQueryListListener::create(args[0]));
    7171    imp->method(listener);
    7272    return v8Undefined();

  • trunk/Source/WebCore/bindings/scripts/test/V8/V8TestNamedConstructor.cpp

    r142250 r143305  
    8484
    8585    ExceptionCode ec = 0;
    86     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str1, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
    87     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str2, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
    88     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str3, MAYBE_MISSING_PARAMETER(args, 2, DefaultIsNullString));
     86    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str1, args[0]);
     87    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str2, args[1]);
     88    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str3, argumentOrNull(args, 2));
    8989
    9090    RefPtr<TestNamedConstructor> impl = TestNamedConstructor::createForJSConstructor(document, str1, str2, str3, ec);

  • trunk/Source/WebCore/bindings/scripts/test/V8/V8TestObj.cpp

    r142849 r143305  
    998998        return throwNotEnoughArgumentsError(args.GetIsolate());
    999999    TestObj* imp = V8TestObj::toNative(args.Holder());
    1000     V8TRYCATCH(int, longArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
    1001     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
    1002     V8TRYCATCH(TestObj*, objArg, V8TestObj::HasInstance(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined), args.GetIsolate()) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined))) : 0);
     1000    V8TRYCATCH(int, longArg, toInt32(args[0]));
     1001    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[1]);
     1002    V8TRYCATCH(TestObj*, objArg, V8TestObj::HasInstance(args[2], args.GetIsolate()) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(args[2])) : 0);
    10031003    imp->voidMethodWithArgs(longArg, strArg, objArg);
    10041004    return v8Undefined();
    … …  
    10161016        return throwNotEnoughArgumentsError(args.GetIsolate());
    10171017    TestObj* imp = V8TestObj::toNative(args.Holder());
    1018     V8TRYCATCH(int, longArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
    1019     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
    1020     V8TRYCATCH(TestObj*, objArg, V8TestObj::HasInstance(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined), args.GetIsolate()) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined))) : 0);
     1018    V8TRYCATCH(int, longArg, toInt32(args[0]));
     1019    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[1]);
     1020    V8TRYCATCH(TestObj*, objArg, V8TestObj::HasInstance(args[2], args.GetIsolate()) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(args[2])) : 0);
    10211021    return v8Integer(imp->longMethodWithArgs(longArg, strArg, objArg), args.GetIsolate());
    10221022}
    … …  
    10341034        return throwNotEnoughArgumentsError(args.GetIsolate());
    10351035    TestObj* imp = V8TestObj::toNative(args.Holder());
    1036     V8TRYCATCH(int, longArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
    1037     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
    1038     V8TRYCATCH(TestObj*, objArg, V8TestObj::HasInstance(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined), args.GetIsolate()) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined))) : 0);
     1036    V8TRYCATCH(int, longArg, toInt32(args[0]));
     1037    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[1]);
     1038    V8TRYCATCH(TestObj*, objArg, V8TestObj::HasInstance(args[2], args.GetIsolate()) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(args[2])) : 0);
    10391039    return toV8(imp->objMethodWithArgs(longArg, strArg, objArg), args.Holder(), args.GetIsolate());
    10401040}
    … …  
    10451045        return throwNotEnoughArgumentsError(args.GetIsolate());
    10461046    TestObj* imp = V8TestObj::toNative(args.Holder());
    1047     V8TRYCATCH(Vector<RefPtr<ScriptProfile> >, sequenceArg, (toRefPtrNativeArray<ScriptProfile, V8ScriptProfile>(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined), args.GetIsolate())));
     1047    V8TRYCATCH(Vector<RefPtr<ScriptProfile> >, sequenceArg, (toRefPtrNativeArray<ScriptProfile, V8ScriptProfile>(args[0], args.GetIsolate())));
    10481048    imp->methodWithSequenceArg(sequenceArg);
    10491049    return v8Undefined();
    … …  
    10551055        return throwNotEnoughArgumentsError(args.GetIsolate());
    10561056    TestObj* imp = V8TestObj::toNative(args.Holder());
    1057     V8TRYCATCH(int, longArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1057    V8TRYCATCH(int, longArg, toInt32(args[0]));
    10581058    return v8Array(imp->methodReturningSequence(longArg), args.GetIsolate());
    10591059}
    … …  
    10661066    ExceptionCode ec = 0;
    10671067    {
    1068     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
    1069     V8TRYCATCH(TestObj*, objArg, V8TestObj::HasInstance(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined), args.GetIsolate()) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined))) : 0);
     1068    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[0]);
     1069    V8TRYCATCH(TestObj*, objArg, V8TestObj::HasInstance(args[1], args.GetIsolate()) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(args[1])) : 0);
    10701070    RefPtr<TestObj> result = imp->methodThatRequiresAllArgsAndThrows(strArg, objArg, ec);
    10711071    if (UNLIKELY(ec))
    … …  
    10951095        return throwNotEnoughArgumentsError(args.GetIsolate());
    10961096    TestObj* imp = V8TestObj::toNative(args.Holder());
    1097     V8TRYCATCH(Dictionary, oo, Dictionary(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined), args.GetIsolate()));
     1097    V8TRYCATCH(Dictionary, oo, Dictionary(args[0], args.GetIsolate()));
    10981098    if (!oo.isUndefinedOrNull() && !oo.isObject())
    10991099        return throwTypeError("Not an object.", args.GetIsolate());
    1100     V8TRYCATCH(Dictionary, ooo, Dictionary(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined), args.GetIsolate()));
     1100    V8TRYCATCH(Dictionary, ooo, Dictionary(args[1], args.GetIsolate()));
    11011101    if (!ooo.isUndefinedOrNull() && !ooo.isObject())
    11021102        return throwTypeError("Not an object.", args.GetIsolate());
    … …  
    13111311        return v8Undefined();
    13121312    }
    1313     V8TRYCATCH(int, opt, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1313    V8TRYCATCH(int, opt, toInt32(args[0]));
    13141314    imp->methodWithOptionalArg(opt);
    13151315    return v8Undefined();
    … …  
    13211321        return throwNotEnoughArgumentsError(args.GetIsolate());
    13221322    TestObj* imp = V8TestObj::toNative(args.Holder());
    1323     V8TRYCATCH(int, nonOpt, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1323    V8TRYCATCH(int, nonOpt, toInt32(args[0]));
    13241324    if (args.Length() <= 1) {
    13251325        imp->methodWithNonOptionalArgAndOptionalArg(nonOpt);
    13261326        return v8Undefined();
    13271327    }
    1328     V8TRYCATCH(int, opt, toInt32(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined)));
     1328    V8TRYCATCH(int, opt, toInt32(args[1]));
    13291329    imp->methodWithNonOptionalArgAndOptionalArg(nonOpt, opt);
    13301330    return v8Undefined();
    … …  
    13361336        return throwNotEnoughArgumentsError(args.GetIsolate());
    13371337    TestObj* imp = V8TestObj::toNative(args.Holder());
    1338     V8TRYCATCH(int, nonOpt, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1338    V8TRYCATCH(int, nonOpt, toInt32(args[0]));
    13391339    if (args.Length() <= 1) {
    13401340        imp->methodWithNonOptionalArgAndTwoOptionalArgs(nonOpt);
    13411341        return v8Undefined();
    13421342    }
    1343     V8TRYCATCH(int, opt1, toInt32(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined)));
     1343    V8TRYCATCH(int, opt1, toInt32(args[1]));
    13441344    if (args.Length() <= 2) {
    13451345        imp->methodWithNonOptionalArgAndTwoOptionalArgs(nonOpt, opt1);
    13461346        return v8Undefined();
    13471347    }
    1348     V8TRYCATCH(int, opt2, toInt32(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined)));
     1348    V8TRYCATCH(int, opt2, toInt32(args[2]));
    13491349    imp->methodWithNonOptionalArgAndTwoOptionalArgs(nonOpt, opt1, opt2);
    13501350    return v8Undefined();
    … …  
    13581358        return v8Undefined();
    13591359    }
    1360     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
     1360    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str, args[0]);
    13611361    imp->methodWithOptionalString(str);
    13621362    return v8Undefined();
    … …  
    13661366{
    13671367    TestObj* imp = V8TestObj::toNative(args.Holder());
    1368     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
     1368    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str, args[0]);
    13691369    imp->methodWithOptionalStringIsUndefined(str);
    13701370    return v8Undefined();
    … …  
    13741374{
    13751375    TestObj* imp = V8TestObj::toNative(args.Holder());
    1376     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsNullString));
     1376    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str, argumentOrNull(args, 0));
    13771377    imp->methodWithOptionalStringIsNullString(str);
    13781378    return v8Undefined();
    … …  
    13961396        return throwNotEnoughArgumentsError(args.GetIsolate());
    13971397    TestObj* imp = V8TestObj::toNative(args.Holder());
    1398     V8TRYCATCH(int, nonCallback, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1398    V8TRYCATCH(int, nonCallback, toInt32(args[0]));
    13991399    if (args.Length() <= 1 || !args[1]->IsFunction())
    14001400        return throwTypeError(0, args.GetIsolate());
    … …  
    14541454        return throwNotEnoughArgumentsError(args.GetIsolate());
    14551455    TestObj* imp = V8TestObj::toNative(args.Holder());
    1456     V8TRYCATCH(TestObj*, objArg, V8TestObj::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined), args.GetIsolate()) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
    1457     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
     1456    V8TRYCATCH(TestObj*, objArg, V8TestObj::HasInstance(args[0], args.GetIsolate()) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
     1457    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[1]);
    14581458    imp->overloadedMethod(objArg, strArg);
    14591459    return v8Undefined();
    … …  
    14651465        return throwNotEnoughArgumentsError(args.GetIsolate());
    14661466    TestObj* imp = V8TestObj::toNative(args.Holder());
    1467     V8TRYCATCH(TestObj*, objArg, V8TestObj::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined), args.GetIsolate()) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
     1467    V8TRYCATCH(TestObj*, objArg, V8TestObj::HasInstance(args[0], args.GetIsolate()) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
    14681468    if (args.Length() <= 1) {
    14691469        imp->overloadedMethod(objArg);
    14701470        return v8Undefined();
    14711471    }
    1472     V8TRYCATCH(int, longArg, toInt32(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined)));
     1472    V8TRYCATCH(int, longArg, toInt32(args[1]));
    14731473    imp->overloadedMethod(objArg, longArg);
    14741474    return v8Undefined();
    … …  
    14801480        return throwNotEnoughArgumentsError(args.GetIsolate());
    14811481    TestObj* imp = V8TestObj::toNative(args.Holder());
    1482     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
     1482    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[0]);
    14831483    imp->overloadedMethod(strArg);
    14841484    return v8Undefined();
    … …  
    14901490        return throwNotEnoughArgumentsError(args.GetIsolate());
    14911491    TestObj* imp = V8TestObj::toNative(args.Holder());
    1492     V8TRYCATCH(int, longArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1492    V8TRYCATCH(int, longArg, toInt32(args[0]));
    14931493    imp->overloadedMethod(longArg);
    14941494    return v8Undefined();
    … …  
    15121512        return throwNotEnoughArgumentsError(args.GetIsolate());
    15131513    TestObj* imp = V8TestObj::toNative(args.Holder());
    1514     V8TRYCATCH(RefPtr<DOMStringList>, listArg, toDOMStringList(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined), args.GetIsolate()));
     1514    V8TRYCATCH(RefPtr<DOMStringList>, listArg, toDOMStringList(args[0], args.GetIsolate()));
    15151515    imp->overloadedMethod(listArg);
    15161516    return v8Undefined();
    … …  
    15221522        return throwNotEnoughArgumentsError(args.GetIsolate());
    15231523    TestObj* imp = V8TestObj::toNative(args.Holder());
    1524     V8TRYCATCH(Vector<String>, arrayArg, toNativeArray<String>(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1524    V8TRYCATCH(Vector<String>, arrayArg, toNativeArray<String>(args[0]));
    15251525    imp->overloadedMethod(arrayArg);
    15261526    return v8Undefined();
    … …  
    15321532        return throwNotEnoughArgumentsError(args.GetIsolate());
    15331533    TestObj* imp = V8TestObj::toNative(args.Holder());
    1534     V8TRYCATCH(TestObj*, objArg, V8TestObj::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined), args.GetIsolate()) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
     1534    V8TRYCATCH(TestObj*, objArg, V8TestObj::HasInstance(args[0], args.GetIsolate()) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
    15351535    imp->overloadedMethod(objArg);
    15361536    return v8Undefined();
    … …  
    15421542        return throwNotEnoughArgumentsError(args.GetIsolate());
    15431543    TestObj* imp = V8TestObj::toNative(args.Holder());
    1544     V8TRYCATCH(Vector<String>, arrayArg, toNativeArray<String>(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1544    V8TRYCATCH(Vector<String>, arrayArg, toNativeArray<String>(args[0]));
    15451545    imp->overloadedMethod(arrayArg);
    15461546    return v8Undefined();
    … …  
    15521552        return throwNotEnoughArgumentsError(args.GetIsolate());
    15531553    TestObj* imp = V8TestObj::toNative(args.Holder());
    1554     V8TRYCATCH(Vector<unsigned>, arrayArg, toNativeArray<unsigned>(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1554    V8TRYCATCH(Vector<unsigned>, arrayArg, toNativeArray<unsigned>(args[0]));
    15551555    imp->overloadedMethod(arrayArg);
    15561556    return v8Undefined();
    … …  
    15621562        return throwNotEnoughArgumentsError(args.GetIsolate());
    15631563    TestObj* imp = V8TestObj::toNative(args.Holder());
    1564     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
     1564    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[0]);
    15651565    imp->overloadedMethod(strArg);
    15661566    return v8Undefined();
    … …  
    16071607        return v8Integer(TestObj::classMethodWithOptional(), args.GetIsolate());
    16081608    }
    1609     V8TRYCATCH(int, arg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1609    V8TRYCATCH(int, arg, toInt32(args[0]));
    16101610    return v8Integer(TestObj::classMethodWithOptional(arg), args.GetIsolate());
    16111611}
    … …  
    16221622    if (args.Length() < 1)
    16231623        return throwNotEnoughArgumentsError(args.GetIsolate());
    1624     V8TRYCATCH(int, arg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1624    V8TRYCATCH(int, arg, toInt32(args[0]));
    16251625    TestObj::overloadedMethod1(arg);
    16261626    return v8Undefined();
    … …  
    16351635    if (args.Length() < 1)
    16361636        return throwNotEnoughArgumentsError(args.GetIsolate());
    1637     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, type, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
     1637    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, type, args[0]);
    16381638    TestObj::overloadedMethod1(type);
    16391639    return v8Undefined();
    … …  
    16791679        return throwNotEnoughArgumentsError(args.GetIsolate());
    16801680    TestObj* imp = V8TestObj::toNative(args.Holder());
    1681     V8TRYCATCH(int, longArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1681    V8TRYCATCH(int, longArg, toInt32(args[0]));
    16821682    imp->enabledAtRuntimeMethod1(longArg);
    16831683    return v8Undefined();
    … …  
    16891689        return throwNotEnoughArgumentsError(args.GetIsolate());
    16901690    TestObj* imp = V8TestObj::toNative(args.Holder());
    1691     V8TRYCATCH(int, longArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1691    V8TRYCATCH(int, longArg, toInt32(args[0]));
    16921692    imp->enabledAtRuntimeMethod2(longArg);
    16931693    return v8Undefined();
    … …  
    16991699        return throwNotEnoughArgumentsError(args.GetIsolate());
    17001700    TestObj* imp = V8TestObj::toNative(args.Holder());
    1701     V8TRYCATCH(int, longArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1701    V8TRYCATCH(int, longArg, toInt32(args[0]));
    17021702    imp->enabledPerContextMethod1(longArg);
    17031703    return v8Undefined();
    … …  
    17091709        return throwNotEnoughArgumentsError(args.GetIsolate());
    17101710    TestObj* imp = V8TestObj::toNative(args.Holder());
    1711     V8TRYCATCH(int, longArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1711    V8TRYCATCH(int, longArg, toInt32(args[0]));
    17121712    imp->enabledPerContextMethod2(longArg);
    17131713    return v8Undefined();
    … …  
    17211721    ExceptionCode ec = 0;
    17221722    {
    1723     V8TRYCATCH(Vector<String>, values, toNativeArray<String>(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1723    V8TRYCATCH(Vector<String>, values, toNativeArray<String>(args[0]));
    17241724    Vector<String> result = imp->stringArrayFunction(values, ec);
    17251725    if (UNLIKELY(ec))
    … …  
    17381738    ExceptionCode ec = 0;
    17391739    {
    1740     V8TRYCATCH(RefPtr<DOMStringList>, values, toDOMStringList(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined), args.GetIsolate()));
     1740    V8TRYCATCH(RefPtr<DOMStringList>, values, toDOMStringList(args[0], args.GetIsolate()));
    17411741    RefPtr<DOMStringList> result = imp->domStringListFunction(values, ec);
    17421742    if (UNLIKELY(ec))
    … …  
    17691769        return throwNotEnoughArgumentsError(args.GetIsolate());
    17701770    TestObj* imp = V8TestObj::toNative(args.Holder());
    1771     V8TRYCATCH(a*, value, V8a::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined), args.GetIsolate()) ? V8a::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
     1771    V8TRYCATCH(a*, value, V8a::HasInstance(args[0], args.GetIsolate()) ? V8a::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
    17721772    imp->convert1(value);
    17731773    return v8Undefined();
    … …  
    17791779        return throwNotEnoughArgumentsError(args.GetIsolate());
    17801780    TestObj* imp = V8TestObj::toNative(args.Holder());
    1781     V8TRYCATCH(b*, value, V8b::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined), args.GetIsolate()) ? V8b::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
     1781    V8TRYCATCH(b*, value, V8b::HasInstance(args[0], args.GetIsolate()) ? V8b::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
    17821782    imp->convert2(value);
    17831783    return v8Undefined();
    … …  
    17891789        return throwNotEnoughArgumentsError(args.GetIsolate());
    17901790    TestObj* imp = V8TestObj::toNative(args.Holder());
    1791     V8TRYCATCH(d*, value, V8d::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined), args.GetIsolate()) ? V8d::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
     1791    V8TRYCATCH(d*, value, V8d::HasInstance(args[0], args.GetIsolate()) ? V8d::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
    17921792    imp->convert4(value);
    17931793    return v8Undefined();
    … …  
    17991799        return throwNotEnoughArgumentsError(args.GetIsolate());
    18001800    TestObj* imp = V8TestObj::toNative(args.Holder());
    1801     V8TRYCATCH(e*, value, V8e::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined), args.GetIsolate()) ? V8e::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
     1801    V8TRYCATCH(e*, value, V8e::HasInstance(args[0], args.GetIsolate()) ? V8e::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
    18021802    imp->convert5(value);
    18031803    return v8Undefined();
    … …  
    18301830    ExceptionCode ec = 0;
    18311831    {
    1832     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
    1833     V8TRYCATCH(float, a, static_cast<float>(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined)->NumberValue()));
    1834     V8TRYCATCH(int, b, toInt32(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined)));
     1832    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str, args[0]);
     1833    V8TRYCATCH(float, a, static_cast<float>(args[1]->NumberValue()));
     1834    V8TRYCATCH(int, b, toInt32(args[2]));
    18351835    RefPtr<bool> result = imp->strictFunction(str, a, b, ec);
    18361836    if (UNLIKELY(ec))
    … …  
    18471847        return throwNotEnoughArgumentsError(args.GetIsolate());
    18481848    TestObj* imp = V8TestObj::toNative(args.Holder());
    1849     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, head, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
     1849    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, head, args[0]);
    18501850    V8TRYCATCH(Vector<String>, tail, toNativeArguments<String>(args, 1));
    18511851    imp->variadicStringMethod(head, tail);
    … …  
    18581858        return throwNotEnoughArgumentsError(args.GetIsolate());
    18591859    TestObj* imp = V8TestObj::toNative(args.Holder());
    1860     V8TRYCATCH(double, head, static_cast<double>(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)->NumberValue()));
     1860    V8TRYCATCH(double, head, static_cast<double>(args[0]->NumberValue()));
    18611861    V8TRYCATCH(Vector<double>, tail, toNativeArguments<double>(args, 1));
    18621862    imp->variadicDoubleMethod(head, tail);
    … …  
    18691869        return throwNotEnoughArgumentsError(args.GetIsolate());
    18701870    TestObj* imp = V8TestObj::toNative(args.Holder());
    1871     V8TRYCATCH(Node*, head, V8Node::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined), args.GetIsolate()) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
     1871    V8TRYCATCH(Node*, head, V8Node::HasInstance(args[0], args.GetIsolate()) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
    18721872    Vector<RefPtr<Node> > tail;
    18731873    for (int i = 1; i < args.Length(); ++i) {

  • trunk/Source/WebCore/bindings/scripts/test/V8/V8TestOverloadedConstructors.cpp

    r142250 r143305  
    7272{
    7373   
    74     V8TRYCATCH(ArrayBuffer*, arrayBuffer, V8ArrayBuffer::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined), args.GetIsolate()) ? V8ArrayBuffer::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
     74    V8TRYCATCH(ArrayBuffer*, arrayBuffer, V8ArrayBuffer::HasInstance(args[0], args.GetIsolate()) ? V8ArrayBuffer::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
    7575
    7676    RefPtr<TestOverloadedConstructors> impl = TestOverloadedConstructors::create(arrayBuffer);
    … …  
    8484{
    8585   
    86     V8TRYCATCH(ArrayBufferView*, arrayBufferView, V8ArrayBufferView::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined), args.GetIsolate()) ? V8ArrayBufferView::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
     86    V8TRYCATCH(ArrayBufferView*, arrayBufferView, V8ArrayBufferView::HasInstance(args[0], args.GetIsolate()) ? V8ArrayBufferView::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
    8787
    8888    RefPtr<TestOverloadedConstructors> impl = TestOverloadedConstructors::create(arrayBufferView);
    … …  
    9696{
    9797   
    98     V8TRYCATCH(Blob*, blob, V8Blob::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined), args.GetIsolate()) ? V8Blob::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
     98    V8TRYCATCH(Blob*, blob, V8Blob::HasInstance(args[0], args.GetIsolate()) ? V8Blob::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
    9999
    100100    RefPtr<TestOverloadedConstructors> impl = TestOverloadedConstructors::create(blob);
    … …  
    108108{
    109109   
    110     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, string, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
     110    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, string, args[0]);
    111111
    112112    RefPtr<TestOverloadedConstructors> impl = TestOverloadedConstructors::create(string);

  • trunk/Source/WebCore/bindings/scripts/test/V8/V8TestSerializedScriptValueInterface.cpp

    r142250 r143305  
    231231    if (args.Length() < 2)
    232232        return throwNotEnoughArgumentsError(args.GetIsolate());
    233     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, hello, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
     233    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, hello, args[0]);
    234234    MessagePortArray messagePortArrayTransferList;
    235235    ArrayBufferArray arrayBufferArrayTransferList;

  • trunk/Source/WebCore/bindings/scripts/test/V8/V8TestTypedefs.cpp

    r142951 r143305  
    193193    if (args.Length() > 0 && !isUndefinedOrNull(args[0]) && !V8long[]::HasInstance(args[0], args.GetIsolate()))
    194194        return throwTypeError(0, args.GetIsolate());
    195     V8TRYCATCH(Vector<int>, x, toNativeArray<int>(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     195    V8TRYCATCH(Vector<int>, x, toNativeArray<int>(args[0]));
    196196    imp->func(x);
    197197    return v8Undefined();
    … …  
    244244        return throwNotEnoughArgumentsError(args.GetIsolate());
    245245    TestTypedefs* imp = V8TestTypedefs::toNative(args.Holder());
    246     V8TRYCATCH(float, width, static_cast<float>(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)->NumberValue()));
    247     V8TRYCATCH(float, height, static_cast<float>(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined)->NumberValue()));
    248     V8TRYCATCH(float, blur, static_cast<float>(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined)->NumberValue()));
     246    V8TRYCATCH(float, width, static_cast<float>(args[0]->NumberValue()));
     247    V8TRYCATCH(float, height, static_cast<float>(args[1]->NumberValue()));
     248    V8TRYCATCH(float, blur, static_cast<float>(args[2]->NumberValue()));
    249249    if (args.Length() <= 3) {
    250250        imp->setShadow(width, height, blur);
    251251        return v8Undefined();
    252252    }
    253     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, color, MAYBE_MISSING_PARAMETER(args, 3, DefaultIsUndefined));
     253    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, color, args[3]);
    254254    if (args.Length() <= 4) {
    255255        imp->setShadow(width, height, blur, color);
    256256        return v8Undefined();
    257257    }
    258     V8TRYCATCH(float, alpha, static_cast<float>(MAYBE_MISSING_PARAMETER(args, 4, DefaultIsUndefined)->NumberValue()));
     258    V8TRYCATCH(float, alpha, static_cast<float>(args[4]->NumberValue()));
    259259    imp->setShadow(width, height, blur, color, alpha);
    260260    return v8Undefined();
    … …  
    266266        return throwNotEnoughArgumentsError(args.GetIsolate());
    267267    TestTypedefs* imp = V8TestTypedefs::toNative(args.Holder());
    268     V8TRYCATCH(Vector<RefPtr<SerializedScriptValue> >, sequenceArg, (toRefPtrNativeArray<SerializedScriptValue, V8SerializedScriptValue>(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined), args.GetIsolate())));
     268    V8TRYCATCH(Vector<RefPtr<SerializedScriptValue> >, sequenceArg, (toRefPtrNativeArray<SerializedScriptValue, V8SerializedScriptValue>(args[0], args.GetIsolate())));
    269269    return v8::Number::New(static_cast<double>(imp->methodWithSequenceArg(sequenceArg)));
    270270}
    … …  
    275275        return throwNotEnoughArgumentsError(args.GetIsolate());
    276276    TestTypedefs* imp = V8TestTypedefs::toNative(args.Holder());
    277     V8TRYCATCH(Vector<String>, arrayArg, toNativeArray<String>(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     277    V8TRYCATCH(Vector<String>, arrayArg, toNativeArray<String>(args[0]));
    278278    imp->nullableArrayArg(arrayArg);
    279279    return v8Undefined();
    … …  
    314314    ExceptionCode ec = 0;
    315315    {
    316     V8TRYCATCH(Vector<String>, values, toNativeArray<String>(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     316    V8TRYCATCH(Vector<String>, values, toNativeArray<String>(args[0]));
    317317    Vector<String> result = imp->stringArrayFunction(values, ec);
    318318    if (UNLIKELY(ec))
    … …  
    331331    ExceptionCode ec = 0;
    332332    {
    333     V8TRYCATCH(Vector<String>, values, toNativeArray<String>(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     333    V8TRYCATCH(Vector<String>, values, toNativeArray<String>(args[0]));
    334334    Vector<String> result = imp->stringArrayFunction2(values, ec);
    335335    if (UNLIKELY(ec))
    … …  
    393393    if (args.Length() < 2)
    394394        return throwNotEnoughArgumentsError(args.GetIsolate());
    395     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, hello, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
     395    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, hello, args[0]);
    396396    if (args.Length() <= 1 || !args[1]->IsFunction())
    397397        return throwTypeError(0, args.GetIsolate());

  • trunk/Source/WebCore/bindings/v8/V8Binding.h

    r143232 r143305  
    7474    v8::Handle<v8::Value> throwNotEnoughArgumentsError(v8::Isolate*);
    7575
     76    inline v8::Handle<v8::Value> argumentOrNull(const v8::Arguments& args, int index)
     77    {
     78        return index >= args.Length() ? v8::Local<v8::Value>() : args[index];
     79    }
     80
    7681    // A fast accessor for v8::Null(isolate). isolate must not be 0.
    7782    // If isolate can be 0, use v8NullWithCheck().

  • trunk/Source/WebCore/bindings/v8/V8BindingMacros.h

    r138665 r143305  
    3434namespace WebCore {
    3535
    36 enum ParameterDefaultPolicy {
    37     DefaultIsUndefined,
    38     DefaultIsNullString
    39 };
    40 
    4136#define V8TRYCATCH(type, var, value) \
    4237    type var;                             \
    … …  
    5853        return;
    5954
    60 #define MAYBE_MISSING_PARAMETER(args, index, policy) \
    61     (((policy) == DefaultIsNullString && (index) >= (args).Length()) ? (v8::Local<v8::Value>()) : ((args)[(index)]))
    62 
    6355} // namespace WebCore
    6456

  • trunk/Source/WebCore/bindings/v8/custom/V8HistoryCustom.cpp

    r142849 r143305  
    6666
    6767    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<WithUndefinedOrNullCheck>, title, args[1]);
    68     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<WithUndefinedOrNullCheck>, url, MAYBE_MISSING_PARAMETER(args, 2, DefaultIsNullString));
     68    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<WithUndefinedOrNullCheck>, url, argumentOrNull(args, 2));
    6969
    7070    ExceptionCode ec = 0;
    … …  
    8383
    8484    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<WithUndefinedOrNullCheck>, title, args[1]);
    85     V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<WithUndefinedOrNullCheck>, url, MAYBE_MISSING_PARAMETER(args, 2, DefaultIsNullString));
     85    V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<WithUndefinedOrNullCheck>, url, argumentOrNull(args, 2));
    8686
    8787    ExceptionCode ec = 0;
Note: See TracChangeset for help on using the changeset viewer.