Changeset 34467 in webkit


Ignore:
Timestamp:
Jun 9, 2008 3:59:57 AM (16 years ago)
Author:
jchaffraix@webkit.org
Message:

WebCore:

2008-06-07 Julien Chaffraix <​jchaffraix@webkit.org>

Reviewed by Darin Adler.

Part of bug 19200: *.in files should embed more information
​https://bugs.webkit.org/show_bug.cgi?id=19200

  • Added a parameters hash that will hold the parameters we used to give in the command line.
  • Added "tags" / "attrs" XML tag parsing to fill the parameters hash.
  • Moved namespace, namespaceURI, namespacePrefix and cppNamespace in the *.in files.


  • dom/make_names.pl:
  • html/HTMLAttributeNames.in:
  • html/HTMLTagNames.in:
  • svg/svgattrs.in:
  • svg/svgtags.in:
  • svg/xlinkattrs.in:
  • xml/xmlattrs.in:
Location:
trunk/WebCore
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r34466 r34467  
     12008-06-07  Julien Chaffraix  <jchaffraix@webkit.org>
     2
     3        Reviewed by Darin Adler.
     4
     5        Part of bug 19200: *.in files should embed more information
     6        https://bugs.webkit.org/show_bug.cgi?id=19200
     7
     8        - Added a parameters hash that will hold the parameters we used to give in the
     9        command line.
     10
     11        - Added "tags" / "attrs" XML tag parsing to fill the parameters hash.
     12
     13        - Moved namespace, namespaceURI, namespacePrefix and cppNamespace in the *.in
     14        files.
     15
     16        * dom/make_names.pl:
     17        * html/HTMLAttributeNames.in:
     18        * html/HTMLTagNames.in:
     19        * svg/svgattrs.in:
     20        * svg/svgtags.in:
     21        * svg/xlinkattrs.in:
     22        * xml/xmlattrs.in:
     23
    1242008-06-09  Tor Arne Vestbø  <tavestbo@trolltech.com>
    225

  • trunk/WebCore/dom/make_names.pl

    r34415 r34467  
    3838my $printFactory = 0;
    3939my $printWrapperFactory = 0;
    40 my $cppNamespace = "";
    41 my $namespace = "";
    42 my $namespacePrefix = "";
    43 my $namespaceURI = "";
    4440my $tagsFile = "";
    4541my $attrsFile = "";
    … …  
    4743my %tags = ();
    4844my %attrs = ();
     45my %parameters = ();
    4946my $tagsNullNamespace = 0;
    5047my $attrsNullNamespace = 0;
    … …  
    5855    'attrs=s' => \$attrsFile,
    5956    'outputDir=s' => \$outputDir,
    60     'namespace=s' => \$namespace,
    61     'namespacePrefix=s' => \$namespacePrefix,
    62     'namespaceURI=s' => \$namespaceURI,
    63     'cppNamespace=s' => \$cppNamespace,
    6457    'factory' => \$printFactory,
    6558    'wrapperFactory' => \$printWrapperFactory,
    … …  
    7063    'guardFactoryWith=s' => \$guardFactoryWith);
    7164
    72 die "You must specify a namespace (e.g. SVG) for <namespace>Names.h" unless $namespace;
    73 die "You must specify a namespaceURI (e.g. http://www.w3.org/2000/svg)" unless $namespaceURI;
    74 die "You must specify a cppNamespace (e.g. DOM) used for <cppNamespace>::<namespace>Names::fooTag" unless $cppNamespace;
    7565die "You must specify at least one of --tags <file> or --attrs <file>" unless (length($tagsFile) || length($attrsFile));
    76 
    77 $namespacePrefix = $namespace unless $namespacePrefix;
    7866
    7967readNames($tagsFile) if length($tagsFile);
    8068readNames($attrsFile) if length($attrsFile);
    8169
     70die "You must specify a namespace (e.g. SVG) for <namespace>Names.h" unless $parameters{'namespace'};
     71die "You must specify a namespaceURI (e.g. http://www.w3.org/2000/svg)" unless $parameters{'namespaceURI'};
     72die "You must specify a cppNamespace (e.g. DOM) used for <cppNamespace>::<namespace>Names::fooTag" unless $parameters{'cppNamespace'};
     73
     74$parameters{'namespacePrefix'} = $parameters{'namespace'} unless $parameters{'namespacePrefix'};
     75
    8276mkpath($outputDir);
    83 my $namesBasePath = "$outputDir/${namespace}Names";
    84 my $factoryBasePath = "$outputDir/${namespace}ElementFactory";
    85 my $wrapperFactoryBasePath = "$outputDir/JS${namespace}ElementWrapperFactory";
     77my $namesBasePath = "$outputDir/$parameters{'namespace'}Names";
     78my $factoryBasePath = "$outputDir/$parameters{'namespace'}ElementFactory";
     79my $wrapperFactoryBasePath = "$outputDir/JS$parameters{'namespace'}ElementWrapperFactory";
    8680
    8781printNamesHeaderFile("$namesBasePath.h");
    … …  
    111105}
    112106
     107sub initializeParametersHash
     108{
     109    return ('namespace' => '',
     110            'namespacePrefix' => '',
     111            'namespaceURI' => '',
     112            'cppNamespace' => '');
     113}
    113114
    114115### Parsing handlers
    115116
    116117# Our files should have the following form :
    117 # <tags> or <attrs>
     118# <'tags' or 'attrs' globalProperty1 = 'value1' ... />
    118119# <'tag/attr name' 'property1' = 'value1' ... />
    119120# where the properties are defined in the initialize*PropertyHash methods.
    … …  
    159160}
    160161
     162sub parseParameters
     163{
     164    my $propertiesRef = shift;
     165    my %properties = %$propertiesRef;
     166
     167    # Initialize default properties' values.
     168    %parameters = initializeParametersHash() if !(keys %parameters);
     169
     170    # Parse the XML attributes.
     171    foreach my $property (keys %properties) {
     172        die "Unknown parameter $property for tags/attrs\n" if !defined($parameters{$property});
     173        $parameters{$property} = $properties{$property};
     174    }
     175}
     176
    161177## Support routines
    162178
    … …  
    185201    switch($name) {
    186202        case "tags" {
     203            parseParameters(\%{$document{'attrib'}});
    187204            parseTags(\@{$document{'content'}});
    188205        }
    189206        case "attrs" {
     207            parseParameters(\%{$document{'attrib'}});
    190208            parseAttrs(\@{$document{'content'}});
    191         }
    192     }
    193 
    194     # FIXME: we should process the attributes here to build a parameter map
     209        } else {
     210            die "Do not know how to parse file starting with $name!\n";
     211        }
     212    }
    195213
    196214    close($names);
    … …  
    216234        my $ucName = $names{$name}{"upperCase"};
    217235
    218         print F "${namespace}Element* ${name}Constructor(Document* doc, bool createdByParser)\n";
     236        print F "$parameters{'namespace'}Element* ${name}Constructor(Document* doc, bool createdByParser)\n";
    219237        print F "{\n";
    220         print F "    return new ${namespace}${ucName}Element(${name}Tag, doc);\n";
     238        print F "    return new $parameters{'namespace'}${ucName}Element(${name}Tag, doc);\n";
    221239        print F "}\n\n";
    222240    }
    … …  
    247265    my $name = shift;
    248266   
    249     $name = svgCapitalizationHacks($name) if ($namespace eq "SVG");
     267    $name = svgCapitalizationHacks($name) if ($parameters{'namespace'} eq "SVG");
    250268
    251269    while ($name =~ /^(.*?)_(.*)/) {
    … …  
    298316   
    299317    printLicenseHeader($F);
    300     print F "#ifndef DOM_${namespace}NAMES_H\n";
    301     print F "#define DOM_${namespace}NAMES_H\n\n";
     318    print F "#ifndef DOM_$parameters{'namespace'}NAMES_H\n";
     319    print F "#define DOM_$parameters{'namespace'}NAMES_H\n\n";
    302320    print F "#include \"QualifiedName.h\"\n\n";
    303321   
    304     print F "namespace $cppNamespace { namespace ${namespace}Names {\n\n";
    305    
    306     my $lowerNamespace = lc($namespacePrefix);
    307     print F "#ifndef DOM_${namespace}NAMES_HIDE_GLOBALS\n";
     322    print F "namespace $parameters{'cppNamespace'} { namespace $parameters{'namespace'}Names {\n\n";
     323   
     324    my $lowerNamespace = lc($parameters{'namespacePrefix'});
     325    print F "#ifndef DOM_$parameters{'namespace'}NAMES_HIDE_GLOBALS\n";
    308326    print F "// Namespace\n";
    309327    print F "extern const WebCore::AtomicString ${lowerNamespace}NamespaceURI;\n\n";
    … …  
    312330        print F "// Tags\n";
    313331        printMacros($F, "extern const WebCore::QualifiedName", "Tag", \%tags);
    314         print F "\n\nWebCore::QualifiedName** get${namespace}Tags(size_t* size);\n";
     332        print F "\n\nWebCore::QualifiedName** get$parameters{'namespace'}Tags(size_t* size);\n";
    315333    }
    316334   
    … …  
    318336        print F "// Attributes\n";
    319337        printMacros($F, "extern const WebCore::QualifiedName", "Attr", \%attrs);
    320         print F "\n\nWebCore::QualifiedName** get${namespace}Attr(size_t* size);\n";
     338        print F "\n\nWebCore::QualifiedName** get$parameters{'namespace'}Attr(size_t* size);\n";
    321339    }
    322340    print F "#endif\n\n";
    … …  
    336354    printLicenseHeader($F);
    337355   
    338     my $lowerNamespace = lc($namespacePrefix);
     356    my $lowerNamespace = lc($parameters{'namespacePrefix'});
    339357
    340358print F "#include \"config.h\"\n";
    341359
    342360print F "#ifdef AVOID_STATIC_CONSTRUCTORS\n";
    343 print F "#define DOM_${namespace}NAMES_HIDE_GLOBALS 1\n";
     361print F "#define DOM_$parameters{'namespace'}NAMES_HIDE_GLOBALS 1\n";
    344362print F "#else\n";
    345363print F "#define QNAME_DEFAULT_CONSTRUCTOR 1\n";
    … …  
    347365
    348366
    349 print F "#include \"${namespace}Names.h\"\n\n";
     367print F "#include \"$parameters{'namespace'}Names.h\"\n\n";
    350368print F "#include \"StaticConstructors.h\"\n";
    351369
    352 print F "namespace $cppNamespace { namespace ${namespace}Names {
     370print F "namespace $parameters{'cppNamespace'} { namespace $parameters{'namespace'}Names {
    353371
    354372using namespace WebCore;
    355373
    356 DEFINE_GLOBAL(AtomicString, ${lowerNamespace}NamespaceURI, \"$namespaceURI\")
     374DEFINE_GLOBAL(AtomicString, ${lowerNamespace}NamespaceURI, \"$parameters{'namespaceURI'}\")
    357375";
    358376
    … …  
    363381        }
    364382       
    365         print F "\n\nWebCore::QualifiedName** get${namespace}Tags(size_t* size)\n";
    366         print F "{\n    static WebCore::QualifiedName* ${namespace}Tags[] = {\n";
     383        print F "\n\nWebCore::QualifiedName** get$parameters{'namespace'}Tags(size_t* size)\n";
     384        print F "{\n    static WebCore::QualifiedName* $parameters{'namespace'}Tags[] = {\n";
    367385        for my $name (sort keys %tags) {
    368386            print F "        (WebCore::QualifiedName*)&${name}Tag,\n";
    … …  
    370388        print F "    };\n";
    371389        print F "    *size = ", scalar(keys %tags), ";\n";
    372         print F "    return ${namespace}Tags;\n";
     390        print F "    return $parameters{'namespace'}Tags;\n";
    373391        print F "}\n";
    374392       
    … …  
    380398            print F "DEFINE_GLOBAL(QualifiedName, ", $name, "Attr, nullAtom, \"$name\", ${lowerNamespace}NamespaceURI);\n";
    381399        }
    382         print F "\n\nWebCore::QualifiedName** get${namespace}Attrs(size_t* size)\n";
    383         print F "{\n    static WebCore::QualifiedName* ${namespace}Attr[] = {\n";
     400        print F "\n\nWebCore::QualifiedName** get$parameters{'namespace'}Attrs(size_t* size)\n";
     401        print F "{\n    static WebCore::QualifiedName* $parameters{'namespace'}Attr[] = {\n";
    384402        for my $name (sort keys %attrs) {
    385403            print F "        (WebCore::QualifiedName*)&${name}Attr,\n";
    … …  
    387405        print F "    };\n";
    388406        print F "    *size = ", scalar(keys %attrs), ";\n";
    389         print F "    return ${namespace}Attr;\n";
     407        print F "    return $parameters{'namespace'}Attr;\n";
    390408        print F "}\n";
    391409    }
    … …  
    403421";
    404422   
    405     print(F "    AtomicString ${lowerNamespace}NS(\"$namespaceURI\");\n\n");
     423    print(F "    AtomicString ${lowerNamespace}NS(\"$parameters{'namespaceURI'}\");\n\n");
    406424
    407425    print(F "    // Namespace\n");
    … …  
    428446
    429447        my $ucName = $names{$name}{"upperCase"};
    430         print F "#include \"JS${namespace}${ucName}Element.h\"\n";
     448        print F "#include \"JS$parameters{'namespace'}${ucName}Element.h\"\n";
    431449    }
    432450}
    … …  
    440458
    441459        my $ucName = $names{$name}{"upperCase"};
    442         print F "#include \"${namespace}${ucName}Element.h\"\n";
     460        print F "#include \"$parameters{'namespace'}${ucName}Element.h\"\n";
    443461    }
    444462}
    … …  
    485503print F <<END
    486504#include "config.h"
    487 #include "${namespace}ElementFactory.h"
    488 #include "${namespace}Names.h"
     505#include "$parameters{'namespace'}ElementFactory.h"
     506#include "$parameters{'namespace'}Names.h"
    489507#include "Page.h"
    490508#include "Settings.h"
    … …  
    498516
    499517using namespace WebCore;
    500 using namespace ${cppNamespace}::${namespace}Names;
    501 
    502 typedef ${namespace}Element* (*ConstructorFunc)(Document* doc, bool createdByParser);
     518using namespace $parameters{'cppNamespace'}::$parameters{'namespace'}Names;
     519
     520typedef $parameters{'namespace'}Element* (*ConstructorFunc)(Document* doc, bool createdByParser);
    503521typedef WTF::HashMap<AtomicStringImpl*, ConstructorFunc> FunctionMap;
    504522
    505523static FunctionMap* gFunctionMap = 0;
    506524
    507 namespace ${cppNamespace} {
     525namespace $parameters{'cppNamespace'} {
    508526
    509527END
    … …  
    532550
    533551print F <<END
    534 ${namespace}Element* ${namespace}ElementFactory::create${namespace}Element(const QualifiedName& qName, Document* doc, bool createdByParser)
     552$parameters{'namespace'}Element* $parameters{'namespace'}ElementFactory::create$parameters{'namespace'}Element(const QualifiedName& qName, Document* doc, bool createdByParser)
    535553{
    536554END
    … …  
    555573        return func(doc, createdByParser);
    556574
    557     return new ${namespace}Element(qName, doc);
     575    return new $parameters{'namespace'}Element(qName, doc);
    558576END
    559577;
    … …  
    589607    printLicenseHeader($F);
    590608
    591 print F "#ifndef ${namespace}ELEMENTFACTORY_H\n";
    592 print F "#define ${namespace}ELEMENTFACTORY_H\n\n";
     609print F "#ifndef $parameters{'namespace'}ELEMENTFACTORY_H\n";
     610print F "#define $parameters{'namespace'}ELEMENTFACTORY_H\n\n";
    593611
    594612print F "
    … …  
    600618}
    601619
    602 namespace ${cppNamespace}
    603 {
    604     class ${namespace}Element;
     620namespace $parameters{'cppNamespace'}
     621{
     622    class $parameters{'namespace'}Element;
    605623
    606624    // The idea behind this class is that there will eventually be a mapping from namespace URIs to ElementFactories that can dispense
    607625    // elements.  In a compound document world, the generic createElement function (will end up being virtual) will be called.
    608     class ${namespace}ElementFactory
     626    class $parameters{'namespace'}ElementFactory
    609627    {
    610628    public:
    611629        WebCore::Element* createElement(const WebCore::QualifiedName& qName, WebCore::Document* doc, bool createdByParser = true);
    612         static ${namespace}Element* create${namespace}Element(const WebCore::QualifiedName& qName, WebCore::Document* doc, bool createdByParser = true);
     630        static $parameters{'namespace'}Element* create$parameters{'namespace'}Element(const WebCore::QualifiedName& qName, WebCore::Document* doc, bool createdByParser = true);
    613631    };
    614632}
    … …  
    687705    my $name = shift;
    688706    initializeCustomMappings();
    689     return 1 if $namespace eq "HTML" && exists($htmlCustomMappings{$name});
    690     return 1 if $namespace eq "SVG" && exists($svgCustomMappings{$name});
     707    return 1 if $parameters{'namespace'} eq "HTML" && exists($htmlCustomMappings{$name});
     708    return 1 if $parameters{'namespace'} eq "SVG" && exists($svgCustomMappings{$name});
    691709    return 0;
    692710}
    … …  
    704722        if ($names{$name}{"applyAudioHack"}) {
    705723            print F <<END
    706 static JSNode* create${ucName}Wrapper(ExecState* exec, PassRefPtr<${namespace}Element> element)
     724static JSNode* create${ucName}Wrapper(ExecState* exec, PassRefPtr<$parameters{'namespace'}Element> element)
    707725{
    708726    if (!MediaPlayer::isAvailable())
    709         return new JS${namespace}Element(JS${namespace}ElementPrototype::self(exec), element.get());
    710     return new JS${namespace}${ucName}Element(JS${namespace}${ucName}ElementPrototype::self(exec), static_cast<${namespace}${ucName}Element*>(element.get()));
     727        return new JS$parameters{'namespace'}Element(JS$parameters{'namespace'}ElementPrototype::self(exec), element.get());
     728    return new JS$parameters{'namespace'}${ucName}Element(JS$parameters{'namespace'}${ucName}ElementPrototype::self(exec), static_cast<$parameters{'namespace'}${ucName}Element*>(element.get()));
    711729}
    712730
    … …  
    715733        } else {
    716734            print F <<END
    717 static JSNode* create${ucName}Wrapper(ExecState* exec, PassRefPtr<${namespace}Element> element)
     735static JSNode* create${ucName}Wrapper(ExecState* exec, PassRefPtr<$parameters{'namespace'}Element> element)
    718736{   
    719     return new JS${namespace}${ucName}Element(JS${namespace}${ucName}ElementPrototype::self(exec), static_cast<${namespace}${ucName}Element*>(element.get()));
     737    return new JS$parameters{'namespace'}${ucName}Element(JS$parameters{'namespace'}${ucName}ElementPrototype::self(exec), static_cast<$parameters{'namespace'}${ucName}Element*>(element.get()));
    720738}
    721739
    … …  
    738756    print F "#if $guardFactoryWith\n\n" if $guardFactoryWith;
    739757
    740     print F "#include \"JS${namespace}ElementWrapperFactory.h\"\n";
     758    print F "#include \"JS$parameters{'namespace'}ElementWrapperFactory.h\"\n";
    741759
    742760    printJSElementIncludes($F, \%tags);
    743761
    744     print F "\n#include \"${namespace}Names.h\"\n\n";
     762    print F "\n#include \"$parameters{'namespace'}Names.h\"\n\n";
    745763
    746764    printElementIncludes($F, \%tags, 1);
    … …  
    751769namespace WebCore {
    752770
    753 using namespace ${namespace}Names;
    754 
    755 typedef JSNode* (*Create${namespace}ElementWrapperFunction)(ExecState*, PassRefPtr<${namespace}Element>);
     771using namespace $parameters{'namespace'}Names;
     772
     773typedef JSNode* (*Create$parameters{'namespace'}ElementWrapperFunction)(ExecState*, PassRefPtr<$parameters{'namespace'}Element>);
    756774
    757775END
    … …  
    761779
    762780    print F <<END
    763 JSNode* createJS${namespace}Wrapper(ExecState* exec, PassRefPtr<${namespace}Element> element)
     781JSNode* createJS$parameters{'namespace'}Wrapper(ExecState* exec, PassRefPtr<$parameters{'namespace'}Element> element)
    764782{   
    765     static HashMap<WebCore::AtomicStringImpl*, Create${namespace}ElementWrapperFunction> map;
     783    static HashMap<WebCore::AtomicStringImpl*, Create$parameters{'namespace'}ElementWrapperFunction> map;
    766784    if (map.isEmpty()) {
    767785END
    … …  
    775793    }
    776794
    777     if ($namespace eq "HTML") {
     795    if ($parameters{'namespace'} eq "HTML") {
    778796        for my $tag (sort keys %htmlCustomMappings) {
    779797            next if !$htmlCustomMappings{$tag};
    … …  
    788806    print F <<END
    789807    }
    790     Create${namespace}ElementWrapperFunction createWrapperFunction = map.get(element->localName().impl());
     808    Create$parameters{'namespace'}ElementWrapperFunction createWrapperFunction = map.get(element->localName().impl());
    791809    if (createWrapperFunction)
    792810        return createWrapperFunction(exec, element);
    793     return new JS${namespace}Element(JS${namespace}ElementPrototype::self(exec), element.get());
     811    return new JS$parameters{'namespace'}Element(JS$parameters{'namespace'}ElementPrototype::self(exec), element.get());
    794812}
    795813
    … …  
    812830    printLicenseHeader($F);
    813831
    814     print F "#ifndef JS${namespace}ElementWrapperFactory_h\n";
    815     print F "#define JS${namespace}ElementWrapperFactory_h\n\n";
     832    print F "#ifndef JS$parameters{'namespace'}ElementWrapperFactory_h\n";
     833    print F "#define JS$parameters{'namespace'}ElementWrapperFactory_h\n\n";
    816834
    817835    print F "#if ${guardFactoryWith}\n" if $guardFactoryWith;
    … …  
    827845
    828846    class JSNode;
    829     class ${namespace}Element;
    830 
    831     JSNode* createJS${namespace}Wrapper(KJS::ExecState*, PassRefPtr<${namespace}Element>);
     847    class $parameters{'namespace'}Element;
     848
     849    JSNode* createJS$parameters{'namespace'}Wrapper(KJS::ExecState*, PassRefPtr<$parameters{'namespace'}Element>);
    832850
    833851}
    … …  
    838856    print F "#endif // $guardFactoryWith\n\n" if $guardFactoryWith;
    839857
    840     print F "#endif // JS${namespace}ElementWrapperFactory_h\n";
     858    print F "#endif // JS$parameters{'namespace'}ElementWrapperFactory_h\n";
    841859
    842860    close F;

  • trunk/WebCore/html/HTMLAttributeNames.in

    r34410 r34467  
    1 <attrs>
     1<attrs namespace="HTML" namespacePrefix="xhtml" cppNamespace="WebCore" namespaceURI="http://www.w3.org/1999/xhtml">
    22<abbr/>
    33<accept_charset/>

  • trunk/WebCore/html/HTMLTagNames.in

    r34415 r34467  
    1 <tags>
     1<tags namespace="HTML" namespacePrefix="xhtml" cppNamespace="WebCore" namespaceURI="http://www.w3.org/1999/xhtml">
    22<a upperCase="Anchor"/>
    33<abbr/>

  • trunk/WebCore/svg/svgattrs.in

    r34410 r34467  
    1 <attrs>
     1<attrs namespace="SVG" cppNamespace="WebCore" namespaceURI="http://www.w3.org/2000/svg">
    22<accent-height/>
    33<accumulate/>

  • trunk/WebCore/svg/svgtags.in

    r34415 r34467  
    1 <tags>
     1<tags namespace="SVG" cppNamespace="WebCore" namespaceURI="http://www.w3.org/2000/svg">
    22<a/>
    33#if ENABLE_SVG_FONTS

  • trunk/WebCore/svg/xlinkattrs.in

    r34410 r34467  
    1 <attrs>
     1<attrs namespace="XLink" cppNamespace="WebCore" namespaceURI="http://www.w3.org/1999/xlink">
    22<actuate/>
    33<arcrole/>

  • trunk/WebCore/xml/xmlattrs.in

    r34410 r34467  
    1 <attrs>
     1<attrs namespace="XML" cppNamespace="WebCore" namespaceURI="http://www.w3.org/XML/1998/namespace">
    22<base/>
    33<lang/>
Note: See TracChangeset for help on using the changeset viewer.