Changeset 202328 in webkit


Ignore:
Timestamp:
Jun 22, 2016 1:59:31 AM (8 years ago)
Author:
Carlos Garcia Campos
Message:

[GTK] Add support for variadic parameters to GObject DOM bindings
https://bugs.webkit.org/show_bug.cgi?id=158942

Reviewed by Michael Catanzaro.

Generate code for functions having variadic parameters.

  • bindings/scripts/CodeGeneratorGObject.pm:

(GenerateFunction):
(SkipFunction):

  • bindings/scripts/test/GObject/WebKitDOMTestObj.cpp:

(webkit_dom_test_obj_variadic_string_method):

  • bindings/scripts/test/GObject/WebKitDOMTestObj.h:
Location:
trunk/Source/WebCore
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r202324 r202328  
     12016-06-22  Carlos Garcia Campos  <cgarcia@igalia.com>
     2
     3        [GTK] Add support for variadic parameters to GObject DOM bindings
     4        https://bugs.webkit.org/show_bug.cgi?id=158942
     5
     6        Reviewed by Michael Catanzaro.
     7
     8        Generate code for functions having variadic parameters.
     9
     10        * bindings/scripts/CodeGeneratorGObject.pm:
     11        (GenerateFunction):
     12        (SkipFunction):
     13        * bindings/scripts/test/GObject/WebKitDOMTestObj.cpp:
     14        (webkit_dom_test_obj_variadic_string_method):
     15        * bindings/scripts/test/GObject/WebKitDOMTestObj.h:
     16
    1172016-06-21  Benjamin Poulain  <bpoulain@apple.com>
    218
  • trunk/Source/WebCore/bindings/scripts/CodeGeneratorGObject.pm

    r202275 r202328  
    321321    # sequence<T> parameters, because this code generator doesn't know how to auto-generate
    322322    # MediaQueryListListener or sequence<T>. Skip EventListeners because they are handled elsewhere.
    323     # Skip functions that have variadic parameters because not supported yet.
    324323    foreach my $param (@{$function->parameters}) {
    325324        return 1 if $codeGenerator->IsFunctionOnlyCallbackInterface($param->type);
     
    328327        return 1 if $param->type eq "EventListener";
    329328        return 1 if $codeGenerator->GetSequenceType($param->type);
    330         return 1 if $param->isVariadic;
    331329    }
    332330
     
    10911089    my $symbolSig = "${className}*";
    10921090
     1091    my $hasVariadic = 0;
    10931092    my @callImplParams;
    10941093    foreach my $param (@{$function->parameters}) {
     
    11001099        my $paramName = $param->name;
    11011100
    1102         $functionSig .= ", ${const}$paramType $paramName";
    1103         $symbolSig .= ", ${const}$paramType";
     1101        if ($param->isVariadic) {
     1102            $hasVariadic = 1;
     1103        } else {
     1104            $functionSig .= ", ${const}$paramType $paramName";
     1105            $symbolSig .= ", ${const}$paramType";
     1106        }
    11041107
    11051108        my $paramIsGDOMType = IsGDOMClassType($paramIDLType);
     
    11091112            }
    11101113        }
    1111         if ($paramIsGDOMType || ($paramIDLType eq "DOMString")) {
     1114        if ($paramIsGDOMType || ($paramIDLType eq "DOMString") || $param->isVariadic) {
    11121115            $paramName = "converted" . $codeGenerator->WK_ucfirst($paramName);
    11131116            $paramName = "*$paramName" if $codeGenerator->ShouldPassWrapperByReference($param, $parentNode);
     1117            $paramName = "WTFMove($paramName)" if $param->isVariadic;
    11141118        }
    11151119        if ($paramIDLType eq "NodeFilter" || $paramIDLType eq "XPathNSResolver") {
     
    11291133    $functionSig .= ", GError** error" if $raisesException || $usedToRaiseException;
    11301134    $symbolSig .= ", GError**" if $raisesException || $usedToRaiseException;
     1135
     1136    if ($hasVariadic) {
     1137        my $param = @{$function->parameters}[-1];
     1138        if ($codeGenerator->IsNonPointerType($param->type)) {
     1139            my $paramName = $param->name;
     1140            $functionSig .= ", guint n_$paramName";
     1141            $symbolSig .= ", guint";
     1142        }
     1143        $functionSig .= ", ...";
     1144        $symbolSig .= ", ...";
     1145    }
    11311146
    11321147    my $symbol = "$returnType $functionName($symbolSig)";
     
    11461161
    11471162    foreach my $param (@{$function->parameters}) {
     1163        if ($param->isVariadic) {
     1164            last;
     1165        }
    11481166        my $paramIDLType = $param->type;
    11491167        my $arrayOrSequenceType = $codeGenerator->GetArrayOrSequenceType($paramIDLType);
     
    11601178    }
    11611179    push(@functionHeader, " * \@error: #GError") if $raisesException || $usedToRaiseException;
     1180    if ($hasVariadic) {
     1181        my $param = @{$function->parameters}[-1];
     1182        my $paramName = $param->name;
     1183        my $paramType = GetGlibTypeName($param->type);
     1184        $paramType =~ s/\*$//;
     1185        if ($codeGenerator->IsNonPointerType($param->type)) {
     1186            push(@functionHeader, " * \@n_${paramName}: number of ${paramName} that will be passed");
     1187            push(@functionHeader, " * \@...: list of #${paramType}");
     1188        } else {
     1189            push(@functionHeader, " * \@...: list of #${paramType} ended by %NULL.");
     1190        }
     1191    }
    11621192    push(@functionHeader, " *");
    11631193    my $returnTypeName = $returnType;
     
    12071237        my $paramIDLType = $param->type;
    12081238        my $paramTypeIsPointer = !$codeGenerator->IsNonPointerType($paramIDLType);
    1209         if ($paramTypeIsPointer) {
     1239        if ($paramTypeIsPointer && !$param->isVariadic) {
    12101240            $gReturnMacro = GetGReturnMacro($paramName, $paramIDLType, $returnType, $functionName);
    12111241            push(@cBody, $gReturnMacro);
     
    12241254
    12251255    $returnParamName = "";
     1256    my $currentParameterIndex = 0;
    12261257    foreach my $param (@{$function->parameters}) {
    12271258        my $paramIDLType = $param->type;
    12281259        my $paramName = $param->name;
    1229 
     1260        my $paramType = GetGlibTypeName($paramIDLType);
    12301261        my $paramIsGDOMType = IsGDOMClassType($paramIDLType);
    1231         $convertedParamName = "converted" . $codeGenerator->WK_ucfirst($paramName);
     1262        my $paramTypeIsPointer = !$codeGenerator->IsNonPointerType($paramIDLType);
     1263        my $convertedParamName = "converted" . $codeGenerator->WK_ucfirst($paramName);
     1264
     1265        my $paramCoreType = $paramType;
     1266        my $paramConversionFunction = "";
    12321267        if ($paramIDLType eq "DOMString") {
    1233             push(@cBody, "    WTF::String ${convertedParamName} = WTF::String::fromUTF8($paramName);\n");
     1268            $paramCoreType = "WTF::String";
     1269            $paramConversionFunction = "WTF::String::fromUTF8";
    12341270        } elsif ($paramIDLType eq "NodeFilter" || $paramIDLType eq "XPathNSResolver") {
    1235             push(@cBody, "    RefPtr<WebCore::$paramIDLType> ${convertedParamName} = WebKit::core($paramName);\n");
     1271            $paramCoreType = "RefPtr<WebCore::$paramIDLType>";
     1272            $paramConversionFunction = "WebKit::core"
    12361273        } elsif ($paramIsGDOMType) {
    1237             push(@cBody, "    WebCore::${paramIDLType}* ${convertedParamName} = WebKit::core($paramName);\n");
     1274            $paramCoreType = "WebCore::${paramIDLType}*";
     1275            $paramConversionFunction = "WebKit::core"
     1276        }
     1277
     1278        if ($param->isVariadic) {
     1279            my $previousParamName;
     1280            if ($raisesException) {
     1281                $previousParamName = "error";
     1282            } elsif ($currentParameterIndex == 0) {
     1283                $previousParamName = "self";
     1284            } else {
     1285                $previousParamName = @{$function->parameters}[$currentParameterIndex - 1]->name;
     1286            }
     1287            push(@cBody, "    va_list variadicParameterList;\n");
     1288            push(@cBody, "    Vector<$paramCoreType> $convertedParamName;\n");
     1289            push(@cBody, "    va_start(variadicParameterList, $previousParamName);\n");
     1290            if ($paramTypeIsPointer) {
     1291                push(@cBody, "    while ($paramType variadicParameter = va_arg(variadicParameterList, $paramType))\n");
     1292                push(@cBody, "        ${convertedParamName}.append(${paramConversionFunction}(variadicParameter));\n");
     1293            } else {
     1294                push(@cBody, "    ${convertedParamName}.reserveInitialCapacity(n_$paramName);\n");
     1295                push(@cBody, "    for (unsigned i = 0; i < n_$paramName; ++i) {\n");
     1296                push(@cBody, "        ${convertedParamName}.uncheckedAppend(va_arg(variadicParameterList, $paramType));\n");
     1297            }
     1298            push(@cBody, "    va_end(variadicParameterList);\n");
     1299        } elsif ($paramCoreType ne $paramType) {
     1300            push(@cBody, "    $paramCoreType $convertedParamName = ${paramConversionFunction}($paramName);\n");
    12381301        }
    12391302        $returnParamName = $convertedParamName if $param->extendedAttributes->{"CustomReturn"};
     1303        $currentParameterIndex++;
    12401304    }
    12411305
  • trunk/Source/WebCore/bindings/scripts/test/GObject/WebKitDOMTestObj.cpp

    r202275 r202328  
    3232#include "WebKitDOMDictionaryPrivate.h"
    3333#include "WebKitDOMDocumentPrivate.h"
     34#include "WebKitDOMNodePrivate.h"
    3435#include "WebKitDOMPrivate.h"
    3536#include "WebKitDOMSVGPointPrivate.h"
     
    20032004}
    20042005
     2006void webkit_dom_test_obj_variadic_string_method(WebKitDOMTestObj* self, const gchar* head, ...)
     2007{
     2008    WebCore::JSMainThreadNullState state;
     2009    g_return_if_fail(WEBKIT_DOM_IS_TEST_OBJ(self));
     2010    g_return_if_fail(head);
     2011    WebCore::TestObj* item = WebKit::core(self);
     2012    WTF::String convertedHead = WTF::String::fromUTF8(head);
     2013    va_list variadicParameterList;
     2014    Vector<WTF::String> convertedTail;
     2015    va_start(variadicParameterList, head);
     2016    while (gchar* variadicParameter = va_arg(variadicParameterList, gchar*))
     2017        convertedTail.append(WTF::String::fromUTF8(variadicParameter));
     2018    va_end(variadicParameterList);
     2019    item->variadicStringMethod(convertedHead, WTFMove(convertedTail));
     2020}
     2021
     2022void webkit_dom_test_obj_variadic_double_method(WebKitDOMTestObj* self, gdouble head, guint n_tail, ...)
     2023{
     2024    WebCore::JSMainThreadNullState state;
     2025    g_return_if_fail(WEBKIT_DOM_IS_TEST_OBJ(self));
     2026    WebCore::TestObj* item = WebKit::core(self);
     2027    va_list variadicParameterList;
     2028    Vector<gdouble> convertedTail;
     2029    va_start(variadicParameterList, head);
     2030    convertedTail.reserveInitialCapacity(n_tail);
     2031    for (unsigned i = 0; i < n_tail; ++i) {
     2032        convertedTail.uncheckedAppend(va_arg(variadicParameterList, gdouble));
     2033    va_end(variadicParameterList);
     2034    item->variadicDoubleMethod(head, WTFMove(convertedTail));
     2035}
     2036
     2037void webkit_dom_test_obj_variadic_node_method(WebKitDOMTestObj* self, WebKitDOMNode* head, ...)
     2038{
     2039    WebCore::JSMainThreadNullState state;
     2040    g_return_if_fail(WEBKIT_DOM_IS_TEST_OBJ(self));
     2041    g_return_if_fail(WEBKIT_DOM_IS_NODE(head));
     2042    WebCore::TestObj* item = WebKit::core(self);
     2043    WebCore::Node* convertedHead = WebKit::core(head);
     2044    va_list variadicParameterList;
     2045    Vector<WebCore::Node*> convertedTail;
     2046    va_start(variadicParameterList, head);
     2047    while (WebKitDOMNode* variadicParameter = va_arg(variadicParameterList, WebKitDOMNode*))
     2048        convertedTail.append(WebKit::core(variadicParameter));
     2049    va_end(variadicParameterList);
     2050    item->variadicNodeMethod(*convertedHead, WTFMove(convertedTail));
     2051}
     2052
    20052053void webkit_dom_test_obj_any(WebKitDOMTestObj* self, gfloat a, glong b)
    20062054{
  • trunk/Source/WebCore/bindings/scripts/test/GObject/WebKitDOMTestObj.h

    r202275 r202328  
    912912
    913913/**
     914 * webkit_dom_test_obj_variadic_string_method:
     915 * @self: A #WebKitDOMTestObj
     916 * @head: A #gchar
     917 * @...: list of #gchar ended by %NULL.
     918 *
     919 * Stability: Unstable
     920**/
     921WEBKIT_API void
     922webkit_dom_test_obj_variadic_string_method(WebKitDOMTestObj* self, const gchar* head, ...);
     923
     924/**
     925 * webkit_dom_test_obj_variadic_double_method:
     926 * @self: A #WebKitDOMTestObj
     927 * @head: A #gdouble
     928 * @n_tail: number of tail that will be passed
     929 * @...: list of #gdouble
     930 *
     931 * Stability: Unstable
     932**/
     933WEBKIT_API void
     934webkit_dom_test_obj_variadic_double_method(WebKitDOMTestObj* self, gdouble head, guint n_tail, ...);
     935
     936/**
     937 * webkit_dom_test_obj_variadic_node_method:
     938 * @self: A #WebKitDOMTestObj
     939 * @head: A #WebKitDOMNode
     940 * @...: list of #WebKitDOMNode ended by %NULL.
     941 *
     942 * Stability: Unstable
     943**/
     944WEBKIT_API void
     945webkit_dom_test_obj_variadic_node_method(WebKitDOMTestObj* self, WebKitDOMNode* head, ...);
     946
     947/**
    914948 * webkit_dom_test_obj_any:
    915949 * @self: A #WebKitDOMTestObj
Note: See TracChangeset for help on using the changeset viewer.