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