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