Reviewed by Tim H.
[WebKit-https.git] / WebCore / bindings / scripts / CodeGeneratorObjC.pm
1
2 # Copyright (C) 2005 Nikolas Zimmermann <wildfox@kde.org>
3 # Copyright (C) 2006 Anders Carlsson <andersca@mac.com> 
4 # Copyright (C) 2006 Samuel Weinig <sam.weinig@gmail.com>
5 # Copyright (C) 2006 Apple Computer, Inc.
6 #
7 # This library is free software; you can redistribute it and/or
8 # modify it under the terms of the GNU Library General Public
9 # License as published by the Free Software Foundation; either
10 # version 2 of the License, or (at your option) any later version.
11
12 # This library is distributed in the hope that it will be useful,
13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 # Library General Public License for more details.
16
17 # You should have received a copy of the GNU Library General Public License
18 # aint with this library; see the file COPYING.LIB.  If not, write to
19 # the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 # Boston, MA 02111-1307, USA.
21 #
22
23 package CodeGeneratorObjC;
24
25 use File::stat;
26
27 # Global Variables
28 my $module = "";
29 my $outputDir = "";
30 my %publicInterfaces = ();
31 my $newPublicClass = 0;
32 my $isProtocol = 0;
33 my @ivars = ();
34
35 my @headerContentHeader = ();
36 my @headerContent = ();
37 my %headerForwardDeclarations = ();
38 my %headerForwardDeclarationsForProtocols = ();
39
40 my @privateHeaderContentHeader = ();
41 my @privateHeaderContent = ();
42 my %privateHeaderForwardDeclarations = ();
43 my %privateHeaderForwardDeclarationsForProtocols = ();
44
45 my @intenalHeaderContent = ();
46
47 my @implContentHeader = ();
48 my @implContent = ();
49 my %implIncludes = ();
50
51 # Hashes
52 my %protocolTypeHash = ("XPathNSResolver" => 1, "EventListener" => 1, "EventTarget" => 1, "NodeFilter" => 1);
53 my %stringTypeHash = ("DOMString" => 1, "AtomicString" => 1);
54
55 # Constants
56 my $buildingForTigerOrEarlier = 1 if $ENV{"MACOSX_DEPLOYMENT_TARGET"} and $ENV{"MACOSX_DEPLOYMENT_TARGET"} <= 10.4;
57 my $buildingForLeopardOrLater = 1 if $ENV{"MACOSX_DEPLOYMENT_TARGET"} and $ENV{"MACOSX_DEPLOYMENT_TARGET"} >= 10.5;
58 my $exceptionInit = "WebCore::ExceptionCode ec = 0;";
59 my $exceptionRaiseOnError = "raiseOnDOMError(ec);";
60
61 # Default Licence Templates
62 my $headerLicenceTemplate = << "EOF";
63 /*
64  * Copyright (C) 2004-2006 Apple Computer, Inc.  All rights reserved.
65  * Copyright (C) 2006 Samuel Weinig <sam.weinig\@gmail.com>
66  *
67  * Redistribution and use in source and binary forms, with or without
68  * modification, are permitted provided that the following conditions
69  * are met:
70  * 1. Redistributions of source code must retain the above copyright
71  *    notice, this list of conditions and the following disclaimer.
72  * 2. Redistributions in binary form must reproduce the above copyright
73  *    notice, this list of conditions and the following disclaimer in the
74  *    documentation and/or other materials provided with the distribution.
75  *
76  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
77  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
78  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
79  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
80  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
81  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
82  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
83  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
84  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
85  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
86  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
87  */
88 EOF
89
90 my $implementationLicenceTemplate = << "EOF";
91 /*
92  * This file is part of the WebKit open source project.
93  * This file has been generated by generate-bindings.pl. DO NOT MODIFY!
94  *
95  * Redistribution and use in source and binary forms, with or without
96  * modification, are permitted provided that the following conditions
97  * are met:
98  * 1. Redistributions of source code must retain the above copyright
99  *    notice, this list of conditions and the following disclaimer.
100  * 2. Redistributions in binary form must reproduce the above copyright
101  *    notice, this list of conditions and the following disclaimer in the
102  *    documentation and/or other materials provided with the distribution.
103  *
104  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
105  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
106  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
107  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
108  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
109  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
110  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
111  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
112  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
113  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
114  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
115  */
116 EOF
117
118 # Default constructor
119 sub new
120 {
121     my $object = shift;
122     my $reference = { };
123
124     $codeGenerator = shift;
125     $outputDir = shift;
126
127     bless($reference, $object);
128     return $reference;
129 }
130
131 sub finish
132 {
133     my $object = shift;
134 }
135
136 sub ReadPublicInterfaces
137 {
138     my $class = shift;
139     my $superClass = shift;
140     my $defines = shift;
141
142     my $found = 0;
143     my $actualSuperClass;
144     %publicInterfaces = ();
145
146     my $fileName = "WebCore/bindings/objc/PublicDOMInterfaces.h";
147     open FILE, "-|", "/usr/bin/gcc", "-E", "-P", "-x", "objective-c", 
148         (map { "-D$_" } split(/ /, $defines)), "-DOBJC_CODE_GENERATION", $fileName or die "Could not open $fileName";
149     my @documentContent = <FILE>;
150     close FILE;
151
152     foreach $line (@documentContent) {
153         if ($line =~ /^\s?\@interface $class\s?:\s?(\w+)\s?$/) {
154             die "error: Public API change. Superclass for \"$class\" differs ($1 != $superClass)" if $superClass ne $1;
155             $found = 1;
156             next;
157         }
158
159         last if $found and $line =~ /^\s?\@end\s?$/;
160
161         if ($found) {
162             # trim whitspace
163             $line =~ s/^\s+//;
164             $line =~ s/\s+$//;
165             $publicInterfaces{$line} = 1;
166         }
167     }
168
169     # If this class was not found in PublicDOMInterfaces.h then it should be considered as an entirly new public class.
170     $newPublicClass = ! $found;
171 }
172
173 # Params: 'domClass' struct
174 sub GenerateInterface
175 {
176     my $object = shift;
177     my $dataNode = shift;
178     my $defines = shift;
179
180     my $name = $dataNode->name;
181     my $className = GetClassName($name);
182     my $parentClassName = "DOM" . GetParentImplClassName($dataNode);
183     $isProtocol = $dataNode->extendedAttributes->{ObjCProtocol};
184
185     ReadPublicInterfaces($className, $parentClassName, $defines);
186
187     # Start actual generation..
188     $object->GenerateHeader($dataNode);
189     $object->GenerateImplementation($dataNode) unless $isProtocol;
190
191     # Write changes.
192     $object->WriteData("DOM" . $name);
193
194     # Check for missing public API
195     if (keys %publicInterfaces > 0) {
196         my $missing = join( "\n", keys %publicInterfaces );
197         die "error: Public API change. There are missing public properties and/or methods from the \"$className\" class.\n$missing\n";
198     }
199 }
200
201 # Params: 'idlDocument' struct
202 sub GenerateModule
203 {
204     my $object = shift;
205     my $dataNode = shift;
206     
207     $module = $dataNode->module;
208 }
209
210 sub GetClassName
211 {
212     my $name = $codeGenerator->StripModule(shift);
213
214     # special cases
215     return "NSString" if IsStringType($name);
216     return "BOOL" if $name eq "boolean";
217     return "unsigned" if $name eq "unsigned long";
218     return "int" if $name eq "long";
219     return "NSURL" if $name eq "URL";
220     return "DOMAbstractView" if $name eq "DOMWindow";
221     return $name if $codeGenerator->IsPrimitiveType($name) or $name eq "DOMImplementation" or $name eq "DOMTimeStamp";
222
223     # Default, assume Objective-C type has the same type name as
224     # idl type prefixed with "DOM".
225     return "DOM$name";
226 }
227
228 sub GetClassHeaderName
229 {
230     my $name = shift;
231
232     return "DOMDOMImplementation" if $name eq "DOMImplementation";
233     return $name;
234 }
235
236 sub GetImplClassName
237 {
238     my $name = $codeGenerator->StripModule(shift);
239
240     # special cases
241     return "DOMImplementationFront" if $name eq "DOMImplementation";
242     return "RectImpl" if $name eq "Rect";
243
244     return $name;
245 }
246
247 sub GetParentImplClassName
248 {
249     my $dataNode = shift;
250
251     return "Object" if @{$dataNode->parents} eq 0;
252
253     my $parent = $codeGenerator->StripModule($dataNode->parents(0));
254
255     # special cases
256     return "Node" if $parent eq "EventTargetNode";
257     return "Object" if $parent eq "HTMLCollection";
258
259     return $parent;
260 }
261
262 sub IsProtocolType
263 {
264     $type = shift;
265
266     return 1 if $protocolTypeHash{$type};
267     return 0;
268 }
269
270 sub IsStringType
271 {
272     $type = shift;
273
274     return 1 if $stringTypeHash{$type};
275     return 0;
276 }
277
278 sub GetObjCType
279 {
280     my $type = shift;
281     my $name = GetClassName($type);
282
283     return "id <$name>" if IsProtocolType($type);
284     return $name if $codeGenerator->IsPrimitiveType($type) or $type eq "DOMTimeStamp";
285     return "$name *";
286 }
287
288 sub GetObjCTypeMaker
289 {
290     my $type = $codeGenerator->StripModule(shift);
291
292     return "" if $codeGenerator->IsPrimitiveType($type) or IsStringType($type) or $type eq "URL" or $type eq "DOMTimeStamp";
293     return "_RGBColorWithRGB" if $type eq "RGBColor";
294
295     my $typeMaker = "";
296     if ($type =~ /^(HTML|CSS|SVG)/ or $type eq "DOMImplementation" or $type eq "CDATASection") {
297         $typeMaker = $type;
298     } elsif ($type =~ /^XPath(.+)/) {
299         $typeMaker = "xpath" . $1;
300     } elsif ($type eq "DOMWindow") {
301         $typeMaker = "abstractView";
302     } elsif ($type eq "EventTarget") {
303         $typeMaker = "node";
304     } else {
305         $typeMaker = lcfirst($type);
306     }
307
308     # put into the form "_fooBarWith" for type FooBar.
309     $typeMaker = "_" . $typeMaker . "With";
310     return $typeMaker;
311 }
312
313 sub GetObjCTypeGetterName
314 {
315     my $type = $codeGenerator->StripModule(shift);
316
317     return "" if $codeGenerator->IsPrimitiveType($type) or IsStringType($type) or $type eq "URL" or $type eq "DOMTimeStamp";
318
319     my $typeGetter = "";
320     if ($type =~ /^(HTML|CSS|SVG)/ or $type eq "DOMImplementation" or $type eq "CDATASection") {
321         $typeGetter = $type;
322     } elsif ($type =~ /^XPath(.+)/) {
323         $typeGetter = "xpath" . $1;
324     } elsif ($type eq "DOMWindow") {
325         $typeGetter = "abstractView";
326     } else {
327         $typeGetter = lcfirst($type);
328     }
329
330     # put into the form "_fooBar" for type FooBar.
331     return "_" . $typeGetter;
332 }
333
334 sub GetObjCTypeGetter
335 {
336     my $argName = shift;
337     my $type = $codeGenerator->StripModule(shift);
338     my $typeGetterMethodName = GetObjCTypeGetterName($type);
339
340     return $argName if $codeGenerator->IsPrimitiveType($type) or IsStringType($type) or $type eq "URL";
341     return $argName . "EventTarget" if $type eq "EventTarget";
342     return "[nativeResolver $typeGetterMethodName]" if $type eq "XPathNSResolver";
343
344     return "[$argName $typeGetterMethodName]";
345 }
346
347 sub AddForwardDeclarationsForType
348 {
349     my $type = $codeGenerator->StripModule(shift);
350     my $public = shift;
351
352     return if $codeGenerator->IsPrimitiveType($type) or IsStringType($type) or $type eq "URL" or $type eq "DOMTimeStamp";
353
354     if (IsProtocolType($type)) {
355         $type = "DOM" . $type;
356         $headerForwardDeclarationsForProtocols{$type} = 1 if $public;
357         $privateHeaderForwardDeclarationsForProtocols{$type} = 1 if !$public and !$headerForwardDeclarationsForProtocols{$type};
358         return;
359     }
360
361     if ($type eq "DOMImplementation") {
362         $type = "DOMImplementation";
363     } elsif ($type eq "DOMWindow") {
364         $type = "DOMAbstractView";
365     } else {
366         $type = "DOM" . $type;
367     }
368
369     $headerForwardDeclarations{$type} = 1 if $public;
370
371     # Private headers include the public header, so only add a forward declaration to the private header
372     # if the public header does not already have the same forward declaration.
373     $privateHeaderForwardDeclarations{$type} = 1 if !$public and !$headerForwardDeclarations{$type};
374 }
375
376 sub AddIncludesForType
377 {
378     my $type = $codeGenerator->StripModule(shift);
379
380     return if $codeGenerator->IsPrimitiveType($type) or $type eq "URL" or $type eq "DOMTimeStamp";
381
382     if (IsStringType($type)) {
383         $implIncludes{"PlatformString.h"} = 1;
384         return;
385     }
386
387     # Temp DOMCSS.h
388     if ($type eq "Rect") {
389         $implIncludes{"DOMRect.h"} = 1;
390         $implIncludes{"RectImpl.h"} = 1;
391         return;
392     }
393
394     if ($type eq "RGBColor") {
395         $implIncludes{"DOMRGBColor.h"} = 1;
396         $implIncludes{"Color.h"} = 1;
397         return;
398     }
399
400     # Temp DOMViews.h
401     if ($type eq "DOMWindow") {
402         $implIncludes{"DOMAbstractView.h"} = 1;
403         $implIncludes{"$type.h"} = 1;
404         return;
405     }
406
407     # Temp DOMImplementationFront.h
408     if ($type eq "DOMImplementation") {
409         $implIncludes{"DOMImplementationFront.h"} = 1;
410         $implIncludes{"DOM$type.h"} = 1;
411         return;
412     }
413
414     if ($type eq "EventTarget") {
415         $implIncludes{"DOM$type.h"} = 1;
416         $implIncludes{"EventTargetNode.h"} = 1;
417         return;
418     }
419
420     # FIXME: won't compile without these
421     $implIncludes{"CSSMutableStyleDeclaration.h"} = 1 if $type eq "CSSStyleDeclaration";
422     $implIncludes{"NamedAttrMap.h"} = 1 if $type eq "NamedNodeMap";
423     $implIncludes{"NameNodeList.h"} = 1 if $type eq "NodeList";
424
425     # Default, include the same named file (the implementation) and the same name prefixed with "DOM". 
426     $implIncludes{"$type.h"} = 1;
427     $implIncludes{"DOM$type.h"} = 1;
428 }
429
430 sub GenerateHeader
431 {
432     my $object = shift;
433     my $dataNode = shift;
434
435     # We only support multiple parents with SVG (for now).
436     if (@{$dataNode->parents} > 1) {
437         die "A class can't have more than one parent" unless $module eq "SVG";
438         $codeGenerator->AddMethodsConstantsAndAttributesFromParentClasses($dataNode);
439     }
440
441     my $interfaceName = $dataNode->name;
442     my $className = GetClassName($interfaceName);
443     my $parentClassName = "DOM" . GetParentImplClassName($dataNode);
444     my $conditional = $dataNode->extendedAttributes->{"Conditional"};
445
446     my $numConstants = @{$dataNode->constants};
447     my $numAttributes = @{$dataNode->attributes};
448     my $numFunctions = @{$dataNode->functions};
449
450     # - Add default header template
451     @headerContentHeader = split("\r", $headerLicenceTemplate);
452     push(@headerContentHeader, "\n");
453
454     # - INCLUDES -
455     unless ($isProtocol) {
456         my $parentHeaderName = GetClassHeaderName($parentClassName);
457         push(@headerContentHeader, "#import <WebCore/$parentHeaderName.h>\n\n");
458     }
459
460     # - Add constants.
461     if ($numConstants > 0) {
462         my @headerConstants = ();
463
464         # FIXME: we need a way to include multiple enums.
465         foreach my $constant (@{$dataNode->constants}) {
466             my $constantName = $constant->name;
467             my $constantValue = $constant->value;
468
469             my $output = "    DOM_" . $constantName . " = " . $constantValue;
470             push(@headerConstants, $output);
471         }
472
473         my $combinedConstants = join(",\n", @headerConstants);
474
475         # FIXME: the formatting of the enums should line up the equal signs.
476         # FIXME: enums are unconditionally placed in the public header.
477         push(@headerContent, "enum {\n");
478         push(@headerContent, $combinedConstants);
479         push(@headerContent, "\n};\n\n");        
480     }
481
482     # - Begin @interface or @protocol
483     if ($isProtocol) {
484         my $parentProtocols = "NSObject" . ($interfaceName eq "EventTarget" ? ", NSCopying" : "");
485         push(@headerContent, "\@protocol $className <$parentProtocols>\n");
486     } else {
487         push(@headerContent, "\@interface $className : $parentClassName\n");
488     }
489
490     my @headerAttributes = ();
491     my @privateHeaderAttributes = ();
492
493     # - Add attribute getters/setters.
494     if ($numAttributes > 0) {
495         # Add ivars, if any, first
496         @ivars = ();
497         foreach my $attribute (@{$dataNode->attributes}) {
498             push(@ivars, $attribute) if $attribute->signature->extendedAttributes->{"ObjCIvar"};
499         }
500         if (@ivars > 0) {
501             push(@headerAttributes, "{\n");
502             foreach my $attribute (@ivars) {
503                 my $type = GetObjCType($attribute->signature->type);;
504                 my $name = "m_" . $attribute->signature->name;
505                 my $ivarDeclaration = "$type $name";
506                 push(@headerAttributes, "    $ivarDeclaration;\n");
507             }
508             push(@headerAttributes, "}\n");
509         }
510
511         foreach my $attribute (@{$dataNode->attributes}) {
512             my $attributeName = $attribute->signature->name;
513
514             if ($attributeName eq "id") {
515                 # Special case attribute id to be idName to avoid Obj-C nameing conflict.
516                 $attributeName .= "Name";
517             } elsif ($attributeName eq "frame") {
518                 # Special case attribute frame to be frameBorders.
519                 $attributeName .= "Borders";
520             }
521
522             my $attributeType = GetObjCType($attribute->signature->type);
523             my $attributeIsReadonly = ($attribute->type =~ /^readonly/);
524
525             my $property = "\@property" . ($attributeIsReadonly ? "(readonly)" : "") . " " . $attributeType . ($attributeType =~ /\*$/ ? "" : " ") . $attributeName . ";";
526
527             my $public = ($publicInterfaces{$property} or $newPublicClass);
528             delete $publicInterfaces{$property};
529
530             AddForwardDeclarationsForType($attribute->signature->type, $public);
531
532             if ($buildingForLeopardOrLater) {
533                 $property .= "\n";
534                 push(@headerAttributes, $property) if $public;
535                 push(@privateHeaderAttributes, $property) unless $public;
536             } else {
537                 # - GETTER
538                 my $getter = "- (" . $attributeType . ")" . $attributeName . ";\n";
539                 push(@headerAttributes, $getter) if $public;
540                 push(@privateHeaderAttributes, $getter) unless $public;
541
542                 # - SETTER
543                 if (!$attributeIsReadonly) {
544                     my $setter = "- (void)set" . ucfirst($attributeName) . ":(" . $attributeType . ")new" . ucfirst($attributeName) . ";\n";
545                     push(@headerAttributes, $setter) if $public;
546                     push(@privateHeaderAttributes, $setter) unless $public;
547                 }
548             }
549         }
550
551         push(@headerContent, @headerAttributes) if @headerAttributes > 0;
552     }
553
554     my @headerFunctions = ();
555     my @privateHeaderFunctions = ();
556     my @deprecatedHeaderFunctions = ();
557
558     # - Add functions.
559     if ($numFunctions > 0) {
560         foreach my $function (@{$dataNode->functions}) {
561             my $functionName = $function->signature->name;
562             my $returnType = GetObjCType($function->signature->type);
563             my $needsDeprecatedVersion = (@{$function->parameters} > 1 and $function->signature->extendedAttributes->{"OldStyleObjC"});
564             my $numberOfParameters = @{$function->parameters};
565             my %typesToForwardDeclare = ($function->signature->type => 1);
566
567             my $parameterIndex = 0;
568             my $functionSig = "- ($returnType)$functionName";
569             foreach my $param (@{$function->parameters}) {
570                 my $paramName = $param->name;
571                 my $paramType = GetObjCType($param->type);
572
573                 $typesToForwardDeclare{$param->type} = 1;
574
575                 if ($parameterIndex >= 1) {
576                     my $paramPrefix = $param->extendedAttributes->{"ObjCPrefix"};
577                     $paramPrefix = $paramName unless defined($paramPrefix);
578                     $functionSig .= " $paramPrefix";
579                 }
580
581                 $functionSig .= ":($paramType)$paramName";
582
583                 $parameterIndex++;
584             }
585
586             $functionSig .= ";";
587
588             my $public = ($publicInterfaces{$functionSig} or $newPublicClass);
589             delete $publicInterfaces{$functionSig};
590
591             $functionSig .= "\n";
592
593             foreach my $type (keys %typesToForwardDeclare) {
594                 # add any forward declarations to the public header if a deprecated version will be generated
595                 AddForwardDeclarationsForType($type, 1) if $needsDeprecatedVersion;
596                 AddForwardDeclarationsForType($type, $public) unless $public and $needsDeprecatedVersion;
597             }
598
599             push(@headerFunctions, $functionSig) if $public;
600             push(@privateHeaderFunctions, $functionSig) unless $public;
601
602             # generate the old style method names with un-named parameters, these methods are deprecated
603             if ($needsDeprecatedVersion) {
604                 my $deprecatedFunctionSig = $functionSig;
605                 $deprecatedFunctionSig =~ s/\s\w+:/ :/g; # remove parameter names
606                 my $deprecatedFunctionKey = $deprecatedFunctionSig;
607
608                 $deprecatedFunctionSig =~ s/;\n$/ DEPRECATED_IN_MAC_OS_X_VERSION_10_5_AND_LATER;\n/ if $buildingForLeopardOrLater;
609                 push(@deprecatedHeaderFunctions, $deprecatedFunctionSig);
610
611                 $deprecatedFunctionKey =~ s/\n$//; # remove the newline
612                 delete $publicInterfaces{$deprecatedFunctionKey};
613             }
614         }
615
616         if (@headerFunctions > 0) {
617             push(@headerContent, "\n") if $buildingForLeopardOrLater and @headerAttributes > 0;
618             push(@headerContent, @headerFunctions);
619         }
620     }
621
622     # - End @interface or @protocol
623     push(@headerContent, "\@end\n");
624
625     if (@deprecatedHeaderFunctions > 0) {
626         # - Deprecated category @interface 
627         push(@headerContent, "\n\@interface $className (" . $className . "Deprecated)\n");
628         push(@headerContent, @deprecatedHeaderFunctions);
629         push(@headerContent, "\@end\n");
630     }
631
632     if (@privateHeaderAttributes > 0 or @privateHeaderFunctions > 0) {
633         # - Private category @interface
634         @privateHeaderContentHeader = split("\r", $headerLicenceTemplate);
635         push(@headerContentHeader, "\n");
636
637         my $classHeaderName = GetClassHeaderName($className);
638         push(@privateHeaderContentHeader, "#import <WebCore/$classHeaderName.h>\n\n");
639
640         @privateHeaderContent = ();
641         push(@privateHeaderContent, "\@interface $className (" . $className . "Private)\n");
642         push(@privateHeaderContent, @privateHeaderAttributes) if @privateHeaderAttributes > 0;
643         push(@privateHeaderContent, "\n") if $buildingForLeopardOrLater and @privateHeaderAttributes > 0 and @privateHeaderFunctions > 0;
644         push(@privateHeaderContent, @privateHeaderFunctions) if @privateHeaderFunctions > 0;
645         push(@privateHeaderContent, "\@end\n");
646     }
647 }
648
649 sub GenerateImplementation
650 {
651     my $object = shift;
652     my $dataNode = shift;
653
654     my $interfaceName = $dataNode->name;
655     my $className = GetClassName($interfaceName);
656     my $implClassName = GetImplClassName($interfaceName);
657     my $parentImplClassName = GetParentImplClassName($dataNode);
658     my $implClassNameWithNamespace = "WebCore::" . $implClassName;
659     my $classHeaderName = GetClassHeaderName($className);
660     my $conditional = $dataNode->extendedAttributes->{"Conditional"};
661
662     my $numAttributes = @{$dataNode->attributes};
663     my $numFunctions = @{$dataNode->functions};
664
665     # - Add default header template.
666     @implContentHeader = split("\r", $implementationLicenceTemplate);
667
668     # - INCLUDES -
669     push(@implContentHeader, "\n#import \"config.h\"\n");
670     push(@implContentHeader, "\n#ifdef ${conditional}_SUPPORT\n\n") if $conditional;
671     push(@implContentHeader, "#import \"$classHeaderName.h\"\n\n");
672     push(@implContentHeader, "#import <wtf/GetPtr.h>\n\n");
673
674     $implIncludes{"$implClassName.h"} = 1;
675     $implIncludes{"DOMInternal.h"} = 1;
676
677     @implContent = ();
678
679     # add implementation accessor
680     # FIXME: CSSStyleSheet should not need special casing like this.
681     if ($parentImplClassName eq "Object" or $interfaceName eq "CSSStyleSheet") {
682         push(@implContent, "#define IMPL reinterpret_cast<$implClassNameWithNamespace*>(_internal)\n\n");
683     } else {
684         my $internalBaseType = "WebCore::";
685         if ($parentImplClassName eq "CSSValue" or $parentImplClassName eq "CSSRule") {
686             $internalBaseType .= $parentImplClassName;
687         } elsif ($parentImplClassName eq "Event" or $parentImplClassName eq "UIEvent") {
688             $internalBaseType .= "Event";
689         } else {
690             $internalBaseType .= "Node";
691         }
692
693         push(@implContent, "#define IMPL static_cast<$implClassNameWithNamespace*>(reinterpret_cast<$internalBaseType*>(_internal))\n\n");
694     }
695
696     # START implementation
697     push(@implContent, "\@implementation $className\n\n");
698
699     # Only generate 'dealloc' and 'finalize' methods for direct subclasses of DOMObject.
700     if ($parentImplClassName eq "Object") {
701         my @ivarsToRelease = ();
702         if (@ivars > 0) {
703             foreach $attribute (@ivars) {
704                 my $name = "m_" . $attribute->signature->name;
705                 push(@ivarsToRelease, "    [$name release];\n");
706             }
707         }
708
709         push(@implContent, "- (void)dealloc\n");
710         push(@implContent, "{\n");
711         push(@implContent, @ivarsToRelease);
712         if ($interfaceName eq "NodeIterator") {
713             push(@implContent, "    if (_internal) {\n");
714             push(@implContent, "        [self detach];\n");
715             push(@implContent, "        IMPL->deref();\n");
716             push(@implContent, "    };\n");
717         } else {
718             push(@implContent, "    if (_internal)\n");
719             push(@implContent, "        IMPL->deref();\n");
720         }
721         push(@implContent, "    [super dealloc];\n");
722         push(@implContent, "}\n\n");
723
724         push(@implContent, "- (void)finalize\n");
725         push(@implContent, "{\n");
726         if ($interfaceName eq "NodeIterator") {
727             push(@implContent, "    if (_internal) {\n");
728             push(@implContent, "        [self detach];\n");
729             push(@implContent, "        IMPL->deref();\n");
730             push(@implContent, "    };\n");
731         } else {
732             push(@implContent, "    if (_internal)\n");
733             push(@implContent, "        IMPL->deref();\n");
734         }
735         push(@implContent, "    [super finalize];\n");
736         push(@implContent, "}\n\n");
737         
738     }
739
740     %attributeNames = ();
741
742     # - Attributes
743     if ($numAttributes > 0) {
744         foreach my $attribute (@{$dataNode->attributes}) {
745             AddIncludesForType($attribute->signature->type);
746
747             my $idlType = $codeGenerator->StripModule($attribute->signature->type);
748
749             my $attributeName = $attribute->signature->name;
750             my $attributeType = GetObjCType($attribute->signature->type);
751             my $attributeIsReadonly = ($attribute->type =~ /^readonly/);
752             my $attributeClassName = GetClassName($attribute->signature->type);
753
754             my $attributeInterfaceName = $attributeName;
755             if ($attributeName eq "id") {
756                 # Special case attribute id to be idName to avoid Obj-C nameing conflict.
757                 $attributeInterfaceName .= "Name";
758             } elsif ($attributeName eq "frame") {
759                 # Special case attribute frame to be frameBorders.
760                 $attributeInterfaceName .= "Borders";
761             } elsif ($attributeName eq "ownerDocument") {
762                 # FIXME: for now special case attribute ownerDocument to call document, this is incorrect
763                 # legacy behavior. (see http://bugzilla.opendarwin.org/show_bug.cgi?id=10889)
764                 $attributeName = "document";
765             }
766
767             $attributeNames{$attributeInterfaceName} = 1;
768
769             # - GETTER
770             my $getterSig = "- ($attributeType)$attributeInterfaceName\n";
771             my $hasGetterException = @{$attribute->getterExceptions};
772             my $getterContentHead = "IMPL->$attributeName(";
773             my $getterContentTail = ")";
774
775             my $attributeTypeSansPtr = $attributeType;
776             $attributeTypeSansPtr =~ s/ \*$//; # Remove trailing " *" from pointer types.
777
778             # special case for EventTarget protocol
779             $attributeTypeSansPtr = "DOMNode" if $idlType eq "EventTarget";
780
781             my $typeMaker = GetObjCTypeMaker($attribute->signature->type);
782
783             # Special cases
784             my @customGetterContent = (); 
785             if ($attributeTypeSansPtr eq "DOMImplementation") {
786                 # FIXME: We have to special case DOMImplementation until DOMImplementationFront is removed
787                 $getterContentHead = "[$attributeTypeSansPtr $typeMaker:implementationFront(IMPL";
788                 $getterContentTail .= "]";
789             } elsif ($attributeName =~ /(\w+)DisplayString$/) {
790                 my $attributeToDisplay = $1;
791                 $getterContentHead = "IMPL->$attributeToDisplay().replace(\'\\\\\', [self _element]->document()->backslashAsCurrencySymbol()";
792                 $implIncludes{"Document.h"} = 1;
793             } elsif ($attributeName =~ /^absolute(\w+)URL$/) {
794                 my $typeOfURL = $1;
795                 $getterContentHead = "[self _getURLAttribute:";
796                 if ($typeOfURL eq "Link") {
797                     $getterContentTail = "\@\"href\"]";
798                 } elsif ($typeOfURL eq "Image" and $interfaceName eq "HTMLImageElement") {
799                     $getterContentTail = "\@\"src\"]";
800                 }
801                 $implIncludes{"DOMPrivate.h"} = 1;
802             } elsif ($idlType eq "NodeFilter") {
803                 push(@customGetterContent, "    if (m_filter)\n");
804                 push(@customGetterContent, "        // This node iterator was created from the Objective-C side.\n");
805                 push(@customGetterContent, "        return [[m_filter retain] autorelease];\n\n");
806                 push(@customGetterContent, "    // This node iterator was created from the C++ side.\n");
807                 $getterContentHead = "[$attributeClassName $typeMaker:WTF::getPtr(" . $getterContentHead;
808                 $getterContentTail .= ")]";
809             } elsif ($typeMaker ne "") {
810                 # Surround getter with TypeMaker
811                 $getterContentHead = "[$attributeTypeSansPtr $typeMaker:WTF::getPtr(" . $getterContentHead;
812                 $getterContentTail .= ")]";
813             }
814
815             my $getterContent;
816             if ($hasGetterException) {
817                 $getterContent = $getterContentHead . "ec" . $getterContentTail;
818             } else {
819                 $getterContent = $getterContentHead . $getterContentTail;
820             }
821
822             push(@implContent, $getterSig);
823             push(@implContent, "{\n");
824             if ($hasGetterException) {
825                 # Differentiated between when the return type is a pointer and
826                 # not for white space issue (ie. Foo *result vs. int result).
827                 if ($attributeType =~ /\*$/) {
828                     $getterContent = $attributeType . "result = " . $getterContent;
829                 } else {
830                     $getterContent = $attributeType . " result = " . $getterContent;
831                 }
832
833                 push(@implContent, @customGetterContent);
834                 push(@implContent, "    $exceptionInit\n");
835                 push(@implContent, "    $getterContent;\n");
836                 push(@implContent, "    $exceptionRaiseOnError\n");
837                 push(@implContent, "    return result;\n");
838             } else {
839                 push(@implContent, @customGetterContent);
840                 push(@implContent, "    return $getterContent;\n");
841             }
842             push(@implContent, "}\n\n");
843
844             # - SETTER
845             if (!$attributeIsReadonly) {
846                 # Exception handling
847                 my $hasSetterException = @{$attribute->setterExceptions};
848
849                 $attributeName = "set" . ucfirst($attributeName);
850                 my $setterName = "set" . ucfirst($attributeInterfaceName);
851                 my $argName = "new" . ucfirst($attributeInterfaceName);
852                 my $arg = GetObjCTypeGetter($argName, $idlType);
853
854                 my $setterSig = "- (void)$setterName:($attributeType)$argName\n";
855
856                 push(@implContent, $setterSig);
857                 push(@implContent, "{\n");
858
859                 unless ($codeGenerator->IsPrimitiveType($idlType) or IsStringType($idlType)) {
860                     push(@implContent, "    ASSERT($argName);\n\n");
861                 }
862
863                 if ($hasSetterException) {
864                     push(@implContent, "    $exceptionInit\n");
865                     push(@implContent, "    IMPL->$attributeName($arg, ec);\n");
866                     push(@implContent, "    $exceptionRaiseOnError\n");
867                 } else {
868                     push(@implContent, "    IMPL->$attributeName($arg);\n");
869                 }
870
871                 push(@implContent, "}\n\n");
872             }
873         }
874     }
875
876     my @deprecatedFunctions = ();
877
878     # - Functions
879     if ($numFunctions > 0) {
880         foreach my $function (@{$dataNode->functions}) {
881             AddIncludesForType($function->signature->type);
882
883             my $functionName = $function->signature->name;
884             my $returnType = GetObjCType($function->signature->type);
885             my $hasParameters = @{$function->parameters};
886             my $raisesExceptions = @{$function->raisesExceptions};
887
888             my @parameterNames = ();
889             my @needsAssert = ();
890             my %needsCustom = ();
891
892             my $parameterIndex = 0;
893             my $functionSig = "- ($returnType)$functionName";
894             foreach my $param (@{$function->parameters}) {
895                 my $paramName = $param->name;
896                 my $paramType = GetObjCType($param->type);
897
898                 # make a new parameter name if the original conflicts with a property name
899                 $paramName = "in" . ucfirst($paramName) if $attributeNames{$paramName};
900
901                 AddIncludesForType($param->type);
902
903                 my $idlType = $codeGenerator->StripModule($param->type);
904                 my $implGetter = GetObjCTypeGetter($paramName, $idlType);
905
906                 push(@parameterNames, $implGetter);
907                 $needsCustom{"XPathNSResolver"} = $paramName if $idlType eq "XPathNSResolver";
908                 $needsCustom{"EventTarget"} = $paramName if $idlType eq "EventTarget";
909                 $needsCustom{"NodeToReturn"} = $paramName if $param->extendedAttributes->{"Return"};
910
911                 unless ($codeGenerator->IsPrimitiveType($idlType) or IsStringType($idlType)) {
912                     push(@needsAssert, "    ASSERT($paramName);\n");
913                 }
914
915                 if ($parameterIndex >= 1) {
916                     my $paramPrefix = $param->extendedAttributes->{"ObjCPrefix"};
917                     $paramPrefix = $param->name unless defined($paramPrefix);
918                     $functionSig .= " $paramPrefix";
919                 }
920
921                 $functionSig .= ":($paramType)$paramName";
922
923                 $parameterIndex++;
924             }
925
926             my @functionContent = ();
927
928             # special case the XPathNSResolver
929             if (defined $needsCustom{"XPathNSResolver"}) {
930                 my $paramName = $needsCustom{"XPathNSResolver"};
931                 push(@functionContent, "    if ($paramName && ![$paramName isMemberOfClass:[DOMNativeXPathNSResolver class]])\n");
932                 push(@functionContent, "        [NSException raise:NSGenericException format:\@\"createExpression currently does not work with custom NS resolvers\"];\n");
933                 push(@functionContent, "    DOMNativeXPathNSResolver *nativeResolver = (DOMNativeXPathNSResolver *)$paramName;\n\n");
934             }
935
936             # special case the EventTarget
937             if (defined $needsCustom{"EventTarget"}) {
938                 my $paramName = $needsCustom{"EventTarget"};
939                 push(@functionContent, "    DOMNode* ${paramName}ObjC = $paramName;\n");
940                 push(@functionContent, "    WebCore::Node* ${paramName}Node = [${paramName}ObjC _node];\n");
941                 push(@functionContent, "    WebCore::EventTargetNode* ${paramName}EventTarget = (${paramName}Node && ${paramName}Node->isEventTargetNode()) ? static_cast<WebCore::EventTargetNode*>(${paramName}Node) : 0;\n\n");
942                 $implIncludes{"DOMNode.h"} = 1;
943                 $implIncludes{"Node.h"} = 1;
944             }
945
946             push(@parameterNames, "ec") if $raisesExceptions;
947
948             my $content = "IMPL->" . $functionName . "(" . join(", ", @parameterNames) . ")";
949
950             if ($returnType eq "void") {
951                 # Special case 'void' return type.
952                 if ($raisesExceptions) {
953                     push(@functionContent, "    $exceptionInit\n");
954                     push(@functionContent, "    $content;\n");
955                     push(@functionContent, "    $exceptionRaiseOnError\n");
956                 } else {
957                     push(@functionContent, "    $content;\n");
958                 }
959             } elsif (defined $needsCustom{"NodeToReturn"}) {
960                 # Special case the insertBefore, replaceChild, removeChild 
961                 # and appendChild functions from DOMNode 
962                 my $toReturn = $needsCustom{"NodeToReturn"};
963                 if ($raisesExceptions) {
964                     push(@functionContent, "    $exceptionInit\n");
965                     push(@functionContent, "    if ($content)\n");
966                     push(@functionContent, "        return $toReturn;\n");
967                     push(@functionContent, "    $exceptionRaiseOnError\n");
968                     push(@functionContent, "    return nil;\n");
969                 } else {
970                     push(@functionContent, "    if ($content)\n");
971                     push(@functionContent, "        return $toReturn;\n");
972                     push(@functionContent, "    return nil;\n");
973                 }
974             } else {
975                 my $typeMaker = GetObjCTypeMaker($function->signature->type);
976                 unless ($typeMaker eq "") {
977                     my $returnTypeClass = "";
978                     if ($function->signature->type eq "XPathNSResolver") {
979                         # Special case XPathNSResolver
980                         $returnTypeClass = "DOMNativeXPathNSResolver";
981                     } else {
982                         # Remove trailing " *" from pointer types.
983                         $returnTypeClass = $returnType;
984                         $returnTypeClass =~ s/ \*$//;
985                     }
986
987                     # Surround getter with TypeMaker
988                     if ($returnTypeClass eq "DOMRGBColor") {
989                         $content = "[$returnTypeClass $typeMaker:" . $content . "]";
990                     } else {
991                         $content = "[$returnTypeClass $typeMaker:WTF::getPtr(" . $content . ")]";
992                     }
993                 }
994
995                 if ($raisesExceptions) {
996                     # Differentiated between when the return type is a pointer and
997                     # not for white space issue (ie. Foo *result vs. int result).
998                     if ($returnType =~ /\*$/) {
999                         $content = $returnType . "result = " . $content;
1000                     } else {
1001                         $content = $returnType . " result = " . $content;
1002                     }
1003
1004                     push(@functionContent, "    $exceptionInit\n");
1005                     push(@functionContent, "    $content;\n");
1006                     push(@functionContent, "    $exceptionRaiseOnError\n");
1007                     push(@functionContent, "    return result;\n");
1008                 } else {
1009                     push(@functionContent, "    return $content;\n");
1010                 }
1011             }
1012
1013             push(@implContent, "$functionSig\n");
1014             push(@implContent, "{\n");
1015             push(@implContent, @functionContent);
1016             push(@implContent, "}\n\n");
1017
1018             # generate the old style method names with un-named parameters, these methods are deprecated
1019             if (@{$function->parameters} > 1 and $function->signature->extendedAttributes->{"OldStyleObjC"}) {
1020                 my $deprecatedFunctionSig = $functionSig;
1021                 $deprecatedFunctionSig =~ s/\s\w+:/ :/g; # remove parameter names
1022
1023                 push(@deprecatedFunctions, "$deprecatedFunctionSig\n");
1024                 push(@deprecatedFunctions, "{\n");
1025                 push(@deprecatedFunctions, @functionContent);
1026                 push(@deprecatedFunctions, "}\n\n");
1027             }
1028
1029             # Clear the hash
1030             %needsCustom = ();
1031         }
1032     }
1033
1034     # END implementation
1035     push(@implContent, "\@end\n");
1036
1037     if (@deprecatedFunctions > 0) {
1038         # - Deprecated category @implementation
1039         push(@implContent, "\n\@implementation $className (" . $className . "Deprecated)\n\n");
1040         push(@implContent, @deprecatedFunctions);
1041         push(@implContent, "\@end\n");
1042     }
1043
1044     unless ($dataNode->extendedAttributes->{ObjCNoInternal}) {
1045         # - BEGIN WebCoreInternal category @implementation
1046         push(@implContent, "\n\@implementation $className (WebCoreInternal)\n\n");
1047
1048         # - Type-Getter
1049         # - (WebCore::FooBar *)_fooBar for implementation class FooBar
1050         my $typeGetterName = GetObjCTypeGetterName($interfaceName);
1051         my $typeGetterSig = "- ($implClassNameWithNamespace *)$typeGetterName";
1052         push(@implContent, "$typeGetterSig\n");
1053         push(@implContent, "{\n");
1054         push(@implContent, "    return IMPL;\n");
1055         push(@implContent, "}\n\n");            
1056
1057         # - Type-Maker
1058         my $typeMakerName = GetObjCTypeMaker($interfaceName);
1059         my $typeMakerSig = "+ ($className *)$typeMakerName:($implClassNameWithNamespace *)impl";
1060         if ($parentImplClassName eq "Object") {        
1061             # - (id)_initWithFooBar:(WebCore::FooBar *)impl for implementation class FooBar
1062             my $initWithImplName = "_initWith" . $implClassName;
1063             push(@implContent, "- (id)$initWithImplName:($implClassNameWithNamespace *)impl\n");
1064             push(@implContent, "{\n");
1065             push(@implContent, "    [super _init];\n");
1066             push(@implContent, "    _internal = reinterpret_cast<DOMObjectInternal*>(impl);\n");
1067             push(@implContent, "    impl->ref();\n");
1068             push(@implContent, "    addDOMWrapper(self, impl);\n");
1069             push(@implContent, "    return self;\n");
1070             push(@implContent, "}\n\n");
1071     
1072             # - (DOMFooBar)_FooBarWith:(WebCore::FooBar *)impl for implementation class FooBar
1073             push(@implContent, "$typeMakerSig\n");
1074             push(@implContent, "{\n");
1075             push(@implContent, "    if (!impl)\n");
1076             push(@implContent, "        return nil;\n");
1077             push(@implContent, "    id cachedInstance;\n");
1078             push(@implContent, "    cachedInstance = getDOMWrapper(impl);\n");
1079             push(@implContent, "    if (cachedInstance)\n");
1080             push(@implContent, "        return [[cachedInstance retain] autorelease];\n");
1081             push(@implContent, "    return [[[self alloc] $initWithImplName:impl] autorelease];\n");
1082             push(@implContent, "}\n\n");
1083         } else {
1084             # - (DOMFooBar)_FooBarWith:(WebCore::FooBar *)impl for implementation class FooBar
1085             push(@implContent, "$typeMakerSig\n");
1086             push(@implContent, "{\n");
1087             push(@implContent, "    return static_cast<$className*>([DOMNode _nodeWith:impl]);\n");
1088             push(@implContent, "}\n\n");
1089         }
1090         # END WebCoreInternal category
1091         push(@implContent, "\@end\n");
1092         
1093         # Generate interface definitions. 
1094         @intenalHeaderContent = split("\r", $implementationLicenceTemplate);
1095         push(@intenalHeaderContent, "\n#import \"$className.h\"\n\n");
1096         push(@intenalHeaderContent, "namespace WebCore { class $implClassName; }\n\n");
1097         push(@intenalHeaderContent, "\@interface $className (WebCoreInternal)\n");
1098         push(@intenalHeaderContent, "- ($implClassNameWithNamespace *)$typeGetterName;\n");
1099         push(@intenalHeaderContent, "+ ($className *)$typeMakerName:($implClassNameWithNamespace *)impl;\n");
1100         push(@intenalHeaderContent, "\@end\n");
1101     }
1102
1103     # - End the ifdef conditional if necessary
1104     push(@implContent, "\n#endif // ${conditional}_SUPPORT\n\n") if $conditional;
1105 }
1106
1107 # Internal helper
1108 sub WriteData
1109 {
1110     my $object = shift;
1111     my $name = shift;
1112
1113     # Open files for writing...
1114     my $headerFileName = "$outputDir/" . $name . ".h";
1115     my $privateHeaderFileName = "$outputDir/" . $name . "Private.h";
1116     my $implFileName = "$outputDir/" . $name . ".mm";
1117     my $internalHeaderFileName = "$outputDir/" . $name . "Internal.h";
1118
1119     # Remove old files.
1120     unlink($headerFileName);
1121     unlink($privateHeaderFileName);
1122     unlink($implFileName);
1123     unlink($internalHeaderFileName);
1124
1125     # Write public header.
1126     open(HEADER, ">$headerFileName") or die "Couldn't open file $headerFileName";
1127     
1128     print HEADER @headerContentHeader;
1129     print HEADER map { "\@class $_;\n" } sort keys(%headerForwardDeclarations);
1130     print HEADER map { "\@protocol $_;\n" } sort keys(%headerForwardDeclarationsForProtocols);
1131
1132     my $hasForwardDeclarations =  keys(%headerForwardDeclarations) + keys(%headerForwardDeclarationsForProtocols);
1133     print HEADER "\n" if $hasForwardDeclarations;
1134     print HEADER @headerContent;
1135
1136     close(HEADER);
1137
1138     @headerContentHeader = ();
1139     @headerContent = ();
1140     %headerForwardDeclarations = ();
1141     %headerForwardDeclarationsForProtocols = ();
1142
1143     if (@privateHeaderContent > 0) {
1144         open(PRIVATE_HEADER, ">$privateHeaderFileName") or die "Couldn't open file $privateHeaderFileName";
1145
1146         print PRIVATE_HEADER @privateHeaderContentHeader;
1147         print PRIVATE_HEADER map { "\@class $_;\n" } sort keys(%privateHeaderForwardDeclarations);
1148         print PRIVATE_HEADER map { "\@protocol $_;\n" } sort keys(%privateHeaderForwardDeclarationsForProtocols);
1149
1150         $hasForwardDeclarations =  keys(%privateHeaderForwardDeclarations) + keys(%privateHeaderForwardDeclarationsForProtocols);
1151         print PRIVATE_HEADER "\n" if $hasForwardDeclarations;
1152         print PRIVATE_HEADER @privateHeaderContent;
1153
1154         close(PRIVATE_HEADER);
1155
1156         @privateHeaderContentHeader = ();
1157         @privateHeaderContent = ();
1158         %privateHeaderForwardDeclarations = ();
1159         %privateHeaderForwardDeclarationsForProtocols = ();
1160     }
1161
1162     # Write implementation file.
1163     unless ($isProtocol) {
1164         open(IMPL, ">$implFileName") or die "Couldn't open file $implFileName";
1165
1166         print IMPL @implContentHeader;
1167         print IMPL map { "#import \"$_\"\n" } sort keys(%implIncludes);
1168
1169         print IMPL "\n" if keys(%implIncludes);
1170         print IMPL @implContent;
1171
1172         close(IMPL);
1173
1174         @implContentHeader = ();
1175         @implContent = ();
1176         %implIncludes = ();
1177     }
1178     
1179     if (@intenalHeaderContent > 0) {
1180        open(INTERNAL_HEADER, ">$internalHeaderFileName") or die "Couldn't open file $internalHeaderFileName";
1181
1182        print INTERNAL_HEADER @intenalHeaderContent;
1183
1184        close(INTERNAL_HEADER);
1185
1186        @intenalHeaderContent = ();
1187     }
1188 }
1189
1190 1;