Remove duplicated GenerateConditionalString() from code generators
[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 GetNamespaceForClass
311 {
312     my $type = shift;
313     return "WTF" if (($type eq "ArrayBuffer") or ($type eq "ArrayBufferView")); 
314     return "WTF" if (($type eq "Uint8Array") or ($type eq "Uint8ClampedArray") or ($type eq "Uint16Array") or ($type eq "Uint32Array")); 
315     return "WTF" if (($type eq "Int8Array") or ($type eq "Int16Array") or ($type eq "Int32Array")); 
316     return "WTF" if (($type eq "Float32Array") or ($type eq "Float64Array"));    
317     return "WebCore";
318 }
319
320 sub GenerateHeader
321 {
322     my $object = shift;
323     my $dataNode = shift;
324
325     my $interfaceName = $dataNode->name;
326     my $className = GetClassName($interfaceName);
327     my $implClassName = GetImplClassName($interfaceName);
328     
329     my $implClassNameWithNamespace = GetNamespaceForClass($implClassName) . "::" . $implClassName;
330
331     my $parentName = "";
332     $parentName = GetParent($dataNode);
333
334     my $numConstants = @{$dataNode->constants};
335     my $numAttributes = @{$dataNode->attributes};
336     my $numFunctions = @{$dataNode->functions};
337
338     # - Add default header template
339     @headerContentHeader = split("\r", $headerLicenseTemplate);
340     push(@headerContentHeader, "\n#ifndef $className" . "_h");
341     push(@headerContentHeader, "\n#define $className" . "_h\n\n");
342
343     my $conditionalString = $codeGenerator->GenerateConditionalString($dataNode);
344     push(@headerContentHeader, "#if ${conditionalString}\n\n") if $conditionalString;
345
346     # - INCLUDES -
347
348     my %headerIncludes = ();
349     $headerIncludes{"WebDOMString.h"} = 1;
350     $headerIncludes{"$parentName.h"} = 1;
351     foreach my $include (sort keys(%headerIncludes)) {
352         push(@headerContentHeader, "#include <$include>\n");
353     }
354
355     push(@headerContent, "class $className");
356     push(@headerContent, " : public $parentName") if $parentName;
357     push(@headerContent, " {\n");
358     push(@headerContent, "public:\n");
359
360     # Constructor
361     push(@headerContent, "    $className();\n");
362     push(@headerContent, "    explicit $className($implClassNameWithNamespace*);\n");
363
364     # Copy constructor and assignment operator on classes which have the d-ptr
365     if ($parentName eq "WebDOMObject") {
366         push(@headerContent, "    $className(const $className&);\n");
367         push(@headerContent, "    ${className}& operator=(const $className&);\n");
368     }
369
370     # Destructor
371     if ($parentName eq "WebDOMObject") {
372         push(@headerContent, "    virtual ~$className();\n");
373     } else {
374         push(@headerContent, "    virtual ~$className() { }\n");
375     }
376
377     push(@headerContent, "\n");
378     $headerForwardDeclarations{$implClassNameWithNamespace} = 1;
379
380     # - Add constants.
381     if ($numConstants > 0) {
382         my @headerConstants = ();
383         my @constants = @{$dataNode->constants};
384         my $combinedConstants = "";
385
386         # FIXME: we need a way to include multiple enums.
387         foreach my $constant (@constants) {
388             my $constantName = $constant->name;
389             my $constantValue = $constant->value;
390             my $conditional = $constant->extendedAttributes->{"Conditional"};
391             my $notLast = $constant ne $constants[-1];
392
393             if ($conditional) {
394                 my $conditionalString = $codeGenerator->GenerateConditionalStringFromAttributeValue($conditional);
395                 $combinedConstants .= "#if ${conditionalString}\n";
396             }
397             $combinedConstants .= "        WEBDOM_$constantName = $constantValue";
398             $combinedConstants .= "," if $notLast;
399             if ($conditional) {
400                 $combinedConstants .= "\n#endif\n";
401             } elsif ($notLast) {
402                 $combinedConstants .= "\n";
403             }
404         }
405
406         push(@headerContent, "    ");
407         push(@headerContent, "enum {\n");
408         push(@headerContent, $combinedConstants);
409         push(@headerContent, "\n    ");
410         push(@headerContent, "};\n\n");
411     }
412
413     my @headerAttributes = ();
414
415     # - Add attribute getters/setters.
416     if ($numAttributes > 0) {
417         foreach my $attribute (@{$dataNode->attributes}) {
418             next if ShouldSkipType($attribute);
419
420             my $attributeConditionalString = $codeGenerator->GenerateConditionalString($attribute->signature);
421             my $attributeName = $attribute->signature->name;
422             my $attributeType = GetCPPType($attribute->signature->type, 0);
423             my $attributeIsReadonly = ($attribute->type =~ /^readonly/);
424             my $property = "";
425             
426             $property .= "#if ${attributeConditionalString}\n" if $attributeConditionalString;
427             $property .= "    " . $attributeType . ($attributeType =~ /\*$/ ? "" : " ") . $attributeName . "() const";
428
429             my $availabilityMacro = "";
430             my $declarationSuffix = ";\n";
431
432             AddForwardDeclarationsForType($attribute->signature->type, 1);
433
434             $attributeType = GetCPPType($attribute->signature->type, 1);
435             my $setterName = "set" . ucfirst($attributeName);
436
437             $property .= $declarationSuffix;
438             push(@headerAttributes, $property);
439             if (!$attributeIsReadonly and !$attribute->signature->extendedAttributes->{"Replaceable"}) {
440                 $property = "    void $setterName($attributeType)";
441                 $property .= $declarationSuffix;
442                 push(@headerAttributes, $property); 
443             }
444
445             push(@headerAttributes, "#endif\n") if $attributeConditionalString;
446         }
447         push(@headerContent, @headerAttributes) if @headerAttributes > 0;
448     }
449
450     my @headerFunctions = ();
451     my @deprecatedHeaderFunctions = ();
452     my @interfaceFunctions = ();
453
454     # - Add functions.
455     if ($numFunctions > 0) {
456         foreach my $function (@{$dataNode->functions}) {
457             next if ShouldSkipType($function);
458             my $functionName = $function->signature->extendedAttributes->{"ImplementedAs"} || $function->signature->name;
459
460             my $returnType = GetCPPType($function->signature->type, 0);
461             my $numberOfParameters = @{$function->parameters};
462             my %typesToForwardDeclare = ($function->signature->type => 1);
463
464             my $parameterIndex = 0;
465             my $functionSig = "$returnType $functionName(";
466             my $methodName = $functionName;
467             foreach my $param (@{$function->parameters}) {
468                 my $paramName = $param->name;
469                 my $paramType = GetCPPType($param->type, 1);
470                 $typesToForwardDeclare{$param->type} = 1;
471
472                 $functionSig .= ", " if $parameterIndex >= 1;
473                 $functionSig .= "$paramType $paramName";
474                 $parameterIndex++;
475             }
476             $functionSig .= ")";
477             if ($dataNode->extendedAttributes->{"CPPPureInterface"}) {
478                 push(@interfaceFunctions, "    virtual " . $functionSig . " = 0;\n");
479             }
480             my $functionDeclaration = $functionSig;
481             $functionDeclaration .= ";\n";
482
483             foreach my $type (keys %typesToForwardDeclare) {
484                 # add any forward declarations to the public header if a deprecated version will be generated
485                 AddForwardDeclarationsForType($type, 1);
486             }
487
488             my $conditionalString = $codeGenerator->GenerateConditionalString($function->signature);
489             push(@headerFunctions, "#if ${conditionalString}\n") if $conditionalString;
490             push(@headerFunctions, "    ");
491             push(@headerFunctions, $functionDeclaration);
492             push(@headerFunctions, "#endif\n") if $conditionalString;
493         }
494
495         if (@headerFunctions > 0) {
496             push(@headerContent, "\n") if @headerAttributes > 0;
497             push(@headerContent, @headerFunctions);
498         }
499     }
500
501     push(@headerContent, "\n");
502     push(@headerContent, "    $implClassNameWithNamespace* impl() const;\n");
503
504     if ($parentName eq "WebDOMObject") {
505         push(@headerContent, "\nprotected:\n");
506         push(@headerContent, "    struct ${className}Private;\n");
507         push(@headerContent, "    ${className}Private* m_impl;\n");
508     }
509
510     push(@headerContent, "};\n\n");
511
512     # for CPPPureInterface classes also add the interface that the client code needs to
513     # implement
514     if ($dataNode->extendedAttributes->{"CPPPureInterface"}) {
515         push(@headerContent, "class WebUser$interfaceName {\n");
516         push(@headerContent, "public:\n");
517         push(@headerContent, "    virtual void ref() = 0;\n");
518         push(@headerContent, "    virtual void deref() = 0;\n\n");
519         push(@headerContent, @interfaceFunctions);
520         push(@headerContent, "\nprotected:\n");
521         push(@headerContent, "    virtual ~WebUser$interfaceName() {}\n");
522         push(@headerContent, "};\n\n");
523     }
524
525     my $namespace = GetNamespaceForClass($implClassName);
526     push(@headerContent, "$namespace" . "::$implClassName* toWebCore(const $className&);\n");
527     push(@headerContent, "$className toWebKit($namespace" . "::$implClassName*);\n");
528     if ($dataNode->extendedAttributes->{"CPPPureInterface"}) {
529         push(@headerContent, "$className toWebKit(WebUser$interfaceName*);\n");
530     }
531     push(@headerContent, "\n#endif\n");
532     push(@headerContent, "#endif // ${conditionalString}\n\n") if $conditionalString;
533 }
534
535 sub AddEarlyReturnStatement
536 {
537     my $returnType = shift;
538
539     if (!defined($returnType) or $returnType eq "void") {
540         $returnType = "";
541     } elsif ($codeGenerator->IsPrimitiveType($returnType)) {
542         $returnType = " 0";
543     } elsif ($returnType eq "bool") {
544         $returnType = " false";
545     } else {
546         $returnType = " $returnType()";
547     }
548
549     # TODO: We could set exceptions here, if we want that
550     my $statement = "    if (!impl())\n";
551     $statement .=   "        return$returnType;\n\n";
552     return $statement;
553 }
554
555 sub AddReturnStatement
556 {
557     my $typeInfo = shift;
558     my $returnValue = shift;
559
560     # Used to invoke KURLs "const String&" operator
561     if ($codeGenerator->IsStringType($typeInfo->signature->type)) {
562         return "    return static_cast<const WTF::String&>($returnValue);\n";
563     }
564
565     return "    return $returnValue;\n";
566 }
567
568 sub GenerateImplementation
569 {
570     my $object = shift;
571     my $dataNode = shift;
572
573     my @ancestorInterfaceNames = ();
574
575     if (@{$dataNode->parents} > 1) {
576         $codeGenerator->AddMethodsConstantsAndAttributesFromParentClasses($dataNode, \@ancestorInterfaceNames);
577     }
578
579     my $interfaceName = $dataNode->name;
580     my $className = GetClassName($interfaceName);
581     my $implClassName = GetImplClassName($interfaceName);
582     my $parentImplClassName = GetParentImplClassName($dataNode);
583     my $implClassNameWithNamespace = GetNamespaceForClass($implClassName) . "::" . $implClassName;
584     my $baseClass = "WebDOM$parentImplClassName";
585     my $conditional = $dataNode->extendedAttributes->{"Conditional"};
586
587     my $numAttributes = @{$dataNode->attributes};
588     my $numFunctions = @{$dataNode->functions};
589
590     # - Add default header template.
591     @implContentHeader = split("\r", $implementationLicenseTemplate);
592
593     # - INCLUDES -
594     push(@implContentHeader, "\n#include \"config.h\"\n");
595     my $conditionalString = $codeGenerator->GenerateConditionalString($dataNode);
596     push(@implContentHeader, "\n#if ${conditionalString}\n\n") if $conditionalString;
597     push(@implContentHeader, "#include \"$className.h\"\n\n");
598
599     $implIncludes{"WebExceptionHandler.h"} = 1;
600     $implIncludes{"$implClassName.h"} = 1;
601     @implContent = ();
602
603     push(@implContent, "#include <wtf/GetPtr.h>\n");
604     push(@implContent, "#include <wtf/RefPtr.h>\n\n");
605
606     # Private datastructure, encapsulating WebCore types
607     if ($baseClass eq "WebDOMObject") {
608         push(@implContent, "struct ${className}::${className}Private {\n");
609         push(@implContent, "    ${className}Private($implClassNameWithNamespace* object = 0)\n");
610         push(@implContent, "        : impl(object)\n");
611         push(@implContent, "    {\n");
612         push(@implContent, "    }\n\n");
613         push(@implContent, "    RefPtr<$implClassNameWithNamespace> impl;\n");
614         push(@implContent, "};\n\n");
615     }
616
617     # Constructor
618     push(@implContent, "${className}::$className()\n");
619     push(@implContent, "    : ${baseClass}()\n");
620     push(@implContent, "    , m_impl(0)\n") if ($baseClass eq "WebDOMObject");
621     push(@implContent, "{\n");
622     push(@implContent, "}\n\n");
623
624     push(@implContent, "${className}::$className($implClassNameWithNamespace* impl)\n");
625     if ($baseClass eq "WebDOMObject") {
626         push(@implContent, "    : ${baseClass}()\n");
627         push(@implContent, "    , m_impl(new ${className}Private(impl))\n");
628         push(@implContent, "{\n");
629         push(@implContent, "}\n\n");
630
631         push(@implContent, "${className}::${className}(const ${className}& copy)\n");
632         push(@implContent, "    : ${baseClass}()\n");
633         push(@implContent, "{\n");
634         push(@implContent, "    m_impl = copy.impl() ? new ${className}Private(copy.impl()) : 0;\n");
635         push(@implContent, "}\n\n");
636
637         push(@implContent, "${className}& ${className}::operator\=(const ${className}& copy)\n");
638         push(@implContent, "{\n");
639         push(@implContent, "    delete m_impl;\n");
640         push(@implContent, "    m_impl = copy.impl() ? new ${className}Private(copy.impl()) : 0;\n");
641         push(@implContent, "    return *this;\n");
642         push(@implContent, "}\n\n");
643
644         push(@implContent, "$implClassNameWithNamespace* ${className}::impl() const\n");
645         push(@implContent, "{\n");
646         push(@implContent, "    return m_impl ? WTF::getPtr(m_impl->impl) : 0;\n");
647         push(@implContent, "}\n\n");
648
649         # Destructor
650         push(@implContent, "${className}::~$className()\n");
651         push(@implContent, "{\n");
652         push(@implContent, "    delete m_impl;\n");
653         push(@implContent, "    m_impl = 0;\n");
654         push(@implContent, "}\n\n");
655     } else {
656         push(@implContent, "    : ${baseClass}(impl)\n");
657         push(@implContent, "{\n");
658         push(@implContent, "}\n\n");
659
660         push(@implContent, "$implClassNameWithNamespace* ${className}::impl() const\n");
661         push(@implContent, "{\n");
662         push(@implContent, "    return static_cast<$implClassNameWithNamespace*>(${baseClass}::impl());\n");
663         push(@implContent, "}\n\n");
664     }
665
666     # START implementation
667     %attributeNames = ();
668
669     # - Attributes
670     if ($numAttributes > 0) {
671         foreach my $attribute (@{$dataNode->attributes}) {
672             next if ShouldSkipType($attribute);
673             AddIncludesForType($attribute->signature->type);
674
675             my $idlType = $codeGenerator->StripModule($attribute->signature->type);
676
677             my $attributeName = $attribute->signature->name;
678             my $attributeType = GetCPPType($attribute->signature->type, 0);
679             my $attributeIsReadonly = ($attribute->type =~ /^readonly/);
680
681             $attributeNames{$attributeName} = 1;
682
683             # - GETTER
684             my $getterSig = "$attributeType $className\:\:$attributeName() const\n";
685             my $hasGetterException = @{$attribute->getterExceptions};
686             my ($functionName, @arguments) = $codeGenerator->GetterExpression(\%implIncludes, $interfaceName, $attribute);
687             push(@arguments, "ec") if $hasGetterException;
688             if ($attribute->signature->extendedAttributes->{"ImplementedBy"}) {
689                 my $implementedBy = $attribute->signature->extendedAttributes->{"ImplementedBy"};
690                 $implIncludes{"${implementedBy}.h"} = 1;
691                 unshift(@arguments, "impl()");
692                 $functionName = "${implementedBy}::${functionName}";
693             } else {
694                 $functionName = "impl()->${functionName}";
695             }
696
697             # Special cases
698             my $getterContentHead = "";
699             my $getterContentTail = "";
700             my @customGetterContent = (); 
701             if ($attribute->signature->extendedAttributes->{"ConvertToString"}) {
702                 $getterContentHead = "WTF::String::number(";
703                 $getterContentTail = ")";
704             } elsif ($attribute->signature->type eq "SerializedScriptValue") {
705                 $getterContentTail = "->toString()";
706             } elsif (ConversionNeeded($attribute->signature->type)) {
707                 $getterContentHead = "toWebKit(WTF::getPtr(";
708                 $getterContentTail = "))";
709             }
710
711             my $getterContent = "${getterContentHead}${functionName}(" . join(", ", @arguments) . ")${getterContentTail}";
712             my $attributeConditionalString = $codeGenerator->GenerateConditionalString($attribute->signature);
713             push(@implContent, "#if ${attributeConditionalString}\n") if $attributeConditionalString;
714
715             push(@implContent, $getterSig);
716             push(@implContent, "{\n");
717             push(@implContent, AddEarlyReturnStatement($attributeType));
718             push(@implContent, @customGetterContent);
719             if ($hasGetterException) {
720                 # Differentiated between when the return type is a pointer and
721                 # not for white space issue (ie. Foo *result vs. int result).
722                 if ($attributeType =~ /\*$/) {
723                     $getterContent = $attributeType . "result = " . $getterContent;
724                 } else {
725                     $getterContent = $attributeType . " result = " . $getterContent;
726                 }
727
728                 push(@implContent, "    $exceptionInit\n");
729                 push(@implContent, "    $getterContent;\n");
730                 push(@implContent, "    $exceptionRaiseOnError\n");
731                 push(@implContent, AddReturnStatement($attribute, "result"));
732             } else {
733                 push(@implContent, AddReturnStatement($attribute, $getterContent));
734             }
735             push(@implContent, "}\n\n");
736
737             # - SETTER
738             if (!$attributeIsReadonly and !$attribute->signature->extendedAttributes->{"Replaceable"}) {
739                 # Exception handling
740                 my $hasSetterException = @{$attribute->setterExceptions};
741
742                 my $coreSetterName = "set" . $codeGenerator->WK_ucfirst($attributeName);
743                 my $setterName = "set" . ucfirst($attributeName);
744                 my $argName = "new" . ucfirst($attributeName);
745                 my $arg = GetCPPTypeGetter($argName, $idlType);
746
747                 my $attributeType = GetCPPType($attribute->signature->type, 1);
748                 push(@implContent, "void $className\:\:$setterName($attributeType $argName)\n");
749                 push(@implContent, "{\n");
750                 push(@implContent, AddEarlyReturnStatement());
751
752                 push(@implContent, "    $exceptionInit\n") if $hasSetterException;
753
754                 my ($functionName, @arguments) = $codeGenerator->SetterExpression(\%implIncludes, $interfaceName, $attribute);
755                 push(@arguments, $arg);
756                 push(@arguments, "ec") if $hasSetterException;
757                 if ($attribute->signature->extendedAttributes->{"ImplementedBy"}) {
758                     my $implementedBy = $attribute->signature->extendedAttributes->{"ImplementedBy"};
759                     $implIncludes{"${implementedBy}.h"} = 1;
760                     unshift(@arguments, "impl()");
761                     $functionName = "${implementedBy}::${functionName}";
762                 } else {
763                     $functionName = "impl()->${functionName}";
764                 }
765                 push(@implContent, "    ${functionName}(" . join(", ", @arguments) . ");\n");
766                 push(@implContent, "    $exceptionRaiseOnError\n") if $hasSetterException;
767                 push(@implContent, "}\n\n");
768             }
769
770             push(@implContent, "#endif\n") if $attributeConditionalString;
771         }
772     }
773
774     # - Functions
775     if ($numFunctions > 0) {
776         foreach my $function (@{$dataNode->functions}) {
777             # Treat CPPPureInterface as Custom as well, since the WebCore versions will take a script context as well
778             next if ShouldSkipType($function) || $dataNode->extendedAttributes->{"CPPPureInterface"};
779             AddIncludesForType($function->signature->type);
780
781             my $functionName = $function->signature->name;
782             my $returnType = GetCPPType($function->signature->type, 0);
783             my $hasParameters = @{$function->parameters};
784             my $raisesExceptions = @{$function->raisesExceptions};
785
786             my @parameterNames = ();
787             my @needsAssert = ();
788             my %needsCustom = ();
789
790             my $parameterIndex = 0;
791
792             my $functionSig = "$returnType $className\:\:$functionName(";
793             foreach my $param (@{$function->parameters}) {
794                 my $paramName = $param->name;
795                 my $paramType = GetCPPType($param->type, 1);
796
797                 # make a new parameter name if the original conflicts with a property name
798                 $paramName = "in" . ucfirst($paramName) if $attributeNames{$paramName};
799
800                 AddIncludesForType($param->type);
801
802                 my $idlType = $codeGenerator->StripModule($param->type);
803                 my $implGetter = GetCPPTypeGetter($paramName, $idlType);
804
805                 push(@parameterNames, $implGetter);
806                 $needsCustom{"NodeToReturn"} = $paramName if $param->extendedAttributes->{"CustomReturn"};
807
808                 unless ($codeGenerator->IsPrimitiveType($idlType) or $codeGenerator->IsStringType($idlType)) {
809                     push(@needsAssert, "    ASSERT($paramName);\n");
810                 }
811
812                 $functionSig .= ", " if $parameterIndex >= 1;
813                 $functionSig .= "$paramType $paramName";
814                 $parameterIndex++;
815             }
816
817             $functionSig .= ")";
818
819             my @functionContent = ();
820             push(@parameterNames, "ec") if $raisesExceptions;
821
822             my $content;
823             if ($function->signature->extendedAttributes->{"ImplementedBy"}) {
824                 my $implementedBy = $function->signature->extendedAttributes->{"ImplementedBy"};
825                 $implIncludes{"${implementedBy}.h"} = 1;
826                 unshift(@parameterNames, "impl()");
827                 $content = "WebCore::${implementedBy}::" . $codeGenerator->WK_lcfirst($functionName) . "(" . join(", ", @parameterNames) . ")";
828             } else {
829                 $content = "impl()->" . $codeGenerator->WK_lcfirst($functionName) . "(" . join(", ", @parameterNames) . ")";
830             }
831
832             if ($returnType eq "void") {
833                 # Special case 'void' return type.
834                 if ($raisesExceptions) {
835                     push(@functionContent, "    $exceptionInit\n");
836                     push(@functionContent, "    $content;\n");
837                     push(@functionContent, "    $exceptionRaiseOnError\n");
838                 } else {
839                     push(@functionContent, "    $content;\n");
840                 }
841             } elsif (defined $needsCustom{"NodeToReturn"}) {
842                 # TODO: This is important to enable, once we care about custom code!
843
844                 # Special case the insertBefore, replaceChild, removeChild 
845                 # and appendChild functions from DOMNode 
846                 my $toReturn = $needsCustom{"NodeToReturn"};
847                 if ($raisesExceptions) {
848                     push(@functionContent, "    $exceptionInit\n");
849                     push(@functionContent, "    if ($content)\n");
850                     push(@functionContent, "        return $toReturn;\n");
851                     push(@functionContent, "    $exceptionRaiseOnError\n");
852                     push(@functionContent, "    return $className();\n");
853                 } else {
854                     push(@functionContent, "    if ($content)\n");
855                     push(@functionContent, "        return $toReturn;\n");
856                     push(@functionContent, "    return NULL;\n");
857                 }
858             } else {
859                 if (ConversionNeeded($function->signature->type)) {
860                     $content = "toWebKit(WTF::getPtr($content))";
861                 }
862
863                 if ($raisesExceptions) {
864                     # Differentiated between when the return type is a pointer and
865                     # not for white space issue (ie. Foo *result vs. int result).
866                     if ($returnType =~ /\*$/) {
867                         $content = $returnType . "result = " . $content;
868                     } else {
869                         $content = $returnType . " result = " . $content;
870                     }
871
872                     push(@functionContent, "    $exceptionInit\n");
873                     push(@functionContent, "    $content;\n");
874                     push(@functionContent, "    $exceptionRaiseOnError\n");
875                     push(@functionContent, "    return result;\n");
876                 } else {
877                     push(@functionContent, "    return $content;\n");
878                 }
879             }
880
881             my $conditionalString = $codeGenerator->GenerateConditionalString($function->signature);
882             push(@implContent, "\n#if ${conditionalString}\n") if $conditionalString;
883
884             push(@implContent, "$functionSig\n");
885             push(@implContent, "{\n");
886             push(@implContent, AddEarlyReturnStatement($returnType));
887             push(@implContent, @functionContent);
888             push(@implContent, "}\n\n");
889
890             push(@implContent, "#endif\n\n") if $conditionalString;
891
892             # Clear the hash
893             %needsCustom = ();
894         }
895     }
896
897     # END implementation
898
899     # Generate internal interfaces
900     my $namespace = GetNamespaceForClass($implClassName);
901     push(@implContent, "$namespace" . "::$implClassName* toWebCore(const $className& wrapper)\n");
902     push(@implContent, "{\n");
903     push(@implContent, "    return wrapper.impl();\n");
904     push(@implContent, "}\n\n");
905
906     push(@implContent, "$className toWebKit($namespace" . "::$implClassName* value)\n");
907     push(@implContent, "{\n");
908     push(@implContent, "    return $className(value);\n");
909     push(@implContent, "}\n");
910
911     # - End the ifdef conditional if necessary
912     push(@implContent, "\n#endif // ${conditionalString}\n") if $conditionalString;
913 }
914
915 # Internal helper
916 sub WriteData
917 {
918     my $object = shift;
919     my $name = shift;
920
921     # Open files for writing...
922     my $headerFileName = "$outputDir/" . $name . ".h";
923     my $implFileName = "$outputDir/" . $name . ".cpp";
924
925     # Update a .h file if the contents are changed.
926     my $contents = join "", @headerContentHeader;
927     $contents .= "\n";
928     foreach my $class (sort keys(%headerForwardDeclarations)) {
929         if ($class =~ /::/) {
930             my $namespacePart = $class;
931             $namespacePart =~ s/::.*//;
932
933             my $classPart = $class;
934             $classPart =~ s/${namespacePart}:://;
935
936             $contents .= "namespace $namespacePart {\nclass $classPart;\n};\n\n";
937         } else {
938             $contents .= "class $class;\n"
939         }
940     }
941
942     my $hasForwardDeclarations = keys(%headerForwardDeclarations);
943     $contents .= "\n" if $hasForwardDeclarations;
944     $contents .= join "", @headerContent;
945     $codeGenerator->UpdateFile($headerFileName, $contents);
946
947     @headerContentHeader = ();
948     @headerContent = ();
949     %headerForwardDeclarations = ();
950
951     # Update a .cpp file if the contents are changed.
952     $contents = join "", @implContentHeader;
953
954     foreach my $include (sort keys(%implIncludes)) {
955         # "className.h" is already included right after config.h, silence check-webkit-style
956         next if $include eq "$name.h";
957         $contents .= "#include \"$include\"\n";
958     }
959
960     $contents .= join "", @implContent;
961     $codeGenerator->UpdateFile($implFileName, $contents);
962
963     @implContentHeader = ();
964     @implContent = ();
965     %implIncludes = ();
966 }
967
968 1;