2011-01-07 Adam Barth <abarth@webkit.org>
[WebKit-https.git] / WebCore / bindings / scripts / CodeGeneratorCPP.pm
1
2 # Copyright (C) 2005, 2006 Nikolas Zimmermann <zimmermann@kde.org>
3 # Copyright (C) 2006 Anders Carlsson <andersca@mac.com> 
4 # Copyright (C) 2006, 2007 Samuel Weinig <sam@webkit.org>
5 # Copyright (C) 2006 Alexey Proskuryakov <ap@webkit.org>
6 # Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
7 # Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
8 # Copyright (C) Research In Motion Limited 2010. All rights reserved.
9 #
10 # This library is free software; you can redistribute it and/or
11 # modify it under the terms of the GNU Library General Public
12 # License as published by the Free Software Foundation; either
13 # version 2 of the License, or (at your option) any later version.
14
15 # This library is distributed in the hope that it will be useful,
16 # but WITHOUT ANY WARRANTY; without even the implied warranty of
17 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18 # Library General Public License for more details.
19
20 # You should have received a copy of the GNU Library General Public License
21 # aint with this library; see the file COPYING.LIB.  If not, write to
22 # the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
23 # Boston, MA 02110-1301, USA.
24 #
25
26 package CodeGeneratorCPP;
27
28 # Global Variables
29 my $module = "";
30 my $outputDir = "";
31
32 my @headerContentHeader = ();
33 my @headerContent = ();
34 my %headerForwardDeclarations = ();
35
36 my @implContentHeader = ();
37 my @implContent = ();
38 my %implIncludes = ();
39
40 # Constants
41 my $exceptionInit = "WebCore::ExceptionCode ec = 0;";
42 my $exceptionRaiseOnError = "webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));";
43
44 # Default License Templates
45 my $headerLicenseTemplate = << "EOF";
46 /*
47  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
48  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
49  * Copyright (C) 2006 Samuel Weinig <sam.weinig\@gmail.com>
50  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
51  *
52  * This library is free software; you can redistribute it and/or
53  * modify it under the terms of the GNU Library General Public
54  * License as published by the Free Software Foundation; either
55  * version 2 of the License, or (at your option) any later version.
56  *
57  * This library is distributed in the hope that it will be useful,
58  * but WITHOUT ANY WARRANTY; without even the implied warranty of
59  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
60  * Library General Public License for more details.
61  *
62  * You should have received a copy of the GNU Library General Public License
63  * along with this library; see the file COPYING.LIB.  If not, write to
64  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
65  * Boston, MA 02110-1301, USA.
66  */
67 EOF
68
69 my $implementationLicenseTemplate = << "EOF";
70 /*
71  * This file is part of the WebKit open source project.
72  * This file has been generated by generate-bindings.pl. DO NOT MODIFY!
73  *
74  * This library is free software; you can redistribute it and/or
75  * modify it under the terms of the GNU Library General Public
76  * License as published by the Free Software Foundation; either
77  * version 2 of the License, or (at your option) any later version.
78  *
79  * This library is distributed in the hope that it will be useful,
80  * but WITHOUT ANY WARRANTY; without even the implied warranty of
81  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
82  * Library General Public License for more details.
83  *
84  * You should have received a copy of the GNU Library General Public License
85  * along with this library; see the file COPYING.LIB.  If not, write to
86  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
87  * Boston, MA 02110-1301, USA.
88  */
89 EOF
90
91 # Default constructor
92 sub new
93 {
94     my $object = shift;
95     my $reference = { };
96
97     $codeGenerator = shift;
98     $outputDir = shift;
99     shift; # $outputHeadersDir
100     shift; # $useLayerOnTop
101     shift; # $preprocessor
102     shift; # $writeDependencies
103
104     bless($reference, $object);
105     return $reference;
106 }
107
108 sub finish
109 {
110     my $object = shift;
111 }
112
113 # Params: 'domClass' struct
114 sub GenerateInterface
115 {
116     my $object = shift;
117     my $dataNode = shift;
118     my $defines = shift;
119
120     my $name = $dataNode->name;
121     my $className = GetClassName($name);
122     my $parentClassName = "WebDOM" . GetParentImplClassName($dataNode);
123
124     # Start actual generation.
125     $object->GenerateHeader($dataNode);
126     $object->GenerateImplementation($dataNode);
127
128     # Write changes.
129     $object->WriteData("WebDOM" . $name);
130 }
131
132 # Params: 'idlDocument' struct
133 sub GenerateModule
134 {
135     my $object = shift;
136     my $dataNode = shift;
137
138     $module = $dataNode->module;
139 }
140
141 sub GetClassName
142 {
143     my $name = $codeGenerator->StripModule(shift);
144
145     # special cases
146     return "WebDOMString" if $codeGenerator->IsStringType($name) or $name eq "SerializedScriptValue";
147     return "WebDOMObject" if $name eq "DOMObject";
148     return "bool" if $name eq "boolean";
149     return $name if $codeGenerator->IsPrimitiveType($name);
150     return "WebDOMCustomVoidCallback" if $name eq "VoidCallback";
151
152     return "WebDOM$name";
153 }
154
155 sub GetImplClassName
156 {
157     return $codeGenerator->StripModule(shift);
158 }
159
160 sub GetParentImplClassName
161 {
162     my $dataNode = shift;
163
164     if (@{$dataNode->parents} eq 0) {
165         return "EventTarget" if $dataNode->extendedAttributes->{"EventTarget"};
166         return "Object";
167     }
168
169     return $codeGenerator->StripModule($dataNode->parents(0));
170 }
171
172 sub GetParent
173 {
174     my $dataNode = shift;
175     my $numParents = @{$dataNode->parents};
176
177     my $parent = "";
178     if ($numParents eq 0) {
179         $parent = "WebDOMObject";
180         $parent = "WebDOMEventTarget" if $dataNode->extendedAttributes->{"EventTarget"};
181     } elsif ($numParents eq 1) {
182         my $parentName = $codeGenerator->StripModule($dataNode->parents(0));
183         $parent = "WebDOM" . $parentName;
184     } else {
185         my @parents = @{$dataNode->parents};
186         my $firstParent = $codeGenerator->StripModule(shift(@parents));
187         $parent = "WebDOM" . $firstParent;
188     }
189
190     return $parent;
191 }
192
193 sub ShouldSkipTypeInImplementation
194 {
195     my $typeInfo = shift;
196
197     return 1 if $typeInfo->signature->extendedAttributes->{"Custom"}
198              and !$typeInfo->signature->extendedAttributes->{"NoCPPCustom"};
199
200     return 1 if $typeInfo->signature->extendedAttributes->{"CustomArgumentHandling"}
201              or $typeInfo->signature->extendedAttributes->{"CustomGetter"}
202              or $typeInfo->signature->extendedAttributes->{"NeedsUserGestureCheck"}
203              or $typeInfo->signature->extendedAttributes->{"CPPCustom"};
204
205     # FIXME: We don't generate bindings for SVG related interfaces yet
206     return 1 if $typeInfo->signature->name =~ /getSVGDocument/;
207
208     return 1 if $typeInfo->signature->name =~ /Constructor/;
209     return 0;
210 }
211
212 sub ShouldSkipTypeInHeader
213 {
214     my $typeInfo = shift;
215
216     # FIXME: We currently ignore any attribute/function needing custom code
217     return 1 if $typeInfo->signature->extendedAttributes->{"CustomArgumentHandling"}
218              or $typeInfo->signature->extendedAttributes->{"CustomGetter"};
219
220     # FIXME: We don't generate bindings for SVG related interfaces yet
221     return 1 if $typeInfo->signature->name =~ /getSVGDocument/;
222
223     return 1 if $typeInfo->signature->name =~ /Constructor/;
224     return 0;
225 }
226
227 sub GetCPPType
228 {
229     my $type = shift;
230     my $useConstReference = shift;
231     my $name = GetClassName($type);
232
233     return "int" if $type eq "long";
234     return "unsigned" if $name eq "unsigned long";
235     return "unsigned short" if $type eq "CompareHow";
236
237     if ($codeGenerator->IsStringType($type)) {
238         if ($useConstReference) {
239             return "const $name&";
240         }
241
242         return $name;
243     }
244
245     return $name if $codeGenerator->IsPrimitiveType($type) or $type eq "DOMTimeStamp";
246     return "const $name&" if $useConstReference;
247     return $name;
248 }
249
250 sub ConversionNeeded
251 {
252     my $type = $codeGenerator->StripModule(shift);
253     return !$codeGenerator->IsNonPointerType($type) && !$codeGenerator->IsStringType($type);
254 }
255
256 sub GetCPPTypeGetter
257 {
258     my $argName = shift;
259     my $type = $codeGenerator->StripModule(shift);
260
261     return $argName if $codeGenerator->IsPrimitiveType($type) or $codeGenerator->IsStringType($type);
262     return "static_cast<WebCore::Range::CompareHow>($argName)" if $type eq "CompareHow";
263     return "WebCore::SerializedScriptValue::create(WTF::String($argName))" if $type eq "SerializedScriptValue";
264     return "toWebCore($argName)";
265 }
266
267 sub AddForwardDeclarationsForType
268 {
269     my $type = $codeGenerator->StripModule(shift);
270     my $public = shift;
271
272     return if $codeGenerator->IsNonPointerType($type) or $codeGenerator->IsStringType($type);
273
274     my $class = GetClassName($type);
275     $headerForwardDeclarations{$class} = 1 if $public;
276 }
277
278 sub AddIncludesForType
279 {
280     my $type = $codeGenerator->StripModule(shift);
281
282     return if $codeGenerator->IsNonPointerType($type);
283     return if $type =~ /Constructor/;
284
285     if ($codeGenerator->IsStringType($type)) {
286         $implIncludes{"wtf/text/AtomicString.h"} = 1;
287         $implIncludes{"KURL.h"} = 1;
288         $implIncludes{"WebDOMString.h"} = 1;
289         return;
290     }
291
292     if ($type eq "DOMObject") {
293         $implIncludes{"WebDOMObject.h"} = 1;
294         return;
295     }
296
297     if ($type eq "EventListener") {
298         $implIncludes{"WebNativeEventListener.h"} = 1;
299         return;
300     }
301
302     if ($type eq "SerializedScriptValue") {
303         $implIncludes{"SerializedScriptValue.h"} = 1;
304         return;
305     }
306     
307     if ($type eq "VoidCallback") {
308         $implIncludes{"WebDOMCustomVoidCallback.h"} = 1;
309         return;
310     }
311
312     $implIncludes{"Node.h"} = 1 if $type eq "NodeList";
313     $implIncludes{"CSSMutableStyleDeclaration.h"} = 1 if $type eq "CSSStyleDeclaration";
314
315     # Default, include the same named file (the implementation) and the same name prefixed with "WebDOM". 
316     $implIncludes{"$type.h"} = 1 unless $type eq "DOMObject";
317     $implIncludes{"WebDOM$type.h"} = 1;
318 }
319
320 sub GenerateConditionalStringFromAttributeValue
321 {
322     my $conditional = shift;
323     if ($conditional =~ /&/) {
324         return "ENABLE(" . join(") && ENABLE(", split(/&/, $conditional)) . ")";
325     } elsif ($conditional =~ /\|/) {
326         return "ENABLE(" . join(") || ENABLE(", split(/\|/, $conditional)) . ")";
327     } else {
328         return "ENABLE(" . $conditional . ")";
329     }
330 }
331
332 sub GenerateConditionalString
333 {
334     my $node = shift;
335     my $conditional = $node->extendedAttributes->{"Conditional"};
336     if ($conditional) {
337         return GenerateConditionalStringFromAttributeValue($conditional);
338     } else {
339         return "";
340     }
341 }
342
343 sub GenerateHeader
344 {
345     my $object = shift;
346     my $dataNode = shift;
347
348     my $interfaceName = $dataNode->name;
349     my $className = GetClassName($interfaceName);
350     my $implClassName = GetImplClassName($interfaceName);
351     my $implClassNameWithNamespace = "WebCore::" . $implClassName;
352
353     my $parentName = "";
354     $parentName = GetParent($dataNode);
355
356     my $numConstants = @{$dataNode->constants};
357     my $numAttributes = @{$dataNode->attributes};
358     my $numFunctions = @{$dataNode->functions};
359
360     # - Add default header template
361     @headerContentHeader = split("\r", $headerLicenseTemplate);
362     push(@headerContentHeader, "\n#ifndef $className" . "_h");
363     push(@headerContentHeader, "\n#define $className" . "_h\n\n");
364
365     my $conditionalString = GenerateConditionalString($dataNode);
366     push(@headerContentHeader, "#if ${conditionalString}\n\n") if $conditionalString;
367
368     # - INCLUDES -
369
370     my %headerIncludes = ();
371     $headerIncludes{"WebDOMString.h"} = 1;
372     $headerIncludes{"$parentName.h"} = 1;
373     foreach my $include (sort keys(%headerIncludes)) {
374         push(@headerContentHeader, "#include <$include>\n");
375     }
376
377     push(@headerContent, "class $className");
378     push(@headerContent, " : public $parentName") if $parentName;
379     push(@headerContent, " {\n");
380     push(@headerContent, "public:\n");
381
382     # Constructor
383     push(@headerContent, "    $className();\n");
384     push(@headerContent, "    explicit $className($implClassNameWithNamespace*);\n");
385
386     # Copy constructor and assignment operator on classes which have the d-ptr
387     if ($parentName eq "WebDOMObject") {
388         push(@headerContent, "    $className(const $className&);\n");
389         push(@headerContent, "    ${className}& operator=(const $className&);\n");
390     }
391
392     # Destructor
393     if ($parentName eq "WebDOMObject") {
394         push(@headerContent, "    virtual ~$className();\n");
395     } else {
396         push(@headerContent, "    virtual ~$className() { }\n");
397     }
398
399     push(@headerContent, "\n");
400     $headerForwardDeclarations{$implClassNameWithNamespace} = 1;
401
402     # - Add constants.
403     if ($numConstants > 0) {
404         my @headerConstants = ();
405
406         # FIXME: we need a way to include multiple enums.
407         foreach my $constant (@{$dataNode->constants}) {
408             my $constantName = $constant->name;
409             my $constantValue = $constant->value;
410
411             my $output = "WEBDOM_" . $constantName . " = " . $constantValue;
412             push(@headerConstants, "        " . $output);
413         }
414
415         my $combinedConstants = join(",\n", @headerConstants);
416
417         push(@headerContent, "    ");
418         push(@headerContent, "enum {\n");
419         push(@headerContent, $combinedConstants);
420         push(@headerContent, "\n    ");
421         push(@headerContent, "};\n\n");
422     }
423
424     my @headerAttributes = ();
425
426     # - Add attribute getters/setters.
427     if ($numAttributes > 0) {
428         foreach my $attribute (@{$dataNode->attributes}) {
429             next if ShouldSkipTypeInHeader($attribute);
430
431             my $attributeConditionalString = GenerateConditionalString($attribute->signature);
432             my $attributeName = $attribute->signature->name;
433             my $attributeType = GetCPPType($attribute->signature->type, 0);
434             my $attributeIsReadonly = ($attribute->type =~ /^readonly/);
435             my $property = "";
436             
437             $property .= "#if ${attributeConditionalString}\n" if $attributeConditionalString;
438             $property .= "    " . $attributeType . ($attributeType =~ /\*$/ ? "" : " ") . $attributeName . "() const";
439
440             my $availabilityMacro = "";
441             my $declarationSuffix = ";\n";
442
443             AddForwardDeclarationsForType($attribute->signature->type, 1);
444
445             $attributeType = GetCPPType($attribute->signature->type, 1);
446             my $setterName = "set" . ucfirst($attributeName);
447
448             $property .= $declarationSuffix;
449             push(@headerAttributes, $property);
450             if (!$attributeIsReadonly and !$attribute->signature->extendedAttributes->{"Replaceable"}) {
451                 $property = "    void $setterName($attributeType)";
452                 $property .= $declarationSuffix;
453                 push(@headerAttributes, $property); 
454             }
455
456             push(@headerAttributes, "#endif\n") if $attributeConditionalString;
457         }
458         push(@headerContent, @headerAttributes) if @headerAttributes > 0;
459     }
460
461     my @headerFunctions = ();
462     my @deprecatedHeaderFunctions = ();
463     my @interfaceFunctions = ();
464
465     # - Add functions.
466     if ($numFunctions > 0) {
467         foreach my $function (@{$dataNode->functions}) {
468             next if ShouldSkipTypeInHeader($function);
469             my $functionName = $function->signature->name;
470
471             my $returnType = GetCPPType($function->signature->type, 0);
472             my $numberOfParameters = @{$function->parameters};
473             my %typesToForwardDeclare = ($function->signature->type => 1);
474
475             my $parameterIndex = 0;
476             my $functionSig = "$returnType $functionName(";
477             my $methodName = $functionName;
478             foreach my $param (@{$function->parameters}) {
479                 my $paramName = $param->name;
480                 my $paramType = GetCPPType($param->type, 1);
481                 $typesToForwardDeclare{$param->type} = 1;
482
483                 $functionSig .= ", " if $parameterIndex >= 1;
484                 $functionSig .= "$paramType $paramName";
485                 $parameterIndex++;
486             }
487             $functionSig .= ")";
488             if ($dataNode->extendedAttributes->{"PureInterface"}) {
489                 push(@interfaceFunctions, "    virtual " . $functionSig . " = 0;\n");
490             }
491             my $functionDeclaration = $functionSig;
492             $functionDeclaration .= ";\n";
493
494             foreach my $type (keys %typesToForwardDeclare) {
495                 # add any forward declarations to the public header if a deprecated version will be generated
496                 AddForwardDeclarationsForType($type, 1);
497             }
498
499             push(@headerFunctions, "    ");
500             push(@headerFunctions, $functionDeclaration);
501         }
502
503         if (@headerFunctions > 0) {
504             push(@headerContent, "\n") if @headerAttributes > 0;
505             push(@headerContent, @headerFunctions);
506         }
507     }
508
509     push(@headerContent, "\n");
510     push(@headerContent, "    $implClassNameWithNamespace* impl() const;\n");
511
512     if ($parentName eq "WebDOMObject") {
513         push(@headerContent, "\nprotected:\n");
514         push(@headerContent, "    struct ${className}Private;\n");
515         push(@headerContent, "    ${className}Private* m_impl;\n");
516     }
517
518     push(@headerContent, "};\n\n");
519
520     # for PureInterface classes also add the interface that the client code needs to
521     # implement
522     if ($dataNode->extendedAttributes->{"PureInterface"}) {
523         push(@headerContent, "class WebUser$interfaceName {\n");
524         push(@headerContent, "public:\n");
525         push(@headerContent, "    virtual void ref() = 0;\n");
526         push(@headerContent, "    virtual void deref() = 0;\n\n");
527         push(@headerContent, @interfaceFunctions);
528         push(@headerContent, "\nprotected:\n");
529         push(@headerContent, "    virtual ~WebUser$interfaceName() {}\n");
530         push(@headerContent, "};\n\n");
531     }
532
533     push(@headerContent, "WebCore::$implClassName* toWebCore(const $className&);\n");
534     push(@headerContent, "$className toWebKit(WebCore::$implClassName*);\n");
535     if ($dataNode->extendedAttributes->{"PureInterface"}) {
536         push(@headerContent, "$className toWebKit(WebUser$interfaceName*);\n");
537     }
538     push(@headerContent, "\n#endif\n");
539     push(@headerContent, "#endif // ${conditionalString}\n\n") if $conditionalString;
540 }
541
542 sub AddEarlyReturnStatement
543 {
544     my $returnType = shift;
545
546     if (!defined($returnType) or $returnType eq "void") {
547         $returnType = "";
548     } elsif ($codeGenerator->IsPrimitiveType($returnType)) {
549         $returnType = " 0";
550     } elsif ($returnType eq "bool") {
551         $returnType = " false";
552     } else {
553         $returnType = " $returnType()";
554     }
555
556     # TODO: We could set exceptions here, if we want that
557     my $statement = "    if (!impl())\n";
558     $statement .=   "        return$returnType;\n\n";
559     return $statement;
560 }
561
562 sub AddReturnStatement
563 {
564     my $typeInfo = shift;
565     my $returnValue = shift;
566
567     # Used to invoke KURLs "const String&" operator
568     if ($codeGenerator->IsStringType($typeInfo->signature->type)) {
569         return "    return static_cast<const WTF::String&>($returnValue);\n";
570     }
571
572     return "    return $returnValue;\n";
573 }
574
575 sub GenerateImplementation
576 {
577     my $object = shift;
578     my $dataNode = shift;
579
580     my @ancestorInterfaceNames = ();
581
582     if (@{$dataNode->parents} > 1) {
583         $codeGenerator->AddMethodsConstantsAndAttributesFromParentClasses($dataNode, \@ancestorInterfaceNames);
584     }
585
586     my $interfaceName = $dataNode->name;
587     my $className = GetClassName($interfaceName);
588     my $implClassName = GetImplClassName($interfaceName);
589     my $parentImplClassName = GetParentImplClassName($dataNode);
590     my $implClassNameWithNamespace = "WebCore::" . $implClassName;
591     my $baseClass = "WebDOM$parentImplClassName";
592     my $conditional = $dataNode->extendedAttributes->{"Conditional"};
593
594     my $numAttributes = @{$dataNode->attributes};
595     my $numFunctions = @{$dataNode->functions};
596
597     # - Add default header template.
598     @implContentHeader = split("\r", $implementationLicenseTemplate);
599
600     # - INCLUDES -
601     push(@implContentHeader, "\n#include \"config.h\"\n");
602     my $conditionalString = GenerateConditionalString($dataNode);
603     push(@implContentHeader, "\n#if ${conditionalString}\n\n") if $conditionalString;
604     push(@implContentHeader, "#include \"$className.h\"\n\n");
605
606     $implIncludes{"WebExceptionHandler.h"} = 1;
607     $implIncludes{"$implClassName.h"} = 1;
608     @implContent = ();
609
610     push(@implContent, "#include <wtf/GetPtr.h>\n");
611     push(@implContent, "#include <wtf/RefPtr.h>\n\n");
612
613     # Private datastructure, encapsulating WebCore types
614     if ($baseClass eq "WebDOMObject") {
615         push(@implContent, "struct ${className}::${className}Private {\n");
616         push(@implContent, "    ${className}Private($implClassNameWithNamespace* object = 0)\n");
617         push(@implContent, "        : impl(object)\n");
618         push(@implContent, "    {\n");
619         push(@implContent, "    }\n\n");
620         push(@implContent, "    RefPtr<$implClassNameWithNamespace> impl;\n");
621         push(@implContent, "};\n\n");
622     }
623
624     # Constructor
625     push(@implContent, "${className}::$className()\n");
626     push(@implContent, "    : ${baseClass}()\n");
627     push(@implContent, "    , m_impl(0)\n") if ($baseClass eq "WebDOMObject");
628     push(@implContent, "{\n");
629     push(@implContent, "}\n\n");
630
631     push(@implContent, "${className}::$className($implClassNameWithNamespace* impl)\n");
632     if ($baseClass eq "WebDOMObject") {
633         push(@implContent, "    : ${baseClass}()\n");
634         push(@implContent, "    , m_impl(new ${className}Private(impl))\n");
635         push(@implContent, "{\n");
636         push(@implContent, "}\n\n");
637
638         push(@implContent, "${className}::${className}(const ${className}& copy)\n");
639         push(@implContent, "    : ${baseClass}()\n");
640         push(@implContent, "{\n");
641         push(@implContent, "    m_impl = copy.impl() ? new ${className}Private(copy.impl()) : 0;\n");
642         push(@implContent, "}\n\n");
643
644         push(@implContent, "${className}& ${className}::operator\=(const ${className}& copy)\n");
645         push(@implContent, "{\n");
646         push(@implContent, "    delete m_impl;\n");
647         push(@implContent, "    m_impl = copy.impl() ? new ${className}Private(copy.impl()) : 0;\n");
648         push(@implContent, "    return *this;\n");
649         push(@implContent, "}\n\n");
650
651         push(@implContent, "$implClassNameWithNamespace* ${className}::impl() const\n");
652         push(@implContent, "{\n");
653         push(@implContent, "    return m_impl ? m_impl->impl.get() : 0;\n");
654         push(@implContent, "}\n\n");
655
656         # Destructor
657         push(@implContent, "${className}::~$className()\n");
658         push(@implContent, "{\n");
659         push(@implContent, "    delete m_impl;\n");
660         push(@implContent, "    m_impl = 0;\n");
661         push(@implContent, "}\n\n");
662     } else {
663         push(@implContent, "    : ${baseClass}(impl)\n");
664         push(@implContent, "{\n");
665         push(@implContent, "}\n\n");
666
667         push(@implContent, "$implClassNameWithNamespace* ${className}::impl() const\n");
668         push(@implContent, "{\n");
669         push(@implContent, "    return static_cast<$implClassNameWithNamespace*>(${baseClass}::impl());\n");
670         push(@implContent, "}\n\n");
671     }
672
673     # START implementation
674     %attributeNames = ();
675
676     # - Attributes
677     if ($numAttributes > 0) {
678         foreach my $attribute (@{$dataNode->attributes}) {
679             next if ShouldSkipTypeInImplementation($attribute);
680             AddIncludesForType($attribute->signature->type);
681
682             my $idlType = $codeGenerator->StripModule($attribute->signature->type);
683
684             my $attributeName = $attribute->signature->name;
685             my $attributeType = GetCPPType($attribute->signature->type, 0);
686             my $attributeIsReadonly = ($attribute->type =~ /^readonly/);
687
688             $attributeNames{$attributeName} = 1;
689
690             # - GETTER
691             my $getterSig = "$attributeType $className\:\:$attributeName() const\n";
692             my $hasGetterException = @{$attribute->getterExceptions};
693             my $getterContentHead = "impl()->" . $codeGenerator->GetterExpressionPrefix(\%implIncludes, $interfaceName, $attribute);
694             my $getterContentTail = ")";
695
696             # Special cases
697             my @customGetterContent = (); 
698             if ($attribute->signature->extendedAttributes->{"ConvertToString"}) {
699                 $getterContentHead = "WTF::String::number(" . $getterContentHead;
700                 $getterContentTail .= ")";
701             } elsif ($attribute->signature->type eq "SerializedScriptValue") {
702                 $getterContentHead = "$getterContentHead";
703                 $getterContentTail .= "->toString()";                
704             } elsif (ConversionNeeded($attribute->signature->type)) {
705                 $getterContentHead = "toWebKit(WTF::getPtr($getterContentHead";
706                 $getterContentTail .= "))";
707             }
708
709             my $getterContent;
710             if ($hasGetterException) {
711                 $getterContent = $getterContentHead . "ec" . $getterContentTail;
712             } else {
713                 $getterContent = $getterContentHead . $getterContentTail;
714             }
715
716             my $attributeConditionalString = GenerateConditionalString($attribute->signature);
717             push(@implContent, "#if ${attributeConditionalString}\n") if $attributeConditionalString;
718
719             push(@implContent, $getterSig);
720             push(@implContent, "{\n");
721             push(@implContent, AddEarlyReturnStatement($attributeType));
722             push(@implContent, @customGetterContent);
723             if ($hasGetterException) {
724                 # Differentiated between when the return type is a pointer and
725                 # not for white space issue (ie. Foo *result vs. int result).
726                 if ($attributeType =~ /\*$/) {
727                     $getterContent = $attributeType . "result = " . $getterContent;
728                 } else {
729                     $getterContent = $attributeType . " result = " . $getterContent;
730                 }
731
732                 push(@implContent, "    $exceptionInit\n");
733                 push(@implContent, "    $getterContent;\n");
734                 push(@implContent, "    $exceptionRaiseOnError\n");
735                 push(@implContent, AddReturnStatement($attribute, "result"));
736             } else {
737                 push(@implContent, AddReturnStatement($attribute, $getterContent));
738             }
739             push(@implContent, "}\n\n");
740
741             # - SETTER
742             if (!$attributeIsReadonly and !$attribute->signature->extendedAttributes->{"Replaceable"}) {
743                 # Exception handling
744                 my $hasSetterException = @{$attribute->setterExceptions};
745
746                 my $coreSetterName = "set" . $codeGenerator->WK_ucfirst($attributeName);
747                 my $setterName = "set" . ucfirst($attributeName);
748                 my $argName = "new" . ucfirst($attributeName);
749                 my $arg = GetCPPTypeGetter($argName, $idlType);
750
751                 # The definition of ConvertToString is flipped for the setter
752                 if ($attribute->signature->extendedAttributes->{"ConvertToString"}) {
753                     $arg = "WTF::String($arg).toInt()";
754                 }
755
756                 my $attributeType = GetCPPType($attribute->signature->type, 1);
757                 push(@implContent, "void $className\:\:$setterName($attributeType $argName)\n");
758                 push(@implContent, "{\n");
759                 push(@implContent, AddEarlyReturnStatement());
760
761                 push(@implContent, "    $exceptionInit\n") if $hasSetterException;
762                 my $ec = $hasSetterException ? ", ec" : "";
763                 my $setterExpressionPrefix = $codeGenerator->SetterExpressionPrefix(\%implIncludes, $interfaceName, $attribute);
764                 push(@implContent, "    impl()->$setterExpressionPrefix$arg$ec);\n");
765                 push(@implContent, "    $exceptionRaiseOnError\n") if $hasSetterException;
766                 push(@implContent, "}\n\n");
767             }
768
769             push(@implContent, "#endif\n") if $attributeConditionalString;
770         }
771     }
772
773     # - Functions
774     if ($numFunctions > 0) {
775         foreach my $function (@{$dataNode->functions}) {
776             # Treat PureInterface as Custom as well, since the WebCore versions will take a script context as well
777             next if ShouldSkipTypeInImplementation($function) || $dataNode->extendedAttributes->{"PureInterface"};
778             AddIncludesForType($function->signature->type);
779
780             my $functionName = $function->signature->name;
781             my $returnType = GetCPPType($function->signature->type, 0);
782             my $hasParameters = @{$function->parameters};
783             my $raisesExceptions = @{$function->raisesExceptions};
784
785             my @parameterNames = ();
786             my @needsAssert = ();
787             my %needsCustom = ();
788
789             my $parameterIndex = 0;
790
791             my $functionSig = "$returnType $className\:\:$functionName(";
792             foreach my $param (@{$function->parameters}) {
793                 my $paramName = $param->name;
794                 my $paramType = GetCPPType($param->type, 1);
795
796                 # make a new parameter name if the original conflicts with a property name
797                 $paramName = "in" . ucfirst($paramName) if $attributeNames{$paramName};
798
799                 AddIncludesForType($param->type);
800
801                 my $idlType = $codeGenerator->StripModule($param->type);
802                 my $implGetter = GetCPPTypeGetter($paramName, $idlType);
803
804                 push(@parameterNames, $implGetter);
805                 $needsCustom{"NodeToReturn"} = $paramName if $param->extendedAttributes->{"Return"};
806
807                 unless ($codeGenerator->IsPrimitiveType($idlType) or $codeGenerator->IsStringType($idlType)) {
808                     push(@needsAssert, "    ASSERT($paramName);\n");
809                 }
810
811                 $functionSig .= ", " if $parameterIndex >= 1;
812                 $functionSig .= "$paramType $paramName";
813                 $parameterIndex++;
814             }
815
816             $functionSig .= ")";
817
818             my @functionContent = ();
819             push(@parameterNames, "ec") if $raisesExceptions;
820             my $content = "impl()->" . $codeGenerator->WK_lcfirst($functionName) . "(" . join(", ", @parameterNames) . ")"; 
821
822             if ($returnType eq "void") {
823                 # Special case 'void' return type.
824                 if ($raisesExceptions) {
825                     push(@functionContent, "    $exceptionInit\n");
826                     push(@functionContent, "    $content;\n");
827                     push(@functionContent, "    $exceptionRaiseOnError\n");
828                 } else {
829                     push(@functionContent, "    $content;\n");
830                 }
831             } elsif (defined $needsCustom{"NodeToReturn"}) {
832                 # TODO: This is important to enable, once we care about custom code!
833
834                 # Special case the insertBefore, replaceChild, removeChild 
835                 # and appendChild functions from DOMNode 
836                 my $toReturn = $needsCustom{"NodeToReturn"};
837                 if ($raisesExceptions) {
838                     push(@functionContent, "    $exceptionInit\n");
839                     push(@functionContent, "    if ($content)\n");
840                     push(@functionContent, "        return $toReturn;\n");
841                     push(@functionContent, "    $exceptionRaiseOnError\n");
842                     push(@functionContent, "    return $className();\n");
843                 } else {
844                     push(@functionContent, "    if ($content)\n");
845                     push(@functionContent, "        return $toReturn;\n");
846                     push(@functionContent, "    return NULL;\n");
847                 }
848             } else {
849                 if (ConversionNeeded($function->signature->type)) {
850                     $content = "toWebKit(WTF::getPtr($content))";
851                 }
852
853                 if ($raisesExceptions) {
854                     # Differentiated between when the return type is a pointer and
855                     # not for white space issue (ie. Foo *result vs. int result).
856                     if ($returnType =~ /\*$/) {
857                         $content = $returnType . "result = " . $content;
858                     } else {
859                         $content = $returnType . " result = " . $content;
860                     }
861
862                     push(@functionContent, "    $exceptionInit\n");
863                     push(@functionContent, "    $content;\n");
864                     push(@functionContent, "    $exceptionRaiseOnError\n");
865                     push(@functionContent, "    return result;\n");
866                 } else {
867                     push(@functionContent, "    return $content;\n");
868                 }
869             }
870
871             push(@implContent, "$functionSig\n");
872             push(@implContent, "{\n");
873             push(@implContent, AddEarlyReturnStatement($returnType));
874             push(@implContent, @functionContent);
875             push(@implContent, "}\n\n");
876
877             # Clear the hash
878             %needsCustom = ();
879         }
880     }
881
882     # END implementation
883
884     # Generate internal interfaces
885     push(@implContent, "WebCore::$implClassName* toWebCore(const $className& wrapper)\n");
886     push(@implContent, "{\n");
887     push(@implContent, "    return wrapper.impl();\n");
888     push(@implContent, "}\n\n");
889
890     push(@implContent, "$className toWebKit(WebCore::$implClassName* value)\n");
891     push(@implContent, "{\n");
892     push(@implContent, "    return $className(value);\n");
893     push(@implContent, "}\n");
894
895     # - End the ifdef conditional if necessary
896     push(@implContent, "\n#endif // ${conditionalString}\n") if $conditionalString;
897 }
898
899 # Internal helper
900 sub WriteData
901 {
902     my $object = shift;
903     my $name = shift;
904
905     # Open files for writing...
906     my $headerFileName = "$outputDir/" . $name . ".h";
907     my $implFileName = "$outputDir/" . $name . ".cpp";
908
909     # Remove old files.
910     unlink($headerFileName);
911     unlink($implFileName);
912
913     # Write public header.
914     open(HEADER, ">$headerFileName") or die "Couldn't open file $headerFileName";
915     
916     print HEADER @headerContentHeader;
917     print HEADER "\n";
918     foreach my $class (sort keys(%headerForwardDeclarations)) {
919         if ($class =~ /::/) {
920             my $namespacePart = $class;
921             $namespacePart =~ s/::.*//;
922
923             my $classPart = $class;
924             $classPart =~ s/${namespacePart}:://;
925
926             print HEADER "namespace $namespacePart {\nclass $classPart;\n};\n\n";
927         } else {
928             print HEADER "class $class;\n"
929         }
930     }
931
932     my $hasForwardDeclarations = keys(%headerForwardDeclarations);
933     print HEADER "\n" if $hasForwardDeclarations;
934     print HEADER @headerContent;
935     close(HEADER);
936
937     @headerContentHeader = ();
938     @headerContent = ();
939     %headerForwardDeclarations = ();
940
941     # Write implementation file.
942     open(IMPL, ">$implFileName") or die "Couldn't open file $implFileName";
943
944     print IMPL @implContentHeader;
945
946     foreach my $include (sort keys(%implIncludes)) {
947         # "className.h" is already included right after config.h, silence check-webkit-style
948         next if $include eq "$name.h";
949         print IMPL "#include \"$include\"\n";
950     }
951
952     print IMPL @implContent;
953     close(IMPL);
954
955     @implContentHeader = ();
956     @implContent = ();
957     %implIncludes = ();
958 }
959
960 1;