Add Element.matches, the standard name for webkitMatchesSelector
[WebKit-https.git] / Source / WebCore / bindings / scripts / CodeGeneratorObjC.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, 2010 Apple Inc. All rights reserved.
7 # Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
8 # Copyright (C) 2010 Google Inc.
9 # Copyright (C) Research In Motion Limited 2010. All rights reserved.
10 #
11 # This library is free software; you can redistribute it and/or
12 # modify it under the terms of the GNU Library General Public
13 # License as published by the Free Software Foundation; either
14 # version 2 of the License, or (at your option) any later version.
15
16 # This library is distributed in the hope that it will be useful,
17 # but WITHOUT ANY WARRANTY; without even the implied warranty of
18 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 # Library General Public License for more details.
20
21 # You should have received a copy of the GNU Library General Public License
22 # along with this library; see the file COPYING.LIB.  If not, write to
23 # the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
24 # Boston, MA 02110-1301, USA.
25 #
26
27 package CodeGeneratorObjC;
28
29 use constant FileNamePrefix => "DOM";
30
31 sub ConditionalIsEnabled(\%$);
32
33 # Global Variables
34 my $writeDependencies = 0;
35 my %publicInterfaces = ();
36 my $newPublicClass = 0;
37 my $interfaceAvailabilityVersion = "";
38 my $isProtocol = 0;
39 my $noImpl = 0;
40
41 my @headerContentHeader = ();
42 my @headerContent = ();
43 my %headerForwardDeclarations = ();
44 my %headerForwardDeclarationsForProtocols = ();
45
46 my @privateHeaderContentHeader = ();
47 my @privateHeaderContent = ();
48 my %privateHeaderForwardDeclarations = ();
49 my %privateHeaderForwardDeclarationsForProtocols = ();
50
51 my @internalHeaderContent = ();
52
53 my @implConditionalIncludes = ();
54 my @implContentHeader = ();
55 my @implContent = ();
56 my %implIncludes = ();
57 my @depsContent = ();
58
59 my $beginAppleCopyrightForHeaderFiles = <<END;
60 // ------- Begin Apple Copyright -------
61 /*
62  * Copyright (C) 2008, Apple Inc. All rights reserved.
63  *
64  * Permission is granted by Apple to use this file to the extent
65  * necessary to relink with LGPL WebKit files.
66  *
67  * No license or rights are granted by Apple expressly or by
68  * implication, estoppel, or otherwise, to Apple patents and
69  * trademarks. For the sake of clarity, no license or rights are
70  * granted by Apple expressly or by implication, estoppel, or otherwise,
71  * under any Apple patents, copyrights and trademarks to underlying
72  * implementations of any application programming interfaces (APIs)
73  * or to any functionality that is invoked by calling any API.
74  */
75
76 END
77 my $beginAppleCopyrightForSourceFiles = <<END;
78 // ------- Begin Apple Copyright -------
79 /*
80  * Copyright (C) 2008, Apple Inc. All rights reserved.
81  *
82  * No license or rights are granted by Apple expressly or by implication,
83  * estoppel, or otherwise, to Apple copyrights, patents, trademarks, trade
84  * secrets or other rights.
85  */
86
87 END
88 my $endAppleCopyright   = <<END;
89 // ------- End Apple Copyright   -------
90
91 END
92
93 # Hashes
94 my %protocolTypeHash = ("XPathNSResolver" => 1, "EventListener" => 1, "EventTarget" => 1, "NodeFilter" => 1);
95 my %nativeObjCTypeHash = ("URL" => 1, "Color" => 1);
96
97 # FIXME: this should be replaced with a function that recurses up the tree
98 # to find the actual base type.
99 my %baseTypeHash = ("Object" => 1, "Node" => 1, "NodeList" => 1, "NamedNodeMap" => 1, "DOMImplementation" => 1,
100                     "Event" => 1, "CSSRule" => 1, "CSSValue" => 1, "StyleSheet" => 1, "MediaList" => 1,
101                     "Counter" => 1, "Rect" => 1, "RGBColor" => 1, "XPathExpression" => 1, "XPathResult" => 1,
102                     "NodeIterator" => 1, "TreeWalker" => 1, "AbstractView" => 1, "Blob" => 1);
103
104 # Constants
105 my $buildingForIPhone = defined $ENV{PLATFORM_NAME} && ($ENV{PLATFORM_NAME} eq "iphoneos" or $ENV{PLATFORM_NAME} eq "iphonesimulator");
106 my $nullableInit = "bool isNull = false;";
107 my $exceptionInit = "WebCore::ExceptionCode ec = 0;";
108 my $jsContextSetter = "WebCore::JSMainThreadNullState state;";
109 my $exceptionRaiseOnError = "WebCore::raiseOnDOMError(ec);";
110 my $assertMainThread = "{ DOM_ASSERT_MAIN_THREAD(); WebCoreThreadViolationCheckRoundOne(); }";
111
112 my %conflictMethod = (
113     # FIXME: Add C language keywords?
114     # FIXME: Add other predefined types like "id"?
115
116     "callWebScriptMethod:withArguments:" => "WebScriptObject",
117     "evaluateWebScript:" => "WebScriptObject",
118     "removeWebScriptKey:" => "WebScriptObject",
119     "setException:" => "WebScriptObject",
120     "setWebScriptValueAtIndex:value:" => "WebScriptObject",
121     "stringRepresentation" => "WebScriptObject",
122     "webScriptValueAtIndex:" => "WebScriptObject",
123
124     "autorelease" => "NSObject",
125     "awakeAfterUsingCoder:" => "NSObject",
126     "class" => "NSObject",
127     "classForCoder" => "NSObject",
128     "conformsToProtocol:" => "NSObject",
129     "copy" => "NSObject",
130     "copyWithZone:" => "NSObject",
131     "dealloc" => "NSObject",
132     "description" => "NSObject",
133     "doesNotRecognizeSelector:" => "NSObject",
134     "encodeWithCoder:" => "NSObject",
135     "finalize" => "NSObject",
136     "forwardInvocation:" => "NSObject",
137     "hash" => "NSObject",
138     "init" => "NSObject",
139     "initWithCoder:" => "NSObject",
140     "isEqual:" => "NSObject",
141     "isKindOfClass:" => "NSObject",
142     "isMemberOfClass:" => "NSObject",
143     "isProxy" => "NSObject",
144     "methodForSelector:" => "NSObject",
145     "methodSignatureForSelector:" => "NSObject",
146     "mutableCopy" => "NSObject",
147     "mutableCopyWithZone:" => "NSObject",
148     "performSelector:" => "NSObject",
149     "release" => "NSObject",
150     "replacementObjectForCoder:" => "NSObject",
151     "respondsToSelector:" => "NSObject",
152     "retain" => "NSObject",
153     "retainCount" => "NSObject",
154     "self" => "NSObject",
155     "superclass" => "NSObject",
156     "zone" => "NSObject",
157 );
158
159 my $fatalError = 0;
160
161 # Default License Templates
162 my $headerLicenseTemplate = << "EOF";
163 /*
164  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
165  * Copyright (C) 2006 Samuel Weinig <sam.weinig\@gmail.com>
166  *
167  * Redistribution and use in source and binary forms, with or without
168  * modification, are permitted provided that the following conditions
169  * are met:
170  * 1. Redistributions of source code must retain the above copyright
171  *    notice, this list of conditions and the following disclaimer.
172  * 2. Redistributions in binary form must reproduce the above copyright
173  *    notice, this list of conditions and the following disclaimer in the
174  *    documentation and/or other materials provided with the distribution.
175  *
176  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
177  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
178  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
179  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
180  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
181  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
182  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
183  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
184  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
185  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
186  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
187  */
188 EOF
189
190 my $implementationLicenseTemplate = << "EOF";
191 /*
192  * This file is part of the WebKit open source project.
193  * This file has been generated by generate-bindings.pl. DO NOT MODIFY!
194  *
195  * Redistribution and use in source and binary forms, with or without
196  * modification, are permitted provided that the following conditions
197  * are met:
198  * 1. Redistributions of source code must retain the above copyright
199  *    notice, this list of conditions and the following disclaimer.
200  * 2. Redistributions in binary form must reproduce the above copyright
201  *    notice, this list of conditions and the following disclaimer in the
202  *    documentation and/or other materials provided with the distribution.
203  *
204  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
205  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
206  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
207  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
208  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
209  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
210  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
211  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
212  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
213  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
214  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
215  */
216 EOF
217
218 # Default constructor
219 sub new
220 {
221     my $object = shift;
222     my $reference = { };
223
224     $codeGenerator = shift;
225     shift; # $useLayerOnTop
226     shift; # $preprocessor
227     $writeDependencies = shift;
228
229     bless($reference, $object);
230     return $reference;
231 }
232
233 sub ReadPublicInterfaces
234 {
235     my $class = shift;
236     my $superClass = shift;
237     my $defines = shift;
238     my $isProtocol = shift;
239
240     my $found = 0;
241     my $actualSuperClass;
242     %publicInterfaces = ();
243
244     my @args = qw(-E -P -x objective-c);
245
246     push(@args, "-I" . $ENV{BUILT_PRODUCTS_DIR} . "/usr/local/include") if $ENV{BUILT_PRODUCTS_DIR};
247     push(@args, "-isysroot", $ENV{SDKROOT}) if $ENV{SDKROOT};
248
249     my $fileName = "WebCore/bindings/objc/PublicDOMInterfaces.h";
250     my $gccLocation = "";
251     if ($ENV{CC}) {
252         $gccLocation = $ENV{CC};
253     } elsif (($Config::Config{'osname'}) =~ /solaris/i) {
254         $gccLocation = "/usr/sfw/bin/gcc";
255     } elsif (-x "/usr/bin/clang") {
256         $gccLocation = "/usr/bin/clang";
257     } else {
258         $gccLocation = "/usr/bin/gcc";
259     }
260
261     open FILE, "-|", $gccLocation, @args,
262         (map { "-D$_" } split(/ +/, $defines)), "-DOBJC_CODE_GENERATION", $fileName or die "Could not open $fileName";
263     my @documentContent = <FILE>;
264     close FILE;
265
266     foreach $line (@documentContent) {
267         if (!$isProtocol && $line =~ /^\s*\@interface\s*$class\s*:\s*(\w+)\s*([A-Z0-9_]*)/) {
268             if ($superClass ne $1) {
269                 warn "Public API change. Superclass for \"$class\" differs ($1 != $superClass)";
270                 $fatalError = 1;
271             }
272
273             $interfaceAvailabilityVersion = $2 if defined $2;
274             $found = 1;
275             next;
276         } elsif ($isProtocol && $line =~ /^\s*\@protocol $class\s*<[^>]+>\s*([A-Z0-9_()]*)/) {
277             $interfaceAvailabilityVersion = $1 if defined $1;
278             $found = 1;
279             next;
280         }
281
282         last if $found and $line =~ /^\s?\@end\s?$/;
283
284         if ($found) {
285             # trim whitspace
286             $line =~ s/^\s+//;
287             $line =~ s/\s+$//;
288
289             my $availabilityMacro = "";
290             $line =~ s/\s([A-Z0-9_(), ]+)\s*;$/;/;
291             $availabilityMacro = $1 if defined $1;
292
293             $publicInterfaces{$line} = $availabilityMacro if length $line;
294         }
295     }
296
297     # If this class was not found in PublicDOMInterfaces.h then it should be considered as an entirely new public class.
298     $newPublicClass = !$found;
299     $interfaceAvailabilityVersion = "TBD" if $newPublicClass;
300 }
301
302 sub AddMethodsConstantsAndAttributesFromParentInterfaces
303 {
304     # Add to $interface all of its inherited interface members, except for those
305     # inherited through $interface's first listed parent.  If an array reference
306     # is passed in as $parents, the names of all ancestor interfaces visited
307     # will be appended to the array.  If $collectDirectParents is true, then
308     # even the names of $interface's first listed parent and its ancestors will
309     # be appended to $parents.
310
311     my $interface = shift;
312     my $parents = shift;
313     my $collectDirectParents = shift;
314
315     my $first = 1;
316
317     $codeGenerator->ForAllParents($interface, sub {
318         my $currentInterface = shift;
319
320         if ($first) {
321             # Ignore first parent class, already handled by the generation itself.
322             $first = 0;
323
324             if ($collectDirectParents) {
325                 # Just collect the names of the direct ancestor interfaces,
326                 # if necessary.
327                 push(@$parents, $currentInterface->name);
328                 $codeGenerator->ForAllParents($currentInterface, sub {
329                     my $currentInterface = shift;
330                     push(@$parents, $currentInterface->name);
331                 }, undef);
332             }
333
334             # Prune the recursion here.
335             return 'prune';
336         }
337
338         # Collect the name of this additional parent.
339         push(@$parents, $currentInterface->name) if $parents;
340
341         print "  |  |>  -> Inheriting "
342             . @{$currentInterface->constants} . " constants, "
343             . @{$currentInterface->functions} . " functions, "
344             . @{$currentInterface->attributes} . " attributes...\n  |  |>\n" if $verbose;
345
346         # Add this parent's members to $interface.
347         push(@{$interface->constants}, @{$currentInterface->constants});
348         push(@{$interface->functions}, @{$currentInterface->functions});
349         push(@{$interface->attributes}, @{$currentInterface->attributes});
350     });
351 }
352
353 sub GenerateInterface
354 {
355     my $object = shift;
356     my $interface = shift;
357     my $defines = shift;
358
359     $fatalError = 0;
360
361     my $name = $interface->name;
362     my $className = GetClassName($name);
363     my $parentClassName = "DOM" . GetParentImplClassName($interface);
364     $isProtocol = $interface->extendedAttributes->{ObjCProtocol};
365     $noImpl = $interface->extendedAttributes->{ObjCCustomImplementation} || $isProtocol;
366
367     ReadPublicInterfaces($className, $parentClassName, $defines, $isProtocol);
368
369     # Start actual generation..
370     $object->GenerateHeader($interface, $defines);
371     $object->GenerateImplementation($interface) unless $noImpl;
372
373     # Check for missing public API
374     if (keys %publicInterfaces > 0) {
375         my $missing = join("\n", keys %publicInterfaces);
376         warn "Public API change. There are missing public properties and/or methods from the \"$className\" class.\n$missing\n";
377         $fatalError = 1;
378     }
379
380     die if $fatalError;
381 }
382
383 sub GetClassName
384 {
385     my $name = shift;
386
387     # special cases
388     return "NSString" if $codeGenerator->IsStringType($name) or $name eq "SerializedScriptValue";
389     return "CGColorRef" if $name eq "Color" and $buildingForIPhone;
390     return "NS$name" if IsNativeObjCType($name);
391     return "BOOL" if $name eq "boolean";
392     return "unsigned char" if $name eq "octet";
393     return "char" if $name eq "byte";
394     return "unsigned" if $name eq "unsigned long";
395     return "int" if $name eq "long";
396     return "NSTimeInterval" if $name eq "Date";
397     return "DOMAbstractView" if $name eq "DOMWindow";
398     return $name if $codeGenerator->IsPrimitiveType($name) or $name eq "DOMImplementation" or $name eq "DOMTimeStamp";
399
400     # Default, assume Objective-C type has the same type name as
401     # idl type prefixed with "DOM".
402     return "DOM$name";
403 }
404
405 sub GetClassHeaderName
406 {
407     my $name = shift;
408
409     return "DOMDOMImplementation" if $name eq "DOMImplementation";
410     return $name;
411 }
412
413 sub GetImplClassName
414 {
415     my $name = shift;
416
417     return "DOMImplementationFront" if $name eq "DOMImplementation";
418     return "DOMWindow" if $name eq "AbstractView";
419     return $name;
420 }
421
422 sub GetParentImplClassName
423 {
424     my $interface = shift;
425
426     return "Object" if @{$interface->parents} eq 0;
427
428     my $parent = $interface->parents(0);
429
430     # special cases
431     return "Object" if $parent eq "HTMLCollection";
432
433     return $parent;
434 }
435
436 sub GetParentAndProtocols
437 {
438     my $interface = shift;
439     my $numParents = @{$interface->parents};
440
441     my $parent = "";
442     my @protocols = ();
443     if ($numParents eq 0) {
444         if ($isProtocol) {
445             push(@protocols, "NSObject");
446             push(@protocols, "NSCopying") if $interface->name eq "EventTarget";
447         } else {
448             $parent = "DOMObject";
449         }
450     } elsif ($numParents eq 1) {
451         my $parentName = $interface->parents(0);
452         if ($isProtocol) {
453             die "Parents of protocols must also be protocols." unless IsProtocolType($parentName);
454             push(@protocols, "DOM" . $parentName);
455         } else {
456             if (IsProtocolType($parentName)) {
457                 push(@protocols, "DOM" . $parentName);
458             } elsif ($parentName eq "HTMLCollection") {
459                 $parent = "DOMObject";
460             } else {
461                 $parent = "DOM" . $parentName;
462             }
463         }
464     } else {
465         my @parents = @{$interface->parents};
466         my $firstParent = shift(@parents);
467         if (IsProtocolType($firstParent)) {
468             push(@protocols, "DOM" . $firstParent);
469             if (!$isProtocol) {
470                 $parent = "DOMObject";
471             }
472         } else {
473             $parent = "DOM" . $firstParent;
474         }
475
476         foreach my $parentName (@parents) {
477             die "Everything past the first class should be a protocol!" unless IsProtocolType($parentName);
478
479             push(@protocols, "DOM" . $parentName);
480         }
481     }
482
483     return ($parent, @protocols);
484 }
485
486 sub GetBaseClass
487 {
488     $parent = shift;
489
490     return $parent if $parent eq "Object" or IsBaseType($parent);
491     return "Event" if $parent eq "UIEvent" or $parent eq "MouseEvent";
492     return "CSSValue" if $parent eq "CSSValueList";
493     return "Node";
494 }
495
496 sub IsBaseType
497 {
498     my $type = shift;
499
500     return 1 if $baseTypeHash{$type};
501     return 0;
502 }
503
504 sub IsProtocolType
505 {
506     my $type = shift;
507
508     return 1 if $protocolTypeHash{$type};
509     return 0;
510 }
511
512 sub IsNativeObjCType
513 {
514     my $type = shift;
515
516     return 1 if $nativeObjCTypeHash{$type};
517     return 0;
518 }
519
520 sub IsCoreFoundationType
521 {
522     my $type = shift;
523
524     return 1 if $type =~ /^(CF|CG)[A-Za-z]+Ref$/;
525     return 0;
526 }
527
528 sub SkipFunction
529 {
530     my $function = shift;
531
532     return 1 if $codeGenerator->GetSequenceType($function->signature->type);
533     return 1 if $codeGenerator->GetArrayType($function->signature->type);
534
535     foreach my $param (@{$function->parameters}) {
536         return 1 if $codeGenerator->GetSequenceType($param->type);
537         return 1 if $codeGenerator->GetArrayType($param->type);
538         return 1 if $param->extendedAttributes->{"Clamp"};
539     }
540
541     return 0;
542 }
543
544 sub SkipAttribute
545 {
546     my $attribute = shift;
547     my $type = $attribute->signature->type;
548
549     $codeGenerator->AssertNotSequenceType($type);
550     return 1 if $codeGenerator->GetArrayType($type);
551     return 1 if $codeGenerator->IsTypedArrayType($type);
552     return 1 if $codeGenerator->IsEnumType($type);
553     return 1 if $attribute->isStatic;
554
555     # This is for DynamicsCompressorNode.idl
556     if ($attribute->signature->name eq "release") {
557         return 1;
558     }
559
560     return 0;
561 }
562
563 sub GetObjCType
564 {
565     my $type = shift;
566     my $name = GetClassName($type);
567
568     return "id <$name>" if IsProtocolType($type);
569     return $name if $codeGenerator->IsPrimitiveType($type) or $type eq "DOMTimeStamp";
570     return "unsigned short" if $type eq "CompareHow";
571     return $name if IsCoreFoundationType($name);
572     return "$name *";
573 }
574
575 sub GetPropertyAttributes
576 {
577     my $type = shift;
578     my $readOnly = shift;
579
580     my @attributes = ();
581
582     push(@attributes, "readonly") if $readOnly;
583
584     # FIXME: <rdar://problem/5049934> Consider using 'nonatomic' on the DOM @property declarations.
585     if ($codeGenerator->IsStringType($type) || IsNativeObjCType($type)) {
586         push(@attributes, "copy");
587     } elsif (!$codeGenerator->IsStringType($type) && !$codeGenerator->IsPrimitiveType($type) && $type ne "DOMTimeStamp" && $type ne "CompareHow") {
588         push(@attributes, "strong");
589     }
590
591     return "" unless @attributes > 0;
592     return " (" . join(", ", @attributes) . ")";
593 }
594
595 sub ConversionNeeded
596 {
597     my $type = shift;
598
599     return !$codeGenerator->IsNonPointerType($type) && !$codeGenerator->IsStringType($type) && !IsNativeObjCType($type);
600 }
601
602 sub GetObjCTypeGetter
603 {
604     my $argName = shift;
605     my $type = shift;
606
607     return $argName if $codeGenerator->IsPrimitiveType($type) or $codeGenerator->IsStringType($type) or IsNativeObjCType($type);
608     return $argName . "Node" if $type eq "EventTarget";
609     return "static_cast<WebCore::Range::CompareHow>($argName)" if $type eq "CompareHow";
610     return "WTF::getPtr(nativeEventListener)" if $type eq "EventListener";
611     return "WTF::getPtr(nativeNodeFilter)" if $type eq "NodeFilter";
612     return "WTF::getPtr(nativeResolver)" if $type eq "XPathNSResolver";
613     
614     if ($type eq "SerializedScriptValue") {
615         $implIncludes{"SerializedScriptValue.h"} = 1;
616         return "WebCore::SerializedScriptValue::create(WTF::String($argName))";
617     }
618     return "core($argName)";
619 }
620
621 sub AddForwardDeclarationsForType
622 {
623     my $type = shift;
624     my $public = shift;
625
626     return if $codeGenerator->IsNonPointerType($type);
627     return if $codeGenerator->GetSequenceType($type);
628     return if $codeGenerator->GetArrayType($type);
629
630     my $class = GetClassName($type);
631
632     if (IsProtocolType($type)) {
633         $headerForwardDeclarationsForProtocols{$class} = 1 if $public;
634         $privateHeaderForwardDeclarationsForProtocols{$class} = 1 if !$public and !$headerForwardDeclarationsForProtocols{$class};
635         return;
636     }
637
638     $headerForwardDeclarations{$class} = 1 if $public;
639
640     # Private headers include the public header, so only add a forward declaration to the private header
641     # if the public header does not already have the same forward declaration.
642     $privateHeaderForwardDeclarations{$class} = 1 if !$public and !$headerForwardDeclarations{$class};
643 }
644
645 sub AddIncludesForType
646 {
647     my $type = shift;
648
649     return if $codeGenerator->IsNonPointerType($type);
650     return if $codeGenerator->GetSequenceType($type);
651     return if $codeGenerator->GetArrayType($type);
652
653     if (IsNativeObjCType($type)) {
654         if ($type eq "Color") {
655             if ($buildingForIPhone) {
656                 $implIncludes{"ColorSpace.h"} = 1;
657             } else {
658                 $implIncludes{"ColorMac.h"} = 1;
659             }
660         }
661         return;
662     }
663
664     if ($codeGenerator->IsStringType($type)) {
665         $implIncludes{"URL.h"} = 1;
666         return;
667     }
668
669     if ($type eq "DOMWindow") {
670         $implIncludes{"DOMAbstractViewInternal.h"} = 1;
671         $implIncludes{"DOMWindow.h"} = 1;
672         return;
673     }
674
675     if ($type eq "DOMImplementation") {
676         $implIncludes{"DOMDOMImplementationInternal.h"} = 1;
677         $implIncludes{"DOMImplementationFront.h"} = 1;
678         return;
679     }
680
681     if ($type eq "EventTarget") {
682         $implIncludes{"Node.h"} = 1;
683         $implIncludes{"DOMEventTarget.h"} = 1;
684         return;
685     }
686
687     if ($type =~ /(\w+)(Abs|Rel)$/) {
688         $implIncludes{"$1.h"} = 1;
689         $implIncludes{"DOM${type}Internal.h"} = 1;
690         return;
691     }
692
693     if ($type eq "NodeFilter") {
694         $implIncludes{"NodeFilter.h"} = 1;
695         $implIncludes{"ObjCNodeFilterCondition.h"} = 1;
696         return;
697     }
698
699     if ($type eq "EventListener") {
700         $implIncludes{"EventListener.h"} = 1;
701         $implIncludes{"ObjCEventListener.h"} = 1;
702         return;
703     }
704
705     if ($type eq "XPathNSResolver") {
706         $implIncludes{"DOMCustomXPathNSResolver.h"} = 1;
707         $implIncludes{"XPathNSResolver.h"} = 1;
708         return;
709     }
710
711     if ($type eq "SerializedScriptValue") {
712         $implIncludes{"SerializedScriptValue.h"} = 1;
713         return;
714     }
715
716     # FIXME: won't compile without these
717     $implIncludes{"CSSImportRule.h"} = 1 if $type eq "CSSRule";
718     $implIncludes{"StyleProperties.h"} = 1 if $type eq "CSSStyleDeclaration";
719     $implIncludes{"NameNodeList.h"} = 1 if $type eq "NodeList";
720
721     # Default, include the same named file (the implementation) and the same name prefixed with "DOM". 
722     $implIncludes{"$type.h"} = 1 if not $codeGenerator->SkipIncludeHeader($type);
723     $implIncludes{"DOM${type}Internal.h"} = 1;
724 }
725
726 sub ConditionalIsEnabled(\%$)
727 {
728     my $defines = shift;
729     my $conditional = shift;
730
731     return 1 if !$conditional;
732
733     my $operator = ($conditional =~ /&/ ? '&' : ($conditional =~ /\|/ ? '|' : ''));
734     if (!$operator) {
735         return exists($defines->{"ENABLE_" . $conditional});
736     }
737
738     my @conditions = split(/\Q$operator\E/, $conditional);
739     foreach (@conditions) {
740         my $enable = "ENABLE_" . $_;
741         return 0 if ($operator eq '&') and !exists($defines->{$enable});
742         return 1 if ($operator eq '|') and exists($defines->{$enable});
743     }
744
745     return $operator eq '&';
746 }
747
748 sub GenerateHeader
749 {
750     my $object = shift;
751     my $interface = shift;
752     my $defines = shift;
753
754     my %definesRef = map { $_ => 1 } split(/\s+/, $defines);
755
756     my $interfaceName = $interface->name;
757     my $className = GetClassName($interfaceName);
758
759     my $parentName = "";
760     my @protocolsToImplement = ();
761     ($parentName, @protocolsToImplement) = GetParentAndProtocols($interface);
762
763     my $numConstants = @{$interface->constants};
764     my $numAttributes = @{$interface->attributes};
765     my $numFunctions = @{$interface->functions};
766
767     # - Add default header template
768     if ($interface->extendedAttributes->{"AppleCopyright"}) {
769         @headerContentHeader = split("\r", $beginAppleCopyrightForHeaderFiles);
770     } else {
771         @headerContentHeader = split("\r", $headerLicenseTemplate);
772     }
773     push(@headerContentHeader, "\n");
774
775     # - INCLUDES -
776     my $includedWebKitAvailabilityHeader = 0;
777     unless ($isProtocol) {
778         my $parentHeaderName = GetClassHeaderName($parentName);
779         push(@headerContentHeader, "#import <WebCore/$parentHeaderName.h>\n");
780         $includedWebKitAvailabilityHeader = 1;
781     }
782
783     foreach my $parentProtocol (@protocolsToImplement) {
784         next if $parentProtocol =~ /^NS/; 
785         $parentProtocol = GetClassHeaderName($parentProtocol);
786         push(@headerContentHeader, "#import <WebCore/$parentProtocol.h>\n");
787         $includedWebKitAvailabilityHeader = 1;
788     }
789
790     # Special case needed for legacy support of DOMRange
791     if ($interfaceName eq "Range") {
792         push(@headerContentHeader, "#import <WebCore/DOMCore.h>\n");
793         push(@headerContentHeader, "#import <WebCore/DOMDocument.h>\n");
794         push(@headerContentHeader, "#import <WebCore/DOMRangeException.h>\n");
795         $includedWebKitAvailabilityHeader = 1;
796     }
797
798     push(@headerContentHeader, "#import <WebCore/WebKitAvailability.h>\n") unless $includedWebKitAvailabilityHeader;
799
800     push(@headerContentHeader, "\n");
801
802     # - Add constants.
803     if ($numConstants > 0) {
804         my @headerConstants = ();
805         my @constants = @{$interface->constants};
806         my $combinedConstants = "";
807
808         # FIXME: we need a way to include multiple enums.
809         foreach my $constant (@constants) {
810             my $constantName = $constant->name;
811             my $constantValue = $constant->value;
812             my $notLast = $constant ne $constants[-1];
813             
814             if (ConditionalIsEnabled(%definesRef, $constant->extendedAttributes->{"Conditional"})) {
815                 $combinedConstants .= "    DOM_$constantName = $constantValue";
816                 $combinedConstants .= "," if $notLast;
817                 if ($notLast) {
818                     $combinedConstants .= "\n";
819                 }
820             }
821         }
822
823         # FIXME: the formatting of the enums should line up the equal signs.
824         # FIXME: enums are unconditionally placed in the public header.
825         push(@headerContent, "enum {\n");
826         push(@headerContent, $combinedConstants);
827         push(@headerContent, "\n}");
828         push(@headerContent, " WEBKIT_ENUM_AVAILABLE_MAC($interfaceAvailabilityVersion)") if length $interfaceAvailabilityVersion;
829         push(@headerContent, ";\n\n");
830     }
831
832     # - Begin @interface or @protocol
833     my $interfaceDeclaration = ($isProtocol ? "\@protocol $className" : "\@interface $className : $parentName");
834     $interfaceDeclaration .= " <" . join(", ", @protocolsToImplement) . ">" if @protocolsToImplement > 0;
835     $interfaceDeclaration .= "\n";
836
837     push(@headerContent, "WEBKIT_CLASS_AVAILABLE_MAC($interfaceAvailabilityVersion)\n") if length $interfaceAvailabilityVersion;
838     push(@headerContent, $interfaceDeclaration);
839
840     my @headerAttributes = ();
841     my @privateHeaderAttributes = ();
842
843     # - Add attribute getters/setters.
844     if ($numAttributes > 0) {
845         foreach my $attribute (@{$interface->attributes}) {
846             next if SkipAttribute($attribute);
847             my $attributeName = $attribute->signature->name;
848
849             if ($attributeName eq "id" or $attributeName eq "hash" or $attributeName eq "description") {
850                 # Special case some attributes (like id and hash) to have a "Name" suffix to avoid ObjC naming conflicts.
851                 $attributeName .= "Name";
852             } elsif ($attributeName eq "frame") {
853                 # Special case attribute frame to be frameBorders.
854                 $attributeName .= "Borders";
855             }
856
857             my $attributeType = GetObjCType($attribute->signature->type);
858             my $property = "\@property" . GetPropertyAttributes($attribute->signature->type, $attribute->isReadOnly);
859             $property .= " " . $attributeType . ($attributeType =~ /\*$/ ? "" : " ") . $attributeName;
860
861             my $publicInterfaceKey = $property . ";";
862
863             # FIXME: This only works for the getter, but not the setter.  Need to refactor this code.
864             if ($buildingForTigerOrEarlier && !$buildingForIPhone || IsCoreFoundationType($attributeType)) {
865                 $publicInterfaceKey = "- (" . $attributeType . ")" . $attributeName . ";";
866             }
867
868             my $availabilityMacro = "";
869             if (defined $publicInterfaces{$publicInterfaceKey} and length $publicInterfaces{$publicInterfaceKey}) {
870                 $availabilityMacro = $publicInterfaces{$publicInterfaceKey};
871             }
872
873             my $declarationSuffix = ";\n";
874             $declarationSuffix = " $availabilityMacro;\n" if length $availabilityMacro;
875
876             my $public = (defined $publicInterfaces{$publicInterfaceKey} or $newPublicClass);
877             delete $publicInterfaces{$publicInterfaceKey};
878
879             AddForwardDeclarationsForType($attribute->signature->type, $public);
880
881             my $setterName = "set" . ucfirst($attributeName) . ":";
882
883             my $conflict = $conflictMethod{$attributeName};
884             if ($conflict) {
885                 warn "$className conflicts with $conflict method $attributeName\n";
886                 $fatalError = 1;
887             }
888
889             $conflict = $conflictMethod{$setterName};
890             if ($conflict) {
891                 warn "$className conflicts with $conflict method $setterName\n";
892                 $fatalError = 1;
893             }
894
895             if (!IsCoreFoundationType($attributeType)) {
896                 $property .= $declarationSuffix;
897                 push(@headerAttributes, $property) if $public;
898                 push(@privateHeaderAttributes, $property) unless $public;
899             } elsif (ConditionalIsEnabled(%definesRef, $attribute->signature->extendedAttributes->{"Conditional"})) {
900                 # - GETTER
901                 my $getter = "- (" . $attributeType . ")" . $attributeName . $declarationSuffix;
902                 push(@headerAttributes, $getter) if $public;
903                 push(@privateHeaderAttributes, $getter) unless $public;
904  
905                 # - SETTER
906                 if (!$attribute->isReadOnly) {
907                     my $setter = "- (void)$setterName(" . $attributeType . ")new" . ucfirst($attributeName) . $declarationSuffix;
908                     push(@headerAttributes, $setter) if $public;
909                     push(@privateHeaderAttributes, $setter) unless $public;
910                 }
911             }
912         }
913
914         push(@headerContent, @headerAttributes) if @headerAttributes > 0;
915     }
916
917     my @headerFunctions = ();
918     my @privateHeaderFunctions = ();
919     my @deprecatedHeaderFunctions = ();
920
921     # - Add functions.
922     if ($numFunctions > 0) {
923         my %inAppleCopyright = (public => 0, private => 0);
924         foreach my $function (@{$interface->functions}) {
925             next if SkipFunction($function);
926             next if ($function->signature->name eq "set" and $interface->extendedAttributes->{"TypedArray"});
927             my $functionName = $function->signature->name;
928
929             my $returnType = GetObjCType($function->signature->type);
930             my $needsDeprecatedVersion = (@{$function->parameters} > 1 and $function->signature->extendedAttributes->{"ObjCLegacyUnnamedParameters"});
931             my $needsAppleCopyright = $function->signature->extendedAttributes->{"AppleCopyright"};
932             my $numberOfParameters = @{$function->parameters};
933             my %typesToForwardDeclare = ($function->signature->type => 1);
934
935             my $parameterIndex = 0;
936             my $functionSig = "- ($returnType)$functionName";
937             my $methodName = $functionName;
938             foreach my $param (@{$function->parameters}) {
939                 my $paramName = $param->name;
940                 my $paramType = GetObjCType($param->type);
941
942                 $typesToForwardDeclare{$param->type} = 1;
943
944                 if ($parameterIndex >= 1) {
945                     $functionSig .= " $paramName";
946                     $methodName .= $paramName;
947                 }
948
949                 $functionSig .= ":($paramType)$paramName";
950                 $methodName .= ":";
951
952                 $parameterIndex++;
953             }
954
955             my $publicInterfaceKey = $functionSig . ";";
956
957             my $conflict = $conflictMethod{$methodName};
958             if ($conflict) {
959                 warn "$className conflicts with $conflict method $methodName\n";
960                 $fatalError = 1;
961             }
962
963             if ($isProtocol && !$newPublicClass && !defined $publicInterfaces{$publicInterfaceKey}) {
964                 warn "Protocol method $publicInterfaceKey is not in PublicDOMInterfaces.h. Protocols require all methods to be public";
965                 $fatalError = 1;
966             }
967
968             my $availabilityMacro = "";
969             if (defined $publicInterfaces{$publicInterfaceKey} and length $publicInterfaces{$publicInterfaceKey}) {
970                 $availabilityMacro = $publicInterfaces{$publicInterfaceKey};
971             }
972
973             my $functionDeclaration = $functionSig;
974             $functionDeclaration .= " " . $availabilityMacro if length $availabilityMacro;
975             $functionDeclaration .= ";\n";
976
977             my $public = (defined $publicInterfaces{$publicInterfaceKey} or $newPublicClass);
978             delete $publicInterfaces{$publicInterfaceKey};
979
980             foreach my $type (keys %typesToForwardDeclare) {
981                 # add any forward declarations to the public header if a deprecated version will be generated
982                 AddForwardDeclarationsForType($type, 1) if $needsDeprecatedVersion;
983                 AddForwardDeclarationsForType($type, $public) unless $public and $needsDeprecatedVersion;
984             }
985
986             if ($needsAppleCopyright) {
987                 if (!$inAppleCopyright{$public ? "public" : "private"}) {
988                     push(@headerFunctions, $beginAppleCopyrightForHeaderFiles) if $public;
989                     push(@privateHeaderFunctions, $beginAppleCopyrightForHeaderFiles) unless $public;
990                     $inAppleCopyright{$public ? "public" : "private"} = 1;
991                 }
992             } elsif ($inAppleCopyright{$public ? "public" : "private"}) {
993                 push(@headerFunctions, $endAppleCopyright) if $public;
994                 push(@privateHeaderFunctions, $endAppleCopyright) unless $public;
995                 $inAppleCopyright{$public ? "public" : "private"} = 0;
996             }
997             
998             if (ConditionalIsEnabled(%definesRef, $function->signature->extendedAttributes->{"Conditional"})) {
999                 push(@headerFunctions, $functionDeclaration) if $public;
1000                 push(@privateHeaderFunctions, $functionDeclaration) unless $public;
1001
1002                 # generate the old style method names with un-named parameters, these methods are deprecated
1003                 if ($needsDeprecatedVersion) {
1004                     my $deprecatedFunctionSig = $functionSig;
1005                     $deprecatedFunctionSig =~ s/\s\w+:/ :/g; # remove parameter names
1006
1007                     $publicInterfaceKey = $deprecatedFunctionSig . ";";
1008
1009                     my $availabilityMacro = "WEBKIT_DEPRECATED_MAC(10_4, 10_5)";
1010                     if (defined $publicInterfaces{$publicInterfaceKey} and length $publicInterfaces{$publicInterfaceKey}) {
1011                         $availabilityMacro = $publicInterfaces{$publicInterfaceKey};
1012                     }
1013
1014                     $functionDeclaration = "$deprecatedFunctionSig $availabilityMacro;\n";
1015
1016                     push(@deprecatedHeaderFunctions, $functionDeclaration);
1017
1018                     unless (defined $publicInterfaces{$publicInterfaceKey}) {
1019                         warn "Deprecated method $publicInterfaceKey is not in PublicDOMInterfaces.h. All deprecated methods need to be public, or should have the ObjCLegacyUnnamedParameters IDL attribute removed";
1020                         $fatalError = 1;
1021                     }
1022
1023                     delete $publicInterfaces{$publicInterfaceKey};
1024                 }
1025             }
1026         }
1027
1028         push(@headerFunctions, $endAppleCopyright) if $inAppleCopyright{"public"};
1029         push(@privateHeaderFunctions, $endAppleCopyright) if $inAppleCopyright{"private"};
1030
1031         if (@headerFunctions > 0) {
1032             push(@headerContent, "\n") if @headerAttributes > 0;
1033             push(@headerContent, @headerFunctions);
1034         }
1035     }
1036
1037     if (@deprecatedHeaderFunctions > 0 && $isProtocol) {
1038         push(@headerContent, @deprecatedHeaderFunctions);
1039     }
1040
1041     # - End @interface or @protocol
1042     push(@headerContent, "\@end\n");
1043
1044     if (@deprecatedHeaderFunctions > 0 && !$isProtocol) {
1045         # - Deprecated category @interface 
1046         push(@headerContent, "\n\@interface $className (" . $className . "Deprecated)\n");
1047         push(@headerContent, @deprecatedHeaderFunctions);
1048         push(@headerContent, "\@end\n");
1049     }
1050
1051     if ($interface->extendedAttributes->{"AppleCopyright"}) {
1052         push(@headerContent, split("\r", $endAppleCopyright));
1053     }
1054
1055     my %alwaysGenerate = map { $_ => 1 } qw(DOMHTMLEmbedElement DOMHTMLObjectElement);
1056
1057     if (@privateHeaderAttributes > 0 or @privateHeaderFunctions > 0 or exists $alwaysGenerate{$className}) {
1058         # - Private category @interface
1059         if ($interface->extendedAttributes->{"AppleCopyright"}) {
1060             @privateHeaderContentHeader = split("\r", $beginAppleCopyrightForHeaderFiles);
1061         } else {
1062             @privateHeaderContentHeader = split("\r", $headerLicenseTemplate);
1063         }
1064         push(@privateHeaderContentHeader, "\n");
1065
1066         my $classHeaderName = GetClassHeaderName($className);
1067         push(@privateHeaderContentHeader, "#import <WebCore/$classHeaderName.h>\n\n");
1068
1069         @privateHeaderContent = ();
1070         push(@privateHeaderContent, "\@interface $className (" . $className . "Private)\n");
1071         push(@privateHeaderContent, @privateHeaderAttributes) if @privateHeaderAttributes > 0;
1072         push(@privateHeaderContent, "\n") if @privateHeaderAttributes > 0 and @privateHeaderFunctions > 0;
1073         push(@privateHeaderContent, @privateHeaderFunctions) if @privateHeaderFunctions > 0;
1074         push(@privateHeaderContent, "\@end\n");
1075
1076         if ($interface->extendedAttributes->{"AppleCopyright"}) {
1077             push(@privateHeaderContent, split("\r", $endAppleCopyright));
1078         }
1079     }
1080
1081     unless ($isProtocol) {
1082         # Generate internal interfaces
1083         my $implClassName = GetImplClassName($interfaceName);
1084         my $implClassNameWithNamespace = "WebCore::" . $implClassName;
1085
1086         my $implType = $implClassNameWithNamespace;
1087
1088         # Generate interface definitions. 
1089         if ($interface->extendedAttributes->{"AppleCopyright"}) {
1090             @internalHeaderContent = split("\r", $beginAppleCopyrightForHeaderFiles);
1091         } else {
1092             @internalHeaderContent = split("\r", $implementationLicenseTemplate);
1093         }
1094
1095         push(@internalHeaderContent, "\n#import <WebCore/$className.h>\n\n");
1096
1097         if ($interfaceName eq "Node") {
1098             push(@internalHeaderContent, "\@protocol DOMEventTarget;\n\n");
1099         }
1100
1101         my $startedNamespace = 0;
1102
1103         push(@internalHeaderContent, "namespace WebCore {\n");
1104         $startedNamespace = 1;
1105         if ($interfaceName eq "Node") {
1106             push(@internalHeaderContent, "class EventTarget;\n    class Node;\n");
1107         } else {
1108             push(@internalHeaderContent, "class $implClassName;\n");
1109         }
1110         push(@internalHeaderContent, "}\n\n");
1111
1112         push(@internalHeaderContent, "$implType* core($className *);\n");
1113         push(@internalHeaderContent, "$className *kit($implType*);\n");
1114
1115         if ($interface->extendedAttributes->{"ObjCPolymorphic"}) {
1116             push(@internalHeaderContent, "Class kitClass($implType*);\n");
1117         }
1118
1119         if ($interfaceName eq "Node") {
1120             push(@internalHeaderContent, "id <DOMEventTarget> kit(WebCore::EventTarget*);\n");
1121         }
1122     }
1123 }
1124
1125 sub GenerateImplementation
1126 {
1127     my $object = shift;
1128     my $interface = shift;
1129
1130     my @ancestorInterfaceNames = ();
1131
1132     if (@{$interface->parents} > 1) {
1133         AddMethodsConstantsAndAttributesFromParentInterfaces($interface, \@ancestorInterfaceNames);
1134     }
1135
1136     my $interfaceName = $interface->name;
1137     my $className = GetClassName($interfaceName);
1138     my $implClassName = GetImplClassName($interfaceName);
1139     my $parentImplClassName = GetParentImplClassName($interface);
1140     my $implClassNameWithNamespace = "WebCore::" . $implClassName;
1141     my $baseClass = GetBaseClass($parentImplClassName);
1142     my $classHeaderName = GetClassHeaderName($className);
1143
1144     my $numAttributes = @{$interface->attributes};
1145     my $numFunctions = @{$interface->functions};
1146     my $implType = $implClassNameWithNamespace;
1147
1148     # - Add default header template.
1149     if ($interface->extendedAttributes->{"AppleCopyright"}) {
1150         @implContentHeader = split("\r", $beginAppleCopyrightForSourceFiles);
1151     } else {
1152         @implContentHeader = split("\r", $implementationLicenseTemplate);
1153     }
1154
1155     # - INCLUDES -
1156     push(@implContentHeader, "\n#import \"config.h\"\n");
1157
1158     my $conditionalString = $codeGenerator->GenerateConditionalString($interface);
1159     push(@implContentHeader, "\n#if ${conditionalString}\n\n") if $conditionalString;
1160
1161     push(@implContentHeader, "#import \"DOMInternal.h\"\n\n");
1162     push(@implContentHeader, "#import \"$classHeaderName.h\"\n\n");
1163
1164     $implIncludes{"ExceptionHandlers.h"} = 1;
1165     $implIncludes{"ThreadCheck.h"} = 1;
1166     $implIncludes{"JSMainThreadExecState.h"} = 1;
1167     $implIncludes{"WebScriptObjectPrivate.h"} = 1;
1168     $implIncludes{$classHeaderName . "Internal.h"} = 1;
1169     $implIncludes{"DOMNodeInternal.h"} = 1;
1170
1171     $implIncludes{"DOMBlobInternal.h"} = 1 if $interfaceName eq "File";
1172     $implIncludes{"DOMCSSRuleInternal.h"} = 1 if $interfaceName =~ /.*CSS.*Rule/;
1173     $implIncludes{"DOMCSSValueInternal.h"} = 1 if $interfaceName =~ /.*CSS.*Value/;
1174     $implIncludes{"DOMEventInternal.h"} = 1 if $interfaceName =~ /.*Event/;
1175     $implIncludes{"DOMStyleSheetInternal.h"} = 1 if $interfaceName eq "CSSStyleSheet";
1176
1177     if ($interfaceName =~ /(\w+)(Abs|Rel)$/) {
1178         $implIncludes{"$1.h"} = 1;
1179     } else {
1180         if (!$codeGenerator->SkipIncludeHeader($implClassName)) {
1181             $implIncludes{"$implClassName.h"} = 1 ;
1182         }
1183     } 
1184
1185     @implContent = ();
1186
1187     push(@implContent, "#import <wtf/GetPtr.h>\n\n");
1188
1189     # add implementation accessor
1190     if ($parentImplClassName eq "Object") {
1191         push(@implContent, "#define IMPL reinterpret_cast<$implType*>(_internal)\n\n");
1192     } else {
1193         my $baseClassWithNamespace = "WebCore::$baseClass";
1194         push(@implContent, "#define IMPL static_cast<$implClassNameWithNamespace*>(reinterpret_cast<$baseClassWithNamespace*>(_internal))\n\n");
1195     }
1196
1197     # START implementation
1198     push(@implContent, "\@implementation $className\n\n");
1199
1200     # Only generate 'dealloc' and 'finalize' methods for direct subclasses of DOMObject.
1201     if ($parentImplClassName eq "Object") {
1202         $implIncludes{"WebCoreObjCExtras.h"} = 1;
1203         push(@implContent, "- (void)dealloc\n");
1204         push(@implContent, "{\n");
1205         push(@implContent, "    if (WebCoreObjCScheduleDeallocateOnMainThread([$className class], self))\n");
1206         push(@implContent, "        return;\n");
1207         push(@implContent, "\n");
1208         if ($interfaceName eq "NodeIterator") {
1209             push(@implContent, "    if (_internal) {\n");
1210             push(@implContent, "        [self detach];\n");
1211             push(@implContent, "        IMPL->deref();\n");
1212             push(@implContent, "    };\n");
1213         } else {
1214             push(@implContent, "    if (_internal)\n");
1215             push(@implContent, "        IMPL->deref();\n");
1216         }
1217         push(@implContent, "    [super dealloc];\n");
1218         push(@implContent, "}\n\n");
1219
1220         push(@implContent, "- (void)finalize\n");
1221         push(@implContent, "{\n");
1222         if ($interfaceName eq "NodeIterator") {
1223             push(@implContent, "    if (_internal) {\n");
1224             push(@implContent, "        [self detach];\n");
1225             push(@implContent, "        IMPL->deref();\n");
1226             push(@implContent, "    };\n");
1227         } else {
1228             push(@implContent, "    if (_internal)\n");
1229             push(@implContent, "        IMPL->deref();\n");
1230         }
1231         push(@implContent, "    [super finalize];\n");
1232         push(@implContent, "}\n\n");
1233         
1234     }
1235
1236     %attributeNames = ();
1237
1238     # - Attributes
1239     if ($numAttributes > 0) {
1240         foreach my $attribute (@{$interface->attributes}) {
1241             next if SkipAttribute($attribute);
1242             AddIncludesForType($attribute->signature->type);
1243
1244             my $idlType = $attribute->signature->type;
1245
1246             my $attributeName = $attribute->signature->name;
1247             my $attributeType = GetObjCType($attribute->signature->type);
1248             my $attributeClassName = GetClassName($attribute->signature->type);
1249
1250             my $attributeInterfaceName = $attributeName;
1251             if ($attributeName eq "id" or $attributeName eq "hash" or $attributeName eq "description") {
1252                 # Special case some attributes (like id and hash) to have a "Name" suffix to avoid ObjC naming conflicts.
1253                 $attributeInterfaceName .= "Name";
1254             } elsif ($attributeName eq "frame") {
1255                 # Special case attribute frame to be frameBorders.
1256                 $attributeInterfaceName .= "Borders";
1257             }
1258
1259             $attributeNames{$attributeInterfaceName} = 1;
1260
1261             # - GETTER
1262             my $getterSig = "- ($attributeType)$attributeInterfaceName\n";
1263
1264             my ($functionName, @arguments) = $codeGenerator->GetterExpression(\%implIncludes, $interfaceName, $attribute);
1265
1266             # To avoid bloating Obj-C bindings, we use getAttribute() instead of fastGetAttribute().
1267             if ($functionName eq "fastGetAttribute") {
1268                 $functionName = "getAttribute";
1269             }
1270
1271             my $getterExpressionPrefix = "$functionName(" . join(", ", @arguments);
1272
1273             # FIXME: Special case attribute ownerDocument to call document. This makes it return the
1274             # document when called on the document itself. Legacy behavior, see <https://bugs.webkit.org/show_bug.cgi?id=10889>.
1275             $getterExpressionPrefix =~ s/\bownerDocument\b/document/;
1276
1277             my $hasGetterException = $attribute->signature->extendedAttributes->{"GetterRaisesException"};
1278             my $getterContentHead;
1279             if ($attribute->signature->extendedAttributes->{"ImplementedBy"}) {
1280                 my $implementedBy = $attribute->signature->extendedAttributes->{"ImplementedBy"};
1281                 $implIncludes{"${implementedBy}.h"} = 1;
1282                 $getterContentHead = "${implementedBy}::${getterExpressionPrefix}IMPL";
1283             } else {
1284                 $getterContentHead = "IMPL->$getterExpressionPrefix";
1285             }
1286
1287             my $getterContentTail = ")";
1288
1289             my $attributeTypeSansPtr = $attributeType;
1290             $attributeTypeSansPtr =~ s/ \*$//; # Remove trailing " *" from pointer types.
1291
1292             # special case for EventTarget protocol
1293             $attributeTypeSansPtr = "DOMNode" if $idlType eq "EventTarget";
1294
1295             # Special cases
1296             my @customGetterContent = (); 
1297             if ($attributeTypeSansPtr eq "DOMImplementation") {
1298                 # FIXME: We have to special case DOMImplementation until DOMImplementationFront is removed
1299                 $getterContentHead = "kit(implementationFront(IMPL";
1300                 $getterContentTail .= ")";
1301             } elsif ($attributeName =~ /(\w+)DisplayString$/) {
1302                 my $attributeToDisplay = $1;
1303                 $getterContentHead = "WebCore::displayString(IMPL->$attributeToDisplay(), core(self)";
1304                 $implIncludes{"HitTestResult.h"} = 1;
1305             } elsif ($attributeName =~ /^absolute(\w+)URL$/) {
1306                 my $typeOfURL = $1;
1307                 $getterContentHead = "[self _getURLAttribute:";
1308                 if ($typeOfURL eq "Link") {
1309                     $getterContentTail = "\@\"href\"]";
1310                 } elsif ($typeOfURL eq "Image") {
1311                     if ($interfaceName eq "HTMLObjectElement") {
1312                         $getterContentTail = "\@\"data\"]";
1313                     } else {
1314                         $getterContentTail = "\@\"src\"]";
1315                     }
1316                     unless ($interfaceName eq "HTMLImageElement") {
1317                         push(@customGetterContent, "    if (!IMPL->renderer() || !IMPL->renderer()->isImage())\n");
1318                         push(@customGetterContent, "        return nil;\n");
1319                         $implIncludes{"RenderElement.h"} = 1;
1320                     }
1321                 }
1322                 $implIncludes{"DOMPrivate.h"} = 1;
1323             } elsif ($attribute->signature->extendedAttributes->{"ObjCImplementedAsUnsignedLong"}) {
1324                 $getterContentHead = "WTF::String::number(" . $getterContentHead;
1325                 $getterContentTail .= ")";
1326             } elsif ($idlType eq "Date") {
1327                 $getterContentHead = "kit($getterContentHead";
1328                 $getterContentTail .= ")";
1329             } elsif (IsProtocolType($idlType) and $idlType ne "EventTarget") {
1330                 $getterContentHead = "kit($getterContentHead";
1331                 $getterContentTail .= ")";
1332             } elsif ($idlType eq "Color") {
1333                 if ($buildingForIPhone) {
1334                     $getterContentHead = "WebCore::cachedCGColor($getterContentHead";
1335                     $getterContentTail .= ", WebCore::ColorSpaceDeviceRGB)";
1336                 } else {
1337                     $getterContentHead = "WebCore::nsColor($getterContentHead";
1338                     $getterContentTail .= ")";
1339                 }
1340             } elsif ($attribute->signature->type eq "SerializedScriptValue") {
1341                 $getterContentHead = "$getterContentHead";
1342                 $getterContentTail .= "->toString()";                
1343             } elsif (ConversionNeeded($attribute->signature->type)) {
1344                 $getterContentHead = "kit(WTF::getPtr($getterContentHead";
1345                 $getterContentTail .= "))";
1346             }
1347
1348             my $getterContent;
1349             if ($hasGetterException || $attribute->signature->isNullable) {
1350                 $getterContent = $getterContentHead;
1351                 my $getterWithoutAttributes = $getterContentHead =~ /\($|, $/ ? "ec" : ", ec";
1352                 if ($attribute->signature->isNullable) {
1353                     $getterContent .= $getterWithoutAttributes ? "isNull" : ", isNull";
1354                     $getterWithoutAttributes = 0;
1355                 }
1356                 if ($hasGetterException) {
1357                     $getterContent .= $getterWithoutAttributes ? "ec" : ", ec";
1358                 }
1359                 $getterContent .= $getterContentTail;
1360             } else {
1361                 $getterContent = $getterContentHead . $getterContentTail;
1362             }
1363
1364             my $attributeConditionalString = $codeGenerator->GenerateConditionalString($attribute->signature);
1365             push(@implContent, "#if ${attributeConditionalString}\n") if $attributeConditionalString;
1366             push(@implContent, $getterSig);
1367             push(@implContent, "{\n");
1368             push(@implContent, "    $jsContextSetter\n");
1369             push(@implContent, @customGetterContent);
1370
1371             # FIXME: Should we return a default value when isNull == true?
1372             if ($attribute->signature->isNullable) {
1373                 push(@implContents, "    $nullableInit\n");
1374             }
1375
1376             if ($hasGetterException) {
1377                 # Differentiated between when the return type is a pointer and
1378                 # not for white space issue (ie. Foo *result vs. int result).
1379                 if ($attributeType =~ /\*$/) {
1380                     $getterContent = $attributeType . "result = " . $getterContent;
1381                 } else {
1382                     $getterContent = $attributeType . " result = " . $getterContent;
1383                 }
1384
1385                 push(@implContent, "    $exceptionInit\n");
1386                 push(@implContent, "    $getterContent;\n");
1387                 push(@implContent, "    $exceptionRaiseOnError\n");
1388                 push(@implContent, "    return result;\n");
1389             } else {
1390                 push(@implContent, "    return $getterContent;\n");
1391             }
1392             push(@implContent, "}\n");
1393
1394             # - SETTER
1395             if (!$attribute->isReadOnly) {
1396                 # Exception handling
1397                 my $hasSetterException = $attribute->signature->extendedAttributes->{"SetterRaisesException"};
1398
1399                 my $coreSetterName = "set" . $codeGenerator->WK_ucfirst($attributeName);
1400                 my $setterName = "set" . ucfirst($attributeInterfaceName);
1401                 my $argName = "new" . ucfirst($attributeInterfaceName);
1402                 my $arg = GetObjCTypeGetter($argName, $idlType);
1403
1404                 # The definition of ObjCImplementedAsUnsignedLong is flipped for the setter
1405                 if ($attribute->signature->extendedAttributes->{"ObjCImplementedAsUnsignedLong"}) {
1406                     $arg = "WTF::String($arg).toInt()";
1407                 }
1408
1409                 my $setterSig = "- (void)$setterName:($attributeType)$argName\n";
1410
1411                 push(@implContent, "\n");
1412                 push(@implContent, $setterSig);
1413                 push(@implContent, "{\n");
1414                 push(@implContent, "    $jsContextSetter\n");
1415
1416                 unless ($codeGenerator->IsPrimitiveType($idlType) or $codeGenerator->IsStringType($idlType)) {
1417                     push(@implContent, "    ASSERT($argName);\n\n");
1418                 }
1419
1420                 if ($idlType eq "Date") {
1421                     $arg = "core(" . $arg . ")";
1422                 }
1423
1424                 my ($functionName, @arguments) = $codeGenerator->SetterExpression(\%implIncludes, $interfaceName, $attribute);
1425                 push(@arguments, $arg);
1426                 push(@arguments, "ec") if $hasSetterException;
1427                 push(@implContent, "    $exceptionInit\n") if $hasSetterException;
1428                 if ($attribute->signature->extendedAttributes->{"ImplementedBy"}) {
1429                     my $implementedBy = $attribute->signature->extendedAttributes->{"ImplementedBy"};
1430                     $implIncludes{"${implementedBy}.h"} = 1;
1431                     unshift(@arguments, "IMPL");
1432                     $functionName = "${implementedBy}::${functionName}";
1433                 } else {
1434                     $functionName = "IMPL->${functionName}";
1435                 }
1436                 push(@implContent, "    ${functionName}(" . join(", ", @arguments) . ");\n");
1437                 push(@implContent, "    $exceptionRaiseOnError\n") if $hasSetterException;
1438
1439                 push(@implContent, "}\n");
1440             }
1441
1442             push(@implContent, "#endif\n") if $attributeConditionalString;
1443             push(@implContent, "\n");
1444         }
1445     }
1446
1447     # - Functions
1448     if ($numFunctions > 0) {
1449         my $inAppleCopyright = 0;
1450         foreach my $function (@{$interface->functions}) {
1451             next if SkipFunction($function);
1452             next if ($function->signature->name eq "set" and $interface->extendedAttributes->{"TypedArray"});
1453             AddIncludesForType($function->signature->type);
1454
1455             my $functionName = $function->signature->name;
1456             my $returnType = GetObjCType($function->signature->type);
1457             my $needsAppleCopyright = $function->signature->extendedAttributes->{"AppleCopyright"};
1458             my $hasParameters = @{$function->parameters};
1459             my $raisesExceptions = $function->signature->extendedAttributes->{"RaisesException"};
1460
1461             my @parameterNames = ();
1462             my @needsAssert = ();
1463             my %needsCustom = ();
1464
1465             my $parameterIndex = 0;
1466             my $functionSig = "- ($returnType)$functionName";
1467             foreach my $param (@{$function->parameters}) {
1468                 my $paramName = $param->name;
1469                 my $paramType = GetObjCType($param->type);
1470
1471                 # make a new parameter name if the original conflicts with a property name
1472                 $paramName = "in" . ucfirst($paramName) if $attributeNames{$paramName};
1473
1474                 AddIncludesForType($param->type);
1475
1476                 my $idlType = $param->type;
1477                 my $implGetter;
1478                 if ($param->extendedAttributes->{"ObjCExplicitAtomicString"}) {
1479                     $implGetter = "AtomicString($paramName)"
1480                 } else {
1481                     $implGetter = GetObjCTypeGetter($paramName, $idlType);
1482                 }
1483
1484                 push(@parameterNames, $implGetter);
1485                 $needsCustom{"XPathNSResolver"} = $paramName if $idlType eq "XPathNSResolver";
1486                 $needsCustom{"NodeFilter"} = $paramName if $idlType eq "NodeFilter";
1487                 $needsCustom{"EventListener"} = $paramName if $idlType eq "EventListener";
1488                 $needsCustom{"EventTarget"} = $paramName if $idlType eq "EventTarget";
1489                 $needsCustom{"NodeToReturn"} = $paramName if $param->extendedAttributes->{"CustomReturn"};
1490
1491                 unless ($codeGenerator->IsPrimitiveType($idlType) or $codeGenerator->IsStringType($idlType)) {
1492                     push(@needsAssert, "    ASSERT($paramName);\n");
1493                 }
1494
1495                 if ($parameterIndex >= 1) {
1496                     $functionSig .= " " . $param->name;
1497                 }
1498
1499                 $functionSig .= ":($paramType)$paramName";
1500
1501                 $parameterIndex++;
1502             }
1503
1504             my @functionContent = ();
1505             my $caller = "IMPL";
1506
1507             # special case the XPathNSResolver
1508             if (defined $needsCustom{"XPathNSResolver"}) {
1509                 my $paramName = $needsCustom{"XPathNSResolver"};
1510                 push(@functionContent, "    WebCore::XPathNSResolver* nativeResolver = 0;\n");
1511                 push(@functionContent, "    RefPtr<WebCore::XPathNSResolver> customResolver;\n");
1512                 push(@functionContent, "    if ($paramName) {\n");
1513                 push(@functionContent, "        if ([$paramName isMemberOfClass:[DOMNativeXPathNSResolver class]])\n");
1514                 push(@functionContent, "            nativeResolver = core(static_cast<DOMNativeXPathNSResolver *>($paramName));\n");
1515                 push(@functionContent, "        else {\n");
1516                 push(@functionContent, "            customResolver = WebCore::DOMCustomXPathNSResolver::create($paramName);\n");
1517                 push(@functionContent, "            nativeResolver = WTF::getPtr(customResolver);\n");
1518                 push(@functionContent, "        }\n");
1519                 push(@functionContent, "    }\n");
1520             }
1521
1522             # special case the EventTarget
1523             if (defined $needsCustom{"EventTarget"}) {
1524                 my $paramName = $needsCustom{"EventTarget"};
1525                 push(@functionContent, "    DOMNode* ${paramName}ObjC = $paramName;\n");
1526                 push(@functionContent, "    WebCore::Node* ${paramName}Node = core(${paramName}ObjC);\n");
1527                 $implIncludes{"DOMNode.h"} = 1;
1528                 $implIncludes{"Node.h"} = 1;
1529             }
1530
1531             if ($function->signature->extendedAttributes->{"ObjCUseDefaultView"}) {
1532                 push(@functionContent, "    WebCore::DOMWindow* dv = $caller->defaultView();\n");
1533                 push(@functionContent, "    if (!dv)\n");
1534                 push(@functionContent, "        return nil;\n");
1535                 $implIncludes{"DOMWindow.h"} = 1;
1536                 $caller = "dv";
1537             }
1538
1539             # special case the EventListener
1540             if (defined $needsCustom{"EventListener"}) {
1541                 my $paramName = $needsCustom{"EventListener"};
1542                 push(@functionContent, "    RefPtr<WebCore::EventListener> nativeEventListener = WebCore::ObjCEventListener::wrap($paramName);\n");
1543             }
1544
1545             # special case the NodeFilter
1546             if (defined $needsCustom{"NodeFilter"}) {
1547                 my $paramName = $needsCustom{"NodeFilter"};
1548                 push(@functionContent, "    RefPtr<WebCore::NodeFilter> nativeNodeFilter;\n");
1549                 push(@functionContent, "    if ($paramName)\n");
1550                 push(@functionContent, "        nativeNodeFilter = WebCore::NodeFilter::create(WebCore::ObjCNodeFilterCondition::create($paramName));\n");
1551             }
1552
1553             push(@parameterNames, "ec") if $raisesExceptions;
1554
1555             my $content;
1556             if ($function->signature->extendedAttributes->{"ImplementedBy"}) {
1557                 my $implementedBy = $function->signature->extendedAttributes->{"ImplementedBy"};
1558                 $implIncludes{"${implementedBy}.h"} = 1;
1559                 unshift(@parameterNames, $caller);
1560                 $content = "${implementedBy}::" . $codeGenerator->WK_lcfirst($functionName) . "(" . join(", ", @parameterNames) . ")";
1561             } else {
1562                 my $functionImplementationName = $function->signature->extendedAttributes->{"ImplementedAs"} || $codeGenerator->WK_lcfirst($functionName);
1563                 $content = "$caller->" . $functionImplementationName . "(" . join(", ", @parameterNames) . ")";
1564             }
1565
1566             if ($returnType eq "void") {
1567                 # Special case 'void' return type.
1568                 if ($raisesExceptions) {
1569                     push(@functionContent, "    $exceptionInit\n");
1570                     push(@functionContent, "    $content;\n");
1571                     push(@functionContent, "    $exceptionRaiseOnError\n");
1572                 } else {
1573                     push(@functionContent, "    $content;\n");
1574                 }
1575             } elsif (defined $needsCustom{"NodeToReturn"}) {
1576                 # Special case the insertBefore, replaceChild, removeChild 
1577                 # and appendChild functions from DOMNode 
1578                 my $toReturn = $needsCustom{"NodeToReturn"};
1579                 if ($raisesExceptions) {
1580                     push(@functionContent, "    $exceptionInit\n");
1581                     push(@functionContent, "    if ($content)\n");
1582                     push(@functionContent, "        return $toReturn;\n");
1583                     push(@functionContent, "    $exceptionRaiseOnError\n");
1584                     push(@functionContent, "    return nil;\n");
1585                 } else {
1586                     push(@functionContent, "    if ($content)\n");
1587                     push(@functionContent, "        return $toReturn;\n");
1588                     push(@functionContent, "    return nil;\n");
1589                 }
1590             } elsif ($returnType eq "SerializedScriptValue") {
1591                 $content = "foo";
1592             } else {
1593                 if (ConversionNeeded($function->signature->type)) {
1594                     $content = "kit(WTF::getPtr($content))";
1595                 }
1596
1597                 if ($raisesExceptions) {
1598                     # Differentiated between when the return type is a pointer and
1599                     # not for white space issue (ie. Foo *result vs. int result).
1600                     if ($returnType =~ /\*$/) {
1601                         $content = $returnType . "result = " . $content;
1602                     } else {
1603                         $content = $returnType . " result = " . $content;
1604                     }
1605
1606                     push(@functionContent, "    $exceptionInit\n");
1607                     push(@functionContent, "    $content;\n");
1608                     push(@functionContent, "    $exceptionRaiseOnError\n");
1609                     push(@functionContent, "    return result;\n");
1610                 } else {
1611                     push(@functionContent, "    return $content;\n");
1612                 }
1613             }
1614
1615             if ($needsAppleCopyright) {
1616                 if (!$inAppleCopyright) {
1617                     push(@implContent, $beginAppleCopyrightForSourceFiles);
1618                     $inAppleCopyright = 1;
1619                 }
1620             } elsif ($inAppleCopyright) {
1621                 push(@implContent, $endAppleCopyright);
1622                 $inAppleCopyright = 0;
1623             }
1624
1625             my $conditionalString = $codeGenerator->GenerateConditionalString($function->signature);
1626             push(@implContent, "\n#if ${conditionalString}\n") if $conditionalString;
1627
1628             push(@implContent, "$functionSig\n");
1629             push(@implContent, "{\n");
1630             push(@implContent, "    $jsContextSetter\n");
1631             push(@implContent, @functionContent);
1632             push(@implContent, "}\n\n");
1633
1634             push(@implContent, "#endif\n\n") if $conditionalString;
1635
1636             # generate the old style method names with un-named parameters, these methods are deprecated
1637             if (@{$function->parameters} > 1 and $function->signature->extendedAttributes->{"ObjCLegacyUnnamedParameters"}) {
1638                 my $deprecatedFunctionSig = $functionSig;
1639                 $deprecatedFunctionSig =~ s/\s\w+:/ :/g; # remove parameter names
1640
1641                 push(@implContent, "$deprecatedFunctionSig\n");
1642                 push(@implContent, "{\n");
1643                 push(@implContent, "    $jsContextSetter\n");
1644                 push(@implContent, @functionContent);
1645                 push(@implContent, "}\n\n");
1646             }
1647
1648             # Clear the hash
1649             %needsCustom = ();
1650         }
1651         push(@implContent, $endAppleCopyright) if $inAppleCopyright;
1652     }
1653
1654     # END implementation
1655     push(@implContent, "\@end\n");
1656
1657     if ($interface->extendedAttributes->{"AppleCopyright"}) {
1658         push(@implContent, split("\r", $endAppleCopyright));
1659     }
1660
1661     # Generate internal interfaces
1662     push(@implContent, "\n$implType* core($className *wrapper)\n");
1663     push(@implContent, "{\n");
1664     push(@implContent, "    return wrapper ? reinterpret_cast<$implType*>(wrapper->_internal) : 0;\n");
1665     push(@implContent, "}\n\n");
1666
1667     if ($parentImplClassName eq "Object") {        
1668         push(@implContent, "$className *kit($implType* value)\n");
1669         push(@implContent, "{\n");
1670         push(@implContent, "    $assertMainThread;\n");
1671         push(@implContent, "    if (!value)\n");
1672         push(@implContent, "        return nil;\n");
1673         push(@implContent, "    if ($className *wrapper = getDOMWrapper(value))\n");
1674         push(@implContent, "        return [[wrapper retain] autorelease];\n");
1675         if ($interface->extendedAttributes->{"ObjCPolymorphic"}) {
1676             push(@implContent, "    $className *wrapper = [[kitClass(value) alloc] _init];\n");
1677             push(@implContent, "    if (!wrapper)\n");
1678             push(@implContent, "        return nil;\n");
1679         } else {
1680             push(@implContent, "    $className *wrapper = [[$className alloc] _init];\n");
1681         }
1682         push(@implContent, "    wrapper->_internal = reinterpret_cast<DOMObjectInternal*>(value);\n");
1683         push(@implContent, "    value->ref();\n");
1684         push(@implContent, "    addDOMWrapper(wrapper, value);\n");
1685         push(@implContent, "    return [wrapper autorelease];\n");
1686         push(@implContent, "}\n");
1687     } else {
1688         push(@implContent, "$className *kit($implType* value)\n");
1689         push(@implContent, "{\n");
1690         push(@implContent, "    $assertMainThread;\n");
1691         push(@implContent, "    return static_cast<$className*>(kit(static_cast<WebCore::$baseClass*>(value)));\n");
1692         push(@implContent, "}\n");
1693     }
1694
1695     # - End the ifdef conditional if necessary
1696     push(@implContent, "\n#endif // ${conditionalString}\n") if $conditionalString;
1697
1698     if ($interface->extendedAttributes->{"AppleCopyright"}) {
1699         push(@implContent, split("\r", $endAppleCopyright));
1700     }
1701
1702     # - Generate dependencies.
1703     if ($writeDependencies && @ancestorInterfaceNames) {
1704         push(@depsContent, "$className.h : ", join(" ", map { "$_.idl" } @ancestorInterfaceNames), "\n");
1705         push(@depsContent, map { "$_.idl :\n" } @ancestorInterfaceNames); 
1706     }
1707 }
1708
1709 # Internal helper
1710 sub WriteData
1711 {
1712     my $object = shift;
1713     my $interface = shift;
1714     my $outputDir = shift;
1715
1716     # Open files for writing...
1717     my $name = $interface->name;
1718     my $prefix = FileNamePrefix;
1719     my $headerFileName = "$outputDir/$prefix$name.h";
1720     my $privateHeaderFileName = "$outputDir/$prefix${name}Private.h";
1721     my $implFileName = "$outputDir/$prefix$name.mm";
1722     my $internalHeaderFileName = "$outputDir/$prefix${name}Internal.h";
1723     my $depsFileName = "$outputDir/$prefix$name.dep";
1724
1725     # Write public header.
1726     my $contents = join "", @headerContentHeader;
1727     map { $contents .= (IsCoreFoundationType($_) ? "typedef struct " . substr($_, 0, -3) . "* $_;\n" : "\@class $_;\n") } sort keys(%headerForwardDeclarations);
1728     map { $contents .= "\@protocol $_;\n" } sort keys(%headerForwardDeclarationsForProtocols);
1729
1730     my $hasForwardDeclarations = keys(%headerForwardDeclarations) + keys(%headerForwardDeclarationsForProtocols);
1731     $contents .= "\n" if $hasForwardDeclarations;
1732     $contents .= join "", @headerContent;
1733     $codeGenerator->UpdateFile($headerFileName, $contents);
1734
1735     @headerContentHeader = ();
1736     @headerContent = ();
1737     %headerForwardDeclarations = ();
1738     %headerForwardDeclarationsForProtocols = ();
1739
1740     if (@privateHeaderContent > 0) {
1741         $contents = join "", @privateHeaderContentHeader;
1742         map { $contents .= "\@class $_;\n" } sort keys(%privateHeaderForwardDeclarations);
1743         map { $contents .= "\@protocol $_;\n" } sort keys(%privateHeaderForwardDeclarationsForProtocols);
1744
1745         $hasForwardDeclarations = keys(%privateHeaderForwardDeclarations) + keys(%privateHeaderForwardDeclarationsForProtocols);
1746         $contents .= "\n" if $hasForwardDeclarations;
1747         $contents .= join "", @privateHeaderContent;
1748         $codeGenerator->UpdateFile($privateHeaderFileName, $contents);
1749
1750         @privateHeaderContentHeader = ();
1751         @privateHeaderContent = ();
1752         %privateHeaderForwardDeclarations = ();
1753         %privateHeaderForwardDeclarationsForProtocols = ();
1754     }
1755
1756     # Write implementation file.
1757     unless ($noImpl) {
1758         $contents = join "", @implContentHeader;
1759         map { $contents .= "#import \"$_\"\n" } sort keys(%implIncludes);
1760         $contents .= join "", @implContent;
1761         $codeGenerator->UpdateFile($implFileName, $contents);
1762
1763         @implContentHeader = ();
1764         @implContent = ();
1765         %implIncludes = ();
1766     }
1767
1768     if (@internalHeaderContent > 0) {
1769         $contents = join "", @internalHeaderContent;
1770         $codeGenerator->UpdateFile($internalHeaderFileName, $contents);
1771
1772         @internalHeaderContent = ();
1773     }
1774
1775     # Write dependency file.
1776     if (@depsContent) {
1777         $contents = join "", @depsContent;
1778         $codeGenerator->UpdateFile($depsFileName, $contents);
1779
1780         @depsContent = ();
1781     }
1782 }
1783
1784 1;