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