#!/usr/bin/perl -w

# Copyright (C) 2005, 2006, 2007, 2009 Apple Inc. All rights reserved.

# Copyright (C) 2009, Julien Chaffraix <jchaffraix@webkit.org>

# Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)

#

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions

# are met:

#

# 1.  Redistributions of source code must retain the above copyright

#     notice, this list of conditions and the following disclaimer. 

# 2.  Redistributions in binary form must reproduce the above copyright

#     notice, this list of conditions and the following disclaimer in the

#     documentation and/or other materials provided with the distribution. 

# 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of

#     its contributors may be used to endorse or promote products derived

#     from this software without specific prior written permission. 

#

# THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY

# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

# DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY

# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

use strict;

use Config;

use Getopt::Long;

use File::Path;

use IO::File;

use InFilesParser;

use Switch;

sub readTags($$);

sub readAttrs($$);

my $printFactory = 0; 

my $printWrapperFactory = 0; 

my $printWrapperFactoryV8 = 0; 

my $tagsFile = "";

my $attrsFile = "";

my $outputDir = ".";

my %parsedTags = ();

my %parsedAttrs = ();

my %enabledTags = ();

my %enabledAttrs = ();

my %allTags = ();

my %allAttrs = ();

my %parameters = ();

my $extraDefines = 0;

require Config;

my $gccLocation = "";

if ($ENV{CC}) {

    $gccLocation = $ENV{CC};

} elsif (($Config::Config{'osname'}) =~ /solaris/i) {

    $gccLocation = "/usr/sfw/bin/gcc";

} else {

    $gccLocation = "/usr/bin/gcc";

}

my $preprocessor = $gccLocation . " -E -P -x c++";

GetOptions(

    'tags=s' => \$tagsFile, 

    'attrs=s' => \$attrsFile,

    'factory' => \$printFactory,

    'outputDir=s' => \$outputDir,

    'extraDefines=s' => \$extraDefines,

    'preprocessor=s' => \$preprocessor,

    'wrapperFactory' => \$printWrapperFactory,

    'wrapperFactoryV8' => \$printWrapperFactoryV8

);

die "You must specify at least one of --tags <file> or --attrs <file>" unless (length($tagsFile) || length($attrsFile));

if (length($tagsFile)) {

    %allTags = %{readTags($tagsFile, 0)};

    %enabledTags = %{readTags($tagsFile, 1)};

}

if (length($attrsFile)) {

    %allAttrs = %{readAttrs($attrsFile, 0)};

    %enabledAttrs = %{readAttrs($attrsFile, 1)};

}

die "You must specify a namespace (e.g. SVG) for <namespace>Names.h" unless $parameters{namespace};

die "You must specify a namespaceURI (e.g. http://www.w3.org/2000/svg)" unless $parameters{namespaceURI};

$parameters{namespacePrefix} = $parameters{namespace} unless $parameters{namespacePrefix};

mkpath($outputDir);

my $namesBasePath = "$outputDir/$parameters{namespace}Names";

my $factoryBasePath = "$outputDir/$parameters{namespace}ElementFactory";

my $wrapperFactoryFileName = "$parameters{namespace}ElementWrapperFactory";

printNamesHeaderFile("$namesBasePath.h");

printNamesCppFile("$namesBasePath.cpp");

if ($printFactory) {

    printFactoryCppFile("$factoryBasePath.cpp");

    printFactoryHeaderFile("$factoryBasePath.h");

}

die "You cannot specify both --wrapperFactory and --wrapperFactoryV8" if $printWrapperFactory && $printWrapperFactoryV8;

my $wrapperFactoryType = "";

if ($printWrapperFactory) {

    $wrapperFactoryType = "JS";

} elsif ($printWrapperFactoryV8) {

    $wrapperFactoryType = "V8";

}

if ($wrapperFactoryType) {

    printWrapperFactoryCppFile($outputDir, $wrapperFactoryType, $wrapperFactoryFileName);

    printWrapperFactoryHeaderFile($outputDir, $wrapperFactoryType, $wrapperFactoryFileName);

}

### Hash initialization

sub defaultTagPropertyHash

{

    return (

        'constructorNeedsCreatedByParser' => 0,

        'constructorNeedsFormElement' => 0,

        'createWithNew' => 0,

        'interfaceName' => defaultInterfaceName($_[0]),

        # By default, the JSInterfaceName is the same as the interfaceName.

        'JSInterfaceName' => defaultInterfaceName($_[0]),

        'mapToTagName' => '',

        'wrapperOnlyIfMediaIsAvailable' => 0,

        'conditional' => 0

    );

}

sub defaultParametersHash

{

    return (

        'namespace' => '',

        'namespacePrefix' => '',

        'namespaceURI' => '',

        'guardFactoryWith' => '',

        'tagsNullNamespace' => 0,

        'attrsNullNamespace' => 0

    );

}

sub defaultInterfaceName

{

    die "No namespace found" if !$parameters{namespace};

    return $parameters{namespace} . upperCaseName($_[0]) . "Element"

}

### Parsing handlers

sub tagsHandler

{

    my ($tag, $property, $value) = @_;

    $tag =~ s/-/_/g;

    # Initialize default property values.

    $parsedTags{$tag} = { defaultTagPropertyHash($tag) } if !defined($parsedTags{$tag});

    if ($property) {

        die "Unknown property $property for tag $tag\n" if !defined($parsedTags{$tag}{$property});

        # The code relies on JSInterfaceName deriving from interfaceName to check for custom JSInterfaceName.

        # So override JSInterfaceName if it was not already set.

        $parsedTags{$tag}{JSInterfaceName} = $value if $property eq "interfaceName" && $parsedTags{$tag}{JSInterfaceName} eq $parsedTags{$tag}{interfaceName};

        $parsedTags{$tag}{$property} = $value;

    }

}

sub attrsHandler

{

    my ($attr, $property, $value) = @_;

    $attr =~ s/-/_/g;

    # Initialize default properties' values.

    $parsedAttrs{$attr} = {} if !defined($parsedAttrs{$attr});

    if ($property) {

        die "Unknown property $property for attribute $attr\n" if !defined($parsedAttrs{$attr}{$property});

        $parsedAttrs{$attr}{$property} = $value;

    }

}

sub parametersHandler

{

    my ($parameter, $value) = @_;

    # Initialize default properties' values.

    %parameters = defaultParametersHash() if !(keys %parameters);

    die "Unknown parameter $parameter for tags/attrs\n" if !defined($parameters{$parameter});

    $parameters{$parameter} = $value;

}

## Support routines

sub preprocessorCommand()

{

    return $preprocessor if $extraDefines eq 0;

    return $preprocessor . " -D" . join(" -D", split(" ", $extraDefines));

}

sub readNames($$$$)

{

    my ($namesFile, $hashToFillRef, $handler, $usePreprocessor) = @_;

    my $names = new IO::File;

    if ($usePreprocessor) {

        open($names, preprocessorCommand() . " " . $namesFile . "|") or die "Failed to open file: $namesFile";

    } else {

        open($names, $namesFile) or die "Failed to open file: $namesFile";

    }

    my $InParser = InFilesParser->new();

    $InParser->parse($names, \&parametersHandler, $handler);

    close($names);

    die "Failed to read names from file: $namesFile" if (keys %{$hashToFillRef} == 0);

    return $hashToFillRef;

}

sub readAttrs($$)

{

    my ($namesFile, $usePreprocessor) = @_;

    %parsedAttrs = ();

    return readNames($namesFile, \%parsedAttrs, \&attrsHandler, $usePreprocessor);

}

sub readTags($$)

{

    my ($namesFile, $usePreprocessor) = @_;

    %parsedTags = ();

    return readNames($namesFile, \%parsedTags, \&tagsHandler, $usePreprocessor);

}

sub printMacros

{

    my ($F, $macro, $suffix, $namesRef) = @_;

    my %names = %$namesRef;

    for my $name (sort keys %$namesRef) {

        print F "$macro $name","$suffix;\n";

    }

}

sub usesDefaultWrapper

{

    my $tagName = shift;

    return $tagName eq $parameters{namespace} . "Element";

}

# Build a direct mapping from the tags to the Element to create, excluding

# Element that have not constructor.

sub buildConstructorMap

{

    my %tagConstructorMap = ();

    for my $tagName (keys %enabledTags) {

        my $interfaceName = $enabledTags{$tagName}{interfaceName};

        next if (usesDefaultWrapper($interfaceName));

        if ($enabledTags{$tagName}{mapToTagName}) {

            die "Cannot handle multiple mapToTagName for $tagName\n" if $enabledTags{$enabledTags{$tagName}{mapToTagName}}{mapToTagName};

            $interfaceName = $enabledTags{ $enabledTags{$tagName}{mapToTagName} }{interfaceName};

        }

        # Chop the string to keep the interesting part.

        $interfaceName =~ s/$parameters{namespace}(.*)Element/$1/;

        $tagConstructorMap{$tagName} = lc($interfaceName);

    }

    return %tagConstructorMap;

}

# Helper method that print the constructor's signature avoiding

# unneeded arguments.

sub printConstructorSignature

{

    my ($F, $tagName, $constructorName, $constructorTagName) = @_;

    print F "static PassRefPtr<$parameters{namespace}Element> ${constructorName}Constructor(const QualifiedName& $constructorTagName, Document* document";

    if ($parameters{namespace} eq "HTML") {

        print F ", HTMLFormElement*";

        print F " formElement" if $enabledTags{$tagName}{constructorNeedsFormElement};

    }

    print F ", bool";

    print F " createdByParser" if $enabledTags{$tagName}{constructorNeedsCreatedByParser};

    print F ")\n{\n";

}

# Helper method to dump the constructor interior and call the 

# Element constructor with the right arguments.

# The variable names should be kept in sync with the previous method.

sub printConstructorInterior

{

    my ($F, $tagName, $interfaceName, $constructorTagName) = @_;

    # Handle media elements.

    if ($enabledTags{$tagName}{wrapperOnlyIfMediaIsAvailable}) {

        print F <<END

    Settings* settings = document->settings();

    if (!MediaPlayer::isAvailable() || (settings && !settings->isMediaEnabled()))

        return HTMLElement::create($constructorTagName, document);

END

;

    }

    my $newPrefix = "";

    my $createSuffix = "::create";

    if ($enabledTags{$tagName}{createWithNew}) {

        $newPrefix = "new ";

        $createSuffix = "";

    }

    # Call the constructor with the right parameters.

    print F "    return $newPrefix$interfaceName${createSuffix}($constructorTagName, document";

    print F ", formElement" if $enabledTags{$tagName}{constructorNeedsFormElement};

    print F ", createdByParser" if $enabledTags{$tagName}{constructorNeedsCreatedByParser};

    print F ");\n}\n\n";

}

sub printConstructors

{

    my ($F, $tagConstructorMapRef) = @_;

    my %tagConstructorMap = %$tagConstructorMapRef;

    # This is to avoid generating the same constructor several times.

    my %uniqueTags = ();

    for my $tagName (sort keys %tagConstructorMap) {

        my $interfaceName = $enabledTags{$tagName}{interfaceName};

        # Ignore the mapped tag

        # FIXME: It could be moved inside this loop but was split for readibility.

        next if (defined($uniqueTags{$interfaceName}) || $enabledTags{$tagName}{mapToTagName});

        $uniqueTags{$interfaceName} = '1';

        my $conditional = $enabledTags{$tagName}{conditional};

        if ($conditional) {

            my $conditionalString = "ENABLE(" . join(") && ENABLE(", split(/&/, $conditional)) . ")";

            print F "#if ${conditionalString}\n\n";

        }

        printConstructorSignature($F, $tagName, $tagConstructorMap{$tagName}, "tagName");

        printConstructorInterior($F, $tagName, $interfaceName, "tagName");

        if ($conditional) {

            print F "#endif\n";

        }

    }

    # Mapped tag name uses a special wrapper to keep their prefix and namespaceURI while using the mapped localname.

    for my $tagName (sort keys %tagConstructorMap) {

        if ($enabledTags{$tagName}{mapToTagName}) {

            my $mappedName = $enabledTags{$tagName}{mapToTagName};

            printConstructorSignature($F, $mappedName, $mappedName . "To" . $tagName, "tagName");

            printConstructorInterior($F, $mappedName, $enabledTags{$mappedName}{interfaceName}, "QualifiedName(tagName.prefix(), ${mappedName}Tag.localName(), tagName.namespaceURI())");

        }

    }

}

sub printFunctionInits

{

    my ($F, $tagConstructorMap) = @_;

    my %tagConstructorMap = %$tagConstructorMap;

    for my $tagName (sort keys %tagConstructorMap) {

        my $conditional = $enabledTags{$tagName}{conditional};

        if ($conditional) {

            my $conditionalString = "ENABLE(" . join(") && ENABLE(", split(/&/, $conditional)) . ")";

            print F "#if ${conditionalString}\n";

        }

        if ($enabledTags{$tagName}{mapToTagName}) {

            print F "    addTag(${tagName}Tag, $enabledTags{$tagName}{mapToTagName}To${tagName}Constructor);\n";

        } else {

            print F "    addTag(${tagName}Tag, $tagConstructorMap{$tagName}Constructor);\n";

        }

        if ($conditional) {

            print F "#endif\n\n";

        }

    }

}

sub svgCapitalizationHacks

{

    my $name = shift;

    $name = "FE" . ucfirst $1 if $name =~ /^fe(.+)$/;

    return $name;

}

sub upperCaseName

{

    my $name = shift;

    $name = svgCapitalizationHacks($name) if ($parameters{namespace} eq "SVG");

    while ($name =~ /^(.*?)_(.*)/) {

        $name = $1 . ucfirst $2;

    }

    return ucfirst $name;

}

sub printLicenseHeader

{

    my $F = shift;

    print F "/*

 * THIS FILE WAS AUTOMATICALLY GENERATED, DO NOT EDIT.

 *

 * This file was generated by the dom/make_names.pl script.

 *

 * Copyright (C) 2005, 2006, 2007, 2008, 2009 Apple Inc.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

";

}

sub printNamesHeaderFile

{

    my ($headerPath) = shift;

    my $F;

    open F, ">$headerPath";

    printLicenseHeader($F);

    print F "#ifndef DOM_$parameters{namespace}NAMES_H\n";

    print F "#define DOM_$parameters{namespace}NAMES_H\n\n";

    print F "#include \"QualifiedName.h\"\n\n";

    print F "namespace WebCore {\n\n namespace $parameters{namespace}Names {\n\n";

    my $lowerNamespace = lc($parameters{namespacePrefix});

    print F "#ifndef DOM_$parameters{namespace}NAMES_HIDE_GLOBALS\n";

    print F "// Namespace\n";

    print F "extern const WebCore::AtomicString ${lowerNamespace}NamespaceURI;\n\n";

    if (keys %allTags) {

        print F "// Tags\n";

        printMacros($F, "extern const WebCore::QualifiedName", "Tag", \%allTags);

    }

    if (keys %allAttrs) {

        print F "// Attributes\n";

        printMacros($F, "extern const WebCore::QualifiedName", "Attr", \%allAttrs);

    }

    print F "#endif\n\n";

    if (keys %allTags) {

        print F "WebCore::QualifiedName** get$parameters{namespace}Tags(size_t* size);\n";

    }

    if (keys %allAttrs) {

        print F "WebCore::QualifiedName** get$parameters{namespace}Attrs(size_t* size);\n";

    }

    print F "\nvoid init();\n\n";

    print F "} }\n\n";

    print F "#endif\n\n";

    close F;

}

sub printNamesCppFile

{

    my $cppPath = shift;

    my $F;

    open F, ">$cppPath";

    printLicenseHeader($F);

    my $lowerNamespace = lc($parameters{namespacePrefix});

print F "#include \"config.h\"\n";

print F "#ifdef SKIP_STATIC_CONSTRUCTORS_ON_GCC\n";

print F "#define DOM_$parameters{namespace}NAMES_HIDE_GLOBALS 1\n";

print F "#else\n";

print F "#define QNAME_DEFAULT_CONSTRUCTOR 1\n";

print F "#endif\n\n";

print F "#include \"$parameters{namespace}Names.h\"\n\n";

print F "#include <wtf/StaticConstructors.h>\n";

print F "namespace WebCore {\n\n namespace $parameters{namespace}Names {

using namespace WebCore;

DEFINE_GLOBAL(AtomicString, ${lowerNamespace}NamespaceURI, \"$parameters{namespaceURI}\")

";