Remove CodeGenerator::StripModule
[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 = 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
148     return "WebDOM$name";
149 }
150
151 sub GetImplClassName
152 {
153     return shift;
154 }
155
156 sub GetParentImplClassName
157 {
158     my $dataNode = shift;
159
160     if (@{$dataNode->parents} eq 0) {
161         return "EventTarget" if $dataNode->extendedAttributes->{"EventTarget"};
162         return "Object";
163     }
164
165     return $dataNode->parents(0);
166 }
167
168 sub GetParent
169 {
170     my $dataNode = shift;
171     my $numParents = @{$dataNode->parents};
172
173     my $parent = "";
174     if ($numParents eq 0) {
175         $parent = "WebDOMObject";
176         $parent = "WebDOMEventTarget" if $dataNode->extendedAttributes->{"EventTarget"};
177     } elsif ($numParents eq 1) {
178         my $parentName = $dataNode->parents(0);
179         $parent = "WebDOM" . $parentName;
180     } else {
181         my @parents = @{$dataNode->parents};
182         my $firstParent = shift(@parents);
183         $parent = "WebDOM" . $firstParent;
184     }
185
186     return $parent;
187 }
188
189 sub SkipFunction
190 {
191     my $function = shift;
192
193     return 1 if $function->signature->extendedAttributes->{"Custom"};
194
195     # FIXME: We don't generate bindings for SVG related interfaces yet
196     return 1 if $function->signature->name =~ /getSVGDocument/;
197
198     if ($codeGenerator->GetArrayType($function->signature->type)) {
199         return 1;
200     }
201
202     if ($codeGenerator->GetSequenceType($function->signature->type)) {
203         return 1;
204     }
205
206     foreach my $param (@{$function->parameters}) {
207         return 1 if $codeGenerator->GetSequenceType($param->type);
208         return 1 if $param->extendedAttributes->{"Clamp"};
209     }
210
211     # FIXME: This is typically used to add script execution state arguments to the method.
212     # These functions will not compile with the C++ bindings as is, so disable them
213     # to restore compilation until a proper implementation can be developed.
214     return 1 if $function->signature->extendedAttributes->{"CallWith"};
215 }
216
217 sub SkipAttribute
218 {
219     my $attribute = shift;
220
221     return 1 if $attribute->signature->extendedAttributes->{"Custom"}
222                 or $attribute->signature->extendedAttributes->{"CustomGetter"};
223
224     return 1 if $attribute->signature->type =~ /Constructor$/;
225
226     return 1 if $codeGenerator->IsTypedArrayType($attribute->signature->type);
227
228     if ($codeGenerator->GetArrayType($attribute->signature->type)) {
229         return 1;
230     }
231
232     if ($codeGenerator->GetSequenceType($attribute->signature->type)) {
233         return 1;
234     }
235
236     $codeGenerator->AssertNotSequenceType($attribute->signature->type);
237
238     # FIXME: This is typically used to add script execution state arguments to the method.
239     # These functions will not compile with the C++ bindings as is, so disable them
240     # to restore compilation until a proper implementation can be developed.
241     return 1 if $attribute->signature->extendedAttributes->{"CallWith"};
242
243     return 0;
244 }
245
246 sub GetCPPType
247 {
248     my $type = shift;
249     my $useConstReference = shift;
250     my $name = GetClassName($type);
251
252     return "int" if $type eq "long";
253     return "unsigned" if $name eq "unsigned long";
254     return "unsigned short" if $type eq "CompareHow";
255     return "double" if $name eq "Date";
256
257     if ($codeGenerator->IsStringType($type)) {
258         if ($useConstReference) {
259             return "const $name&";
260         }
261
262         return $name;
263     }
264
265     return $name if $codeGenerator->IsPrimitiveType($type) or $type eq "DOMTimeStamp";
266     return "const $name&" if $useConstReference;
267     return $name;
268 }
269
270 sub ConversionNeeded
271 {
272     my $type = shift;
273     return !$codeGenerator->IsNonPointerType($type) && !$codeGenerator->IsStringType($type);
274 }
275
276 sub GetCPPTypeGetter
277 {
278     my $argName = shift;
279     my $type = shift;
280
281     return $argName if $codeGenerator->IsPrimitiveType($type) or $codeGenerator->IsStringType($type);
282     return "static_cast<WebCore::Range::CompareHow>($argName)" if $type eq "CompareHow";
283     return "WebCore::SerializedScriptValue::create(WTF::String($argName))" if $type eq "SerializedScriptValue";
284     return "to" . GetNamespaceForClass($argName) . "($argName)";
285 }
286
287 sub AddForwardDeclarationsForType
288 {
289     my $type = shift;
290     my $public = shift;
291
292     return if $codeGenerator->IsNonPointerType($type) or $codeGenerator->IsStringType($type);
293
294     my $class = GetClassName($type);
295     $headerForwardDeclarations{$class} = 1 if $public;
296 }
297
298 sub AddIncludesForType
299 {
300     my $type = shift;
301
302     return if $codeGenerator->GetSequenceType($type);
303     return if $codeGenerator->GetArrayType($type);
304     return if $codeGenerator->IsNonPointerType($type);
305     return if $type =~ /Constructor/;
306
307     if ($codeGenerator->IsStringType($type)) {
308         $implIncludes{"wtf/text/AtomicString.h"} = 1;
309         $implIncludes{"KURL.h"} = 1;
310         $implIncludes{"WebDOMString.h"} = 1;
311         return;
312     }
313
314     if ($type eq "DOMObject") {
315         $implIncludes{"WebDOMObject.h"} = 1;
316         return;
317     }
318
319     if ($type eq "EventListener") {
320         $implIncludes{"WebNativeEventListener.h"} = 1;
321         return;
322     }
323
324     if ($type eq "SerializedScriptValue") {
325         $implIncludes{"SerializedScriptValue.h"} = 1;
326         return;
327     }
328
329     # Also include CSSImportRule so that the toWebKit methods for subclasses are found
330     if ($type eq "CSSRule") {
331         $implIncludes{"WebDOMCSSImportRule.h"} = 1;
332     }
333
334     $implIncludes{"Node.h"} = 1 if $type eq "NodeList";
335     $implIncludes{"StylePropertySet.h"} = 1 if $type eq "CSSStyleDeclaration";
336
337     # Default, include the same named file (the implementation) and the same name prefixed with "WebDOM". 
338     $implIncludes{"$type.h"} = 1 unless $type eq "DOMObject";
339     $implIncludes{"WebDOM$type.h"} = 1;
340 }
341
342 sub GetNamespaceForClass
343 {
344     my $type = shift;
345     return "WTF" if (($type eq "ArrayBuffer") or ($type eq "ArrayBufferView")); 
346     return "WTF" if (($type eq "Uint8Array") or ($type eq "Uint8ClampedArray") or ($type eq "Uint16Array") or ($type eq "Uint32Array")); 
347     return "WTF" if (($type eq "Int8Array") or ($type eq "Int16Array") or ($type eq "Int32Array")); 
348     return "WTF" if (($type eq "Float32Array") or ($type eq "Float64Array"));    
349     return "WebCore";
350 }
351
352 sub GenerateHeader
353 {
354     my $object = shift;
355     my $dataNode = shift;
356
357     my $interfaceName = $dataNode->name;
358     my $className = GetClassName($interfaceName);
359     my $implClassName = GetImplClassName($interfaceName);
360     
361     my $implClassNameWithNamespace = GetNamespaceForClass($implClassName) . "::" . $implClassName;
362
363     my $parentName = "";
364     $parentName = GetParent($dataNode);
365
366     my $numConstants = @{$dataNode->constants};
367     my $numAttributes = @{$dataNode->attributes};
368     my $numFunctions = @{$dataNode->functions};
369
370     # - Add default header template
371     @headerContentHeader = split("\r", $headerLicenseTemplate);
372     push(@headerContentHeader, "\n#ifndef $className" . "_h");
373     push(@headerContentHeader, "\n#define $className" . "_h\n\n");
374
375     my $conditionalString = $codeGenerator->GenerateConditionalString($dataNode);
376     push(@headerContentHeader, "#if ${conditionalString}\n\n") if $conditionalString;
377
378     # - INCLUDES -
379
380     my %headerIncludes = ();
381     $headerIncludes{"WebDOMString.h"} = 1;
382     $headerIncludes{"$parentName.h"} = 1;
383     foreach my $include (sort keys(%headerIncludes)) {
384         push(@headerContentHeader, "#include <$include>\n");
385     }
386
387     push(@headerContent, "class $className");
388     push(@headerContent, " : public $parentName") if $parentName;
389     push(@headerContent, " {\n");
390     push(@headerContent, "public:\n");
391
392     # Constructor
393     push(@headerContent, "    $className();\n");
394     push(@headerContent, "    explicit $className($implClassNameWithNamespace*);\n");
395
396     # Copy constructor and assignment operator on classes which have the d-ptr
397     if ($parentName eq "WebDOMObject") {
398         push(@headerContent, "    $className(const $className&);\n");
399         push(@headerContent, "    ${className}& operator=(const $className&);\n");
400     }
401
402     # Destructor
403     if ($parentName eq "WebDOMObject") {
404         push(@headerContent, "    virtual ~$className();\n");
405     } else {
406         push(@headerContent, "    virtual ~$className() { }\n");
407     }
408
409     push(@headerContent, "\n");
410     $headerForwardDeclarations{$implClassNameWithNamespace} = 1;
411
412     # - Add constants.
413     if ($numConstants > 0) {
414         my @headerConstants = ();
415         my @constants = @{$dataNode->constants};
416         my $combinedConstants = "";
417
418         # FIXME: we need a way to include multiple enums.
419         foreach my $constant (@constants) {
420             my $constantName = $constant->name;
421             my $constantValue = $constant->value;
422             my $conditional = $constant->extendedAttributes->{"Conditional"};
423             my $notLast = $constant ne $constants[-1];
424
425             if ($conditional) {
426                 my $conditionalString = $codeGenerator->GenerateConditionalStringFromAttributeValue($conditional);
427                 $combinedConstants .= "#if ${conditionalString}\n";
428             }
429             $combinedConstants .= "        WEBDOM_$constantName = $constantValue";
430             $combinedConstants .= "," if $notLast;
431             if ($conditional) {
432                 $combinedConstants .= "\n#endif\n";
433             } elsif ($notLast) {
434                 $combinedConstants .= "\n";
435             }
436         }
437
438         push(@headerContent, "    ");
439         push(@headerContent, "enum {\n");
440         push(@headerContent, $combinedConstants);
441         push(@headerContent, "\n    ");
442         push(@headerContent, "};\n\n");
443     }
444
445     my @headerAttributes = ();
446
447     # - Add attribute getters/setters.
448     if ($numAttributes > 0) {
449         foreach my $attribute (@{$dataNode->attributes}) {
450             next if SkipAttribute($attribute);
451
452             my $attributeConditionalString = $codeGenerator->GenerateConditionalString($attribute->signature);
453             my $attributeName = $attribute->signature->name;
454             my $attributeType = GetCPPType($attribute->signature->type, 0);
455             my $attributeIsReadonly = ($attribute->type =~ /^readonly/);
456             my $property = "";
457             
458             $property .= "#if ${attributeConditionalString}\n" if $attributeConditionalString;
459             $property .= "    " . $attributeType . ($attributeType =~ /\*$/ ? "" : " ") . $attributeName . "() const";
460
461             my $availabilityMacro = "";
462             my $declarationSuffix = ";\n";
463
464             AddForwardDeclarationsForType($attribute->signature->type, 1);
465
466             $attributeType = GetCPPType($attribute->signature->type, 1);
467             my $setterName = "set" . ucfirst($attributeName);
468
469             $property .= $declarationSuffix;
470             push(@headerAttributes, $property);
471             if (!$attributeIsReadonly and !$attribute->signature->extendedAttributes->{"Replaceable"}) {
472                 $property = "    void $setterName($attributeType)";
473                 $property .= $declarationSuffix;
474                 push(@headerAttributes, $property); 
475             }
476
477             push(@headerAttributes, "#endif\n") if $attributeConditionalString;
478         }
479         push(@headerContent, @headerAttributes) if @headerAttributes > 0;
480     }
481
482     my @headerFunctions = ();
483     my @deprecatedHeaderFunctions = ();
484     my @interfaceFunctions = ();
485
486     # - Add functions.
487     if ($numFunctions > 0) {
488         foreach my $function (@{$dataNode->functions}) {
489             next if SkipFunction($function);
490             next if ($function->signature->name eq "set" and $dataNode->extendedAttributes->{"TypedArray"});
491             my $functionName = $function->signature->extendedAttributes->{"ImplementedAs"} || $function->signature->name;
492
493             my $returnType = GetCPPType($function->signature->type, 0);
494             my $numberOfParameters = @{$function->parameters};
495             my %typesToForwardDeclare = ($function->signature->type => 1);
496
497             my $parameterIndex = 0;
498             my $functionSig = "$returnType $functionName(";
499             my $methodName = $functionName;
500             foreach my $param (@{$function->parameters}) {
501                 my $paramName = $param->name;
502                 my $paramType = GetCPPType($param->type, 1);
503                 $typesToForwardDeclare{$param->type} = 1;
504
505                 $functionSig .= ", " if $parameterIndex >= 1;
506                 $functionSig .= "$paramType $paramName";
507                 $parameterIndex++;
508             }
509             $functionSig .= ")";
510             if ($dataNode->extendedAttributes->{"CPPPureInterface"}) {
511                 push(@interfaceFunctions, "    virtual " . $functionSig . " = 0;\n");
512             }
513             my $functionDeclaration = $functionSig;
514             $functionDeclaration .= ";\n";
515
516             foreach my $type (keys %typesToForwardDeclare) {
517                 # add any forward declarations to the public header if a deprecated version will be generated
518                 AddForwardDeclarationsForType($type, 1);
519             }
520
521             my $conditionalString = $codeGenerator->GenerateConditionalString($function->signature);
522             push(@headerFunctions, "#if ${conditionalString}\n") if $conditionalString;
523             push(@headerFunctions, "    ");
524             push(@headerFunctions, $functionDeclaration);
525             push(@headerFunctions, "#endif\n") if $conditionalString;
526         }
527
528         if (@headerFunctions > 0) {
529             push(@headerContent, "\n") if @headerAttributes > 0;
530             push(@headerContent, @headerFunctions);
531         }
532     }
533
534     push(@headerContent, "\n");
535     push(@headerContent, "    $implClassNameWithNamespace* impl() const;\n");
536
537     if ($parentName eq "WebDOMObject") {
538         push(@headerContent, "\nprotected:\n");
539         push(@headerContent, "    struct ${className}Private;\n");
540         push(@headerContent, "    ${className}Private* m_impl;\n");
541     }
542
543     push(@headerContent, "};\n\n");
544
545     # for CPPPureInterface classes also add the interface that the client code needs to
546     # implement
547     if ($dataNode->extendedAttributes->{"CPPPureInterface"}) {
548         push(@headerContent, "class WebUser$interfaceName {\n");
549         push(@headerContent, "public:\n");
550         push(@headerContent, "    virtual void ref() = 0;\n");
551         push(@headerContent, "    virtual void deref() = 0;\n\n");
552         push(@headerContent, @interfaceFunctions);
553         push(@headerContent, "\nprotected:\n");
554         push(@headerContent, "    virtual ~WebUser$interfaceName() {}\n");
555         push(@headerContent, "};\n\n");
556     }
557
558     my $namespace = GetNamespaceForClass($implClassName);
559     push(@headerContent, "$namespace" . "::$implClassName* toWebCore(const $className&);\n");
560     push(@headerContent, "$className toWebKit($namespace" . "::$implClassName*);\n");
561     if ($dataNode->extendedAttributes->{"CPPPureInterface"}) {
562         push(@headerContent, "$className toWebKit(WebUser$interfaceName*);\n");
563     }
564     push(@headerContent, "\n#endif\n");
565     push(@headerContent, "#endif // ${conditionalString}\n\n") if $conditionalString;
566 }
567
568 sub AddEarlyReturnStatement
569 {
570     my $returnType = shift;
571
572     if (!defined($returnType) or $returnType eq "void") {
573         $returnType = "";
574     } elsif ($codeGenerator->IsPrimitiveType($returnType)) {
575         $returnType = " 0";
576     } elsif ($returnType eq "bool") {
577         $returnType = " false";
578     } else {
579         $returnType = " $returnType()";
580     }
581
582     # TODO: We could set exceptions here, if we want that
583     my $statement = "    if (!impl())\n";
584     $statement .=   "        return$returnType;\n\n";
585     return $statement;
586 }
587
588 sub AddReturnStatement
589 {
590     my $typeInfo = shift;
591     my $returnValue = shift;
592
593     # Used to invoke KURLs "const String&" operator
594     if ($codeGenerator->IsStringType($typeInfo->signature->type)) {
595         return "    return static_cast<const WTF::String&>($returnValue);\n";
596     }
597
598     return "    return $returnValue;\n";
599 }
600
601 sub GenerateImplementation
602 {
603     my $object = shift;
604     my $dataNode = shift;
605
606     my @ancestorInterfaceNames = ();
607
608     if (@{$dataNode->parents} > 1) {
609         $codeGenerator->AddMethodsConstantsAndAttributesFromParentClasses($dataNode, \@ancestorInterfaceNames);
610     }
611
612     my $interfaceName = $dataNode->name;
613     my $className = GetClassName($interfaceName);
614     my $implClassName = GetImplClassName($interfaceName);
615     my $parentImplClassName = GetParentImplClassName($dataNode);
616     my $implClassNameWithNamespace = GetNamespaceForClass($implClassName) . "::" . $implClassName;
617     my $baseClass = "WebDOM$parentImplClassName";
618     my $conditional = $dataNode->extendedAttributes->{"Conditional"};
619
620     my $numAttributes = @{$dataNode->attributes};
621     my $numFunctions = @{$dataNode->functions};
622
623     # - Add default header template.
624     @implContentHeader = split("\r", $implementationLicenseTemplate);
625
626     # - INCLUDES -
627     push(@implContentHeader, "\n#include \"config.h\"\n");
628     my $conditionalString = $codeGenerator->GenerateConditionalString($dataNode);
629     push(@implContentHeader, "\n#if ${conditionalString}\n\n") if $conditionalString;
630     push(@implContentHeader, "#include \"$className.h\"\n\n");
631
632     $implIncludes{"WebExceptionHandler.h"} = 1;
633     $implIncludes{"$implClassName.h"} = 1;
634     @implContent = ();
635
636     push(@implContent, "#include <wtf/GetPtr.h>\n");
637     push(@implContent, "#include <wtf/RefPtr.h>\n\n");
638
639     # Private datastructure, encapsulating WebCore types
640     if ($baseClass eq "WebDOMObject") {
641         push(@implContent, "struct ${className}::${className}Private {\n");
642         push(@implContent, "    ${className}Private($implClassNameWithNamespace* object = 0)\n");
643         push(@implContent, "        : impl(object)\n");
644         push(@implContent, "    {\n");
645         push(@implContent, "    }\n\n");
646         push(@implContent, "    RefPtr<$implClassNameWithNamespace> impl;\n");
647         push(@implContent, "};\n\n");
648     }
649
650     # Constructor
651     push(@implContent, "${className}::$className()\n");
652     push(@implContent, "    : ${baseClass}()\n");
653     push(@implContent, "    , m_impl(0)\n") if ($baseClass eq "WebDOMObject");
654     push(@implContent, "{\n");
655     push(@implContent, "}\n\n");
656
657     push(@implContent, "${className}::$className($implClassNameWithNamespace* impl)\n");
658     if ($baseClass eq "WebDOMObject") {
659         push(@implContent, "    : ${baseClass}()\n");
660         push(@implContent, "    , m_impl(new ${className}Private(impl))\n");
661         push(@implContent, "{\n");
662         push(@implContent, "}\n\n");
663
664         push(@implContent, "${className}::${className}(const ${className}& copy)\n");
665         push(@implContent, "    : ${baseClass}()\n");
666         push(@implContent, "{\n");
667         push(@implContent, "    m_impl = copy.impl() ? new ${className}Private(copy.impl()) : 0;\n");
668         push(@implContent, "}\n\n");
669
670         push(@implContent, "${className}& ${className}::operator\=(const ${className}& copy)\n");
671         push(@implContent, "{\n");
672         push(@implContent, "    delete m_impl;\n");
673         push(@implContent, "    m_impl = copy.impl() ? new ${className}Private(copy.impl()) : 0;\n");
674         push(@implContent, "    return *this;\n");
675         push(@implContent, "}\n\n");
676
677         push(@implContent, "$implClassNameWithNamespace* ${className}::impl() const\n");
678         push(@implContent, "{\n");
679         push(@implContent, "    return m_impl ? WTF::getPtr(m_impl->impl) : 0;\n");
680         push(@implContent, "}\n\n");
681
682         # Destructor
683         push(@implContent, "${className}::~$className()\n");
684         push(@implContent, "{\n");
685         push(@implContent, "    delete m_impl;\n");
686         push(@implContent, "    m_impl = 0;\n");
687         push(@implContent, "}\n\n");
688     } else {
689         push(@implContent, "    : ${baseClass}(impl)\n");
690         push(@implContent, "{\n");
691         push(@implContent, "}\n\n");
692
693         push(@implContent, "$implClassNameWithNamespace* ${className}::impl() const\n");
694         push(@implContent, "{\n");
695         push(@implContent, "    return static_cast<$implClassNameWithNamespace*>(${baseClass}::impl());\n");
696         push(@implContent, "}\n\n");
697     }
698
699     # START implementation
700     %attributeNames = ();
701
702     # - Attributes
703     if ($numAttributes > 0) {
704         foreach my $attribute (@{$dataNode->attributes}) {
705             next if SkipAttribute($attribute);
706             AddIncludesForType($attribute->signature->type);
707
708             my $idlType = $attribute->signature->type;
709
710             my $attributeName = $attribute->signature->name;
711             my $attributeType = GetCPPType($attribute->signature->type, 0);
712             my $attributeIsReadonly = ($attribute->type =~ /^readonly/);
713
714             $attributeNames{$attributeName} = 1;
715
716             # - GETTER
717             my $getterSig = "$attributeType $className\:\:$attributeName() const\n";
718             my $hasGetterException = @{$attribute->getterExceptions};
719             my ($functionName, @arguments) = $codeGenerator->GetterExpression(\%implIncludes, $interfaceName, $attribute);
720             push(@arguments, "ec") if $hasGetterException;
721             if ($attribute->signature->extendedAttributes->{"ImplementedBy"}) {
722                 my $implementedBy = $attribute->signature->extendedAttributes->{"ImplementedBy"};
723                 $implIncludes{"${implementedBy}.h"} = 1;
724                 unshift(@arguments, "impl()");
725                 $functionName = "${implementedBy}::${functionName}";
726             } else {
727                 $functionName = "impl()->${functionName}";
728             }
729
730             # Special cases
731             my $getterContentHead = "";
732             my $getterContentTail = "";
733             my @customGetterContent = (); 
734             if ($attribute->signature->extendedAttributes->{"ConvertToString"}) {
735                 $getterContentHead = "WTF::String::number(";
736                 $getterContentTail = ")";
737             } elsif ($attribute->signature->type eq "SerializedScriptValue") {
738                 $getterContentTail = "->toString()";
739             } elsif (ConversionNeeded($attribute->signature->type)) {
740                 $getterContentHead = "toWebKit(WTF::getPtr(";
741                 $getterContentTail = "))";
742             }
743
744             my $getterContent = "${getterContentHead}${functionName}(" . join(", ", @arguments) . ")${getterContentTail}";
745             my $attributeConditionalString = $codeGenerator->GenerateConditionalString($attribute->signature);
746             push(@implContent, "#if ${attributeConditionalString}\n") if $attributeConditionalString;
747
748             push(@implContent, $getterSig);
749             push(@implContent, "{\n");
750             push(@implContent, AddEarlyReturnStatement($attributeType));
751             push(@implContent, @customGetterContent);
752             if ($hasGetterException) {
753                 # Differentiated between when the return type is a pointer and
754                 # not for white space issue (ie. Foo *result vs. int result).
755                 if ($attributeType =~ /\*$/) {
756                     $getterContent = $attributeType . "result = " . $getterContent;
757                 } else {
758                     $getterContent = $attributeType . " result = " . $getterContent;
759                 }
760
761                 push(@implContent, "    $exceptionInit\n");
762                 push(@implContent, "    $getterContent;\n");
763                 push(@implContent, "    $exceptionRaiseOnError\n");
764                 push(@implContent, AddReturnStatement($attribute, "result"));
765             } else {
766                 push(@implContent, AddReturnStatement($attribute, $getterContent));
767             }
768             push(@implContent, "}\n\n");
769
770             # - SETTER
771             if (!$attributeIsReadonly and !$attribute->signature->extendedAttributes->{"Replaceable"}) {
772                 # Exception handling
773                 my $hasSetterException = @{$attribute->setterExceptions};
774
775                 my $coreSetterName = "set" . $codeGenerator->WK_ucfirst($attributeName);
776                 my $setterName = "set" . ucfirst($attributeName);
777                 my $argName = "new" . ucfirst($attributeName);
778                 my $arg = GetCPPTypeGetter($argName, $idlType);
779
780                 my $attributeType = GetCPPType($attribute->signature->type, 1);
781                 push(@implContent, "void $className\:\:$setterName($attributeType $argName)\n");
782                 push(@implContent, "{\n");
783                 push(@implContent, AddEarlyReturnStatement());
784
785                 push(@implContent, "    $exceptionInit\n") if $hasSetterException;
786
787                 my ($functionName, @arguments) = $codeGenerator->SetterExpression(\%implIncludes, $interfaceName, $attribute);
788                 push(@arguments, $arg);
789                 push(@arguments, "ec") if $hasSetterException;
790                 if ($attribute->signature->extendedAttributes->{"ImplementedBy"}) {
791                     my $implementedBy = $attribute->signature->extendedAttributes->{"ImplementedBy"};
792                     $implIncludes{"${implementedBy}.h"} = 1;
793                     unshift(@arguments, "impl()");
794                     $functionName = "${implementedBy}::${functionName}";
795                 } else {
796                     $functionName = "impl()->${functionName}";
797                 }
798                 push(@implContent, "    ${functionName}(" . join(", ", @arguments) . ");\n");
799                 push(@implContent, "    $exceptionRaiseOnError\n") if $hasSetterException;
800                 push(@implContent, "}\n\n");
801             }
802
803             push(@implContent, "#endif\n") if $attributeConditionalString;
804         }
805     }
806
807     # - Functions
808     if ($numFunctions > 0) {
809         foreach my $function (@{$dataNode->functions}) {
810             # Treat CPPPureInterface as Custom as well, since the WebCore versions will take a script context as well
811             next if SkipFunction($function) || $dataNode->extendedAttributes->{"CPPPureInterface"};
812             next if ($function->signature->name eq "set" and $dataNode->extendedAttributes->{"TypedArray"});
813             AddIncludesForType($function->signature->type);
814
815             my $functionName = $function->signature->name;
816             my $returnType = GetCPPType($function->signature->type, 0);
817             my $hasParameters = @{$function->parameters};
818             my $raisesExceptions = @{$function->raisesExceptions};
819
820             my @parameterNames = ();
821             my @needsAssert = ();
822             my %needsCustom = ();
823
824             my $parameterIndex = 0;
825
826             my $functionSig = "$returnType $className\:\:$functionName(";
827             foreach my $param (@{$function->parameters}) {
828                 my $paramName = $param->name;
829                 my $paramType = GetCPPType($param->type, 1);
830
831                 # make a new parameter name if the original conflicts with a property name
832                 $paramName = "in" . ucfirst($paramName) if $attributeNames{$paramName};
833
834                 AddIncludesForType($param->type);
835
836                 my $idlType = $param->type;
837                 my $implGetter = GetCPPTypeGetter($paramName, $idlType);
838
839                 push(@parameterNames, $implGetter);
840                 $needsCustom{"NodeToReturn"} = $paramName if $param->extendedAttributes->{"CustomReturn"};
841
842                 unless ($codeGenerator->IsPrimitiveType($idlType) or $codeGenerator->IsStringType($idlType)) {
843                     push(@needsAssert, "    ASSERT($paramName);\n");
844                 }
845
846                 $functionSig .= ", " if $parameterIndex >= 1;
847                 $functionSig .= "$paramType $paramName";
848                 $parameterIndex++;
849             }
850
851             $functionSig .= ")";
852
853             my @functionContent = ();
854             push(@parameterNames, "ec") if $raisesExceptions;
855
856             my $content;
857             if ($function->signature->extendedAttributes->{"ImplementedBy"}) {
858                 my $implementedBy = $function->signature->extendedAttributes->{"ImplementedBy"};
859                 $implIncludes{"${implementedBy}.h"} = 1;
860                 unshift(@parameterNames, "impl()");
861                 $content = "WebCore::${implementedBy}::" . $codeGenerator->WK_lcfirst($functionName) . "(" . join(", ", @parameterNames) . ")";
862             } else {
863                 $content = "impl()->" . $codeGenerator->WK_lcfirst($functionName) . "(" . join(", ", @parameterNames) . ")";
864             }
865
866             if ($returnType eq "void") {
867                 # Special case 'void' return type.
868                 if ($raisesExceptions) {
869                     push(@functionContent, "    $exceptionInit\n");
870                     push(@functionContent, "    $content;\n");
871                     push(@functionContent, "    $exceptionRaiseOnError\n");
872                 } else {
873                     push(@functionContent, "    $content;\n");
874                 }
875             } elsif (defined $needsCustom{"NodeToReturn"}) {
876                 # TODO: This is important to enable, once we care about custom code!
877
878                 # Special case the insertBefore, replaceChild, removeChild 
879                 # and appendChild functions from DOMNode 
880                 my $toReturn = $needsCustom{"NodeToReturn"};
881                 if ($raisesExceptions) {
882                     push(@functionContent, "    $exceptionInit\n");
883                     push(@functionContent, "    if ($content)\n");
884                     push(@functionContent, "        return $toReturn;\n");
885                     push(@functionContent, "    $exceptionRaiseOnError\n");
886                     push(@functionContent, "    return $className();\n");
887                 } else {
888                     push(@functionContent, "    if ($content)\n");
889                     push(@functionContent, "        return $toReturn;\n");
890                     push(@functionContent, "    return NULL;\n");
891                 }
892             } else {
893                 if (ConversionNeeded($function->signature->type)) {
894                     $content = "toWebKit(WTF::getPtr($content))";
895                 }
896
897                 if ($raisesExceptions) {
898                     # Differentiated between when the return type is a pointer and
899                     # not for white space issue (ie. Foo *result vs. int result).
900                     if ($returnType =~ /\*$/) {
901                         $content = $returnType . "result = " . $content;
902                     } else {
903                         $content = $returnType . " result = " . $content;
904                     }
905
906                     push(@functionContent, "    $exceptionInit\n");
907                     push(@functionContent, "    $content;\n");
908                     push(@functionContent, "    $exceptionRaiseOnError\n");
909                     push(@functionContent, "    return result;\n");
910                 } else {
911                     push(@functionContent, "    return $content;\n");
912                 }
913             }
914
915             my $conditionalString = $codeGenerator->GenerateConditionalString($function->signature);
916             push(@implContent, "\n#if ${conditionalString}\n") if $conditionalString;
917
918             push(@implContent, "$functionSig\n");
919             push(@implContent, "{\n");
920             push(@implContent, AddEarlyReturnStatement($returnType));
921             push(@implContent, @functionContent);
922             push(@implContent, "}\n\n");
923
924             push(@implContent, "#endif\n\n") if $conditionalString;
925
926             # Clear the hash
927             %needsCustom = ();
928         }
929     }
930
931     # END implementation
932
933     # Generate internal interfaces
934     my $namespace = GetNamespaceForClass($implClassName);
935     push(@implContent, "$namespace" . "::$implClassName* toWebCore(const $className& wrapper)\n");
936     push(@implContent, "{\n");
937     push(@implContent, "    return wrapper.impl();\n");
938     push(@implContent, "}\n\n");
939
940     push(@implContent, "$className toWebKit($namespace" . "::$implClassName* value)\n");
941     push(@implContent, "{\n");
942     push(@implContent, "    return $className(value);\n");
943     push(@implContent, "}\n");
944
945     # - End the ifdef conditional if necessary
946     push(@implContent, "\n#endif // ${conditionalString}\n") if $conditionalString;
947 }
948
949 # Internal helper
950 sub WriteData
951 {
952     my $object = shift;
953     my $name = shift;
954
955     # Open files for writing...
956     my $headerFileName = "$outputDir/" . $name . ".h";
957     my $implFileName = "$outputDir/" . $name . ".cpp";
958
959     # Update a .h file if the contents are changed.
960     my $contents = join "", @headerContentHeader;
961     $contents .= "\n";
962     foreach my $class (sort keys(%headerForwardDeclarations)) {
963         if ($class =~ /::/) {
964             my $namespacePart = $class;
965             $namespacePart =~ s/::.*//;
966
967             my $classPart = $class;
968             $classPart =~ s/${namespacePart}:://;
969
970             $contents .= "namespace $namespacePart {\nclass $classPart;\n};\n\n";
971         } else {
972             $contents .= "class $class;\n"
973         }
974     }
975
976     my $hasForwardDeclarations = keys(%headerForwardDeclarations);
977     $contents .= "\n" if $hasForwardDeclarations;
978     $contents .= join "", @headerContent;
979     $codeGenerator->UpdateFile($headerFileName, $contents);
980
981     @headerContentHeader = ();
982     @headerContent = ();
983     %headerForwardDeclarations = ();
984
985     # Update a .cpp file if the contents are changed.
986     $contents = join "", @implContentHeader;
987
988     foreach my $include (sort keys(%implIncludes)) {
989         # "className.h" is already included right after config.h, silence check-webkit-style
990         next if $include eq "$name.h";
991         $contents .= "#include \"$include\"\n";
992     }
993
994     $contents .= join "", @implContent;
995     $codeGenerator->UpdateFile($implFileName, $contents);
996
997     @implContentHeader = ();
998     @implContent = ();
999     %implIncludes = ();
1000 }
1001
1002 1;