codegeneratorcom.pm

linux下开源浏览器WebKit的源码,市面上的很多商用浏览器都是移植自WebKit

    }

    if ($numAttributes > 0 || $numFunctions > 0) {
        push(@CPPHeaderContent, "    // ${interfaceName} ${DASHES}\n\n");
    }

    # - Add constants COMING SOON

    # - Add attribute getters/setters.
    if ($numAttributes > 0) {
        push(@CPPHeaderContent, "    // Attributes\n\n");
        foreach my $attribute (@{$dataNode->attributes}) {
            AddForwardDeclarationsForTypeInCPPHeader($attribute->signature->type);

            my %attributeSigs = GenerateCPPAttributeSignature($attribute, $className, { "NewLines" => 1,
                                                                                        "Indent" => 4,
                                                                                        "IncludeSemiColon" => 1,
                                                                                        "AddVirtualKeyword" => 1,
                                                                                        "UseClassName" => 0 });

            push(@CPPHeaderContent, values(%attributeSigs));
            push(@CPPHeaderContent, "\n");
        }
    }

    # - Add functions.
    if ($numFunctions > 0) {
        push(@CPPHeaderContent, "    // Functions\n\n");
        foreach my $function (@{$dataNode->functions}) {
            AddForwardDeclarationsForTypeInCPPHeader($function->signature->type);
            AddForwardDeclarationsForTypeInCPPHeader($_->type) foreach (@{$function->parameters});

            my $functionSig = GenerateCPPFunctionSignature($function, $className, { "NewLines" => 1,
                                                                                    "Indent" => 4,
                                                                                    "IncludeSemiColon" => 1,
                                                                                    "AddVirtualKeyword" => 1,
                                                                                    "UseClassName" => 0 });

            push(@CPPHeaderContent, $functionSig);
            push(@CPPHeaderContent, "\n");
        }
    }

    push(@CPPHeaderContent, "    ${implementationClass}* impl${implementationClassWithoutNamespace}() const;\n");

    if (@{$dataNode->parents} == 0) {
        AddIncludesForTypeInCPPHeader("wtf/RefPtr", 1);
        push(@CPPHeaderContent, "\n");
        push(@CPPHeaderContent, "    ${implementationClass}* impl() const { return m_impl.get(); }\n\n");
        push(@CPPHeaderContent, "private:\n");
        push(@CPPHeaderContent, "    RefPtr<${implementationClass}> m_impl;\n");
    }

    # -- End Class --
    push(@CPPHeaderContent, "};\n\n");

    # -- Default Interface Creator --
    push(@CPPHeaderContent, "${interfaceName}* to${interfaceName}(${implementationClass}*);\n\n");

    push(@CPPHeaderContent, "#endif // " . $className . "_h\n");
}


# -----------------------------------------------------------------------------
#    CPP Implementation
# -----------------------------------------------------------------------------

sub GenerateCPPImplementation
{
    my ($object, $dataNode) = @_;

    my $IDLType = $dataNode->name;
    my $implementationClass = IDLTypeToImplementationType($IDLType);
    my $implementationClassWithoutNamespace = StripNamespace($implementationClass);
    my $className = GetClassName($IDLType);
    my $interfaceName = GetInterfaceName($IDLType);

    my $parentClassName = GetParentClass($dataNode);
    my $isBaseClass = (@{$dataNode->parents} == 0);

    my $uuid = $dataNode->extendedAttributes->{"ImplementationUUID"} || die "All classes require an ImplementationUUID extended attribute.";

    my $numAttributes = @{$dataNode->attributes};
    my $numFunctions = @{$dataNode->functions};

    # - Add default header template
    @CPPImplementationHeader = @licenseTemplate;
    push(@CPPImplementationHeader, "\n");

    push(@CPPImplementationHeader, "#include \"config.h\"\n");
    push(@CPPImplementationHeader, "#include \"WebKitDLL.h\"\n");
    push(@CPPImplementationHeader, "#include " . ($className eq "GEN_DOMImplementation" ? "\"GEN_DOMDOMImplementation.h\"" : "\"${className}.h\"") . "\n");
    $CPPImplementationDontIncludes{"${className}.h"} = 1;
    $CPPImplementationWebCoreIncludes{"${implementationClassWithoutNamespace}.h"} = 1;

    # -- Constructor --
    push(@CPPImplementationContent, "${className}::${className}(${implementationClass}* impl)\n");
    if ($isBaseClass) {
        push(@CPPImplementationContent, "    : m_impl(impl)\n");
        push(@CPPImplementationContent, "{\n");
        push(@CPPImplementationContent, "    ASSERT_ARG(impl, impl);\n");
        push(@CPPImplementationContent, "}\n\n");
    } else {
        push(@CPPImplementationContent, "    : ${parentClassName}(impl)\n");
        push(@CPPImplementationContent, "{\n");
        push(@CPPImplementationContent, "}\n\n");
    }

    # -- Destructor --
    push(@CPPImplementationContent, "${className}::~${className}()\n");
    push(@CPPImplementationContent, "{\n");
    if ($isBaseClass) {
        $CPPImplementationIncludes{"DOMCreateInstance.h"} = 1;
        push(@CPPImplementationContent, "    removeDOMWrapper(impl());\n");
    }
    push(@CPPImplementationContent, "}\n\n");

    push(@CPPImplementationContent, "${implementationClass}* ${className}::impl${implementationClassWithoutNamespace}() const\n");
    push(@CPPImplementationContent, "{\n");
    push(@CPPImplementationContent, "    return static_cast<${implementationClass}*>(impl());\n");
    push(@CPPImplementationContent, "}\n\n");

    # Base classes must implement the createInstance method externally.
    if (@{$dataNode->parents} != 0) {
        push(@CPPImplementationContent, "${className}* ${className}::createInstance(${implementationClass}* impl)\n");
        push(@CPPImplementationContent, "{\n");
        push(@CPPImplementationContent, "    return static_cast<${className}*>(${parentClassName}::createInstance(impl));\n");
        push(@CPPImplementationContent, "}\n");
    }

    push(@CPPImplementationContent, "// IUnknown $DASHES\n\n");

    # -- QueryInterface --
    push(@CPPImplementationContent, "HRESULT STDMETHODCALLTYPE ${className}::QueryInterface(REFIID riid, void** ppvObject)\n");
    push(@CPPImplementationContent, "{\n");
    push(@CPPImplementationContent, "    *ppvObject = 0;\n");
    push(@CPPImplementationContent, "    if (IsEqualGUID(riid, IID_${interfaceName}))\n");
    push(@CPPImplementationContent, "        *ppvObject = reinterpret_cast<${interfaceName}*>(this);\n");
    push(@CPPImplementationContent, "    else if (IsEqualGUID(riid, __uuidof(${className})))\n");
    push(@CPPImplementationContent, "        *ppvObject = reinterpret_cast<${className}*>(this);\n");
    push(@CPPImplementationContent, "    else\n");
    push(@CPPImplementationContent, "        return ${parentClassName}::QueryInterface(riid, ppvObject);\n\n");
    push(@CPPImplementationContent, "    AddRef();\n");
    push(@CPPImplementationContent, "    return S_OK;\n");
    push(@CPPImplementationContent, "}\n\n");

    # - Additional interfaces to implement -
    foreach my $interfaceToImplement (@additionalInterfaceDefinitions) {
        my $IDLTypeOfInterfaceToImplement = $interfaceToImplement->name;
        my $nameOfInterfaceToImplement = GetInterfaceName($IDLTypeOfInterfaceToImplement);
        my $numAttributesInInterface = @{$interfaceToImplement->attributes};
        my $numFunctionsInInterface = @{$interfaceToImplement->functions};

        push(@CPPImplementationContent, "    // ${nameOfInterfaceToImplement} ${DASHES}\n\n");

        if ($numAttributesInInterface > 0) {
            push(@CPPImplementationContent, "// Attributes\n\n");
            foreach my $attribute (@{$interfaceToImplement->attributes}) {
                # FIXME: Do this in one step.
                # FIXME: Implement exception handling.

                AddIncludesForTypeInCPPImplementation($attribute->signature->type);

                my %attributes = GenerateCPPAttribute($attribute, $className, $implementationClass);
                push(@CPPImplementationContent, values(%attributes));
            }
        }

        # - Add functions.
        if ($numFunctionsInInterface > 0) {
            push(@CPPImplementationContent, "// Functions\n\n");

            foreach my $function (@{$interfaceToImplement->functions}) {
                my $functionImplementation = GenerateCPPFunction($function, $className, $implementationClass);
                push(@CPPImplementationContent, $functionImplementation);
            }
        }
    }

    push(@CPPImplementationContent, "// ${interfaceName} $DASHES\n\n");

    # - Add attribute getters/setters.
    if ($numAttributes > 0) {
        push(@CPPImplementationContent, "// Attributes\n\n");
        foreach my $attribute (@{$dataNode->attributes}) {
            # FIXME: do this in one step
            my $hasSetterException = @{$attribute->setterExceptions};
            my $hasGetterException = @{$attribute->getterExceptions};

            AddIncludesForTypeInCPPImplementation($attribute->signature->type);

            my %attributes = GenerateCPPAttribute($attribute, $className, $implementationClass);
            push(@CPPImplementationContent, values(%attributes));
        }
    }

    # - Add functions.
    if ($numFunctions > 0) {
        push(@CPPImplementationContent, "// Functions\n\n");

        foreach my $function (@{$dataNode->functions}) {
            my $functionImplementation = GenerateCPPFunction($function, $className, $implementationClass);
            push(@CPPImplementationContent, $functionImplementation);
        }
    }

    # - Default implementation for interface creator.
    # FIXME: add extended attribute to add custom implementation if necessary.
    push(@CPPImplementationContent, "${interfaceName}* to${interfaceName}(${implementationClass}* impl)\n");
    push(@CPPImplementationContent, "{\n");
    push(@CPPImplementationContent, "    return ${className}::createInstance(impl);\n");
    push(@CPPImplementationContent, "}\n");
}

sub WriteData
{
    my ($object, $name, $pureInterface) = @_;

    # -- IDL --
    my $IDLFileName = "$outputDir/I" . $TEMP_PREFIX . "DOM" . $name . ".idl";
    unlink($IDLFileName);

    # Write to output IDL.
    open(OUTPUTIDL, ">$IDLFileName") or die "Couldn't open file $IDLFileName";

    # Add header
    print OUTPUTIDL @IDLHeader;

    # Add forward declarations and imorts
    delete $IDLForwardDeclarations{keys(%IDLDontForwardDeclare)};
    delete $IDLImports{keys(%IDLDontImport)};

    print OUTPUTIDL map { "cpp_quote(\"interface $_;\")\n" } sort keys(%IDLForwardDeclarations);
    print OUTPUTIDL "\n";

    print OUTPUTIDL map { "interface $_;\n" } sort keys(%IDLForwardDeclarations);
    print OUTPUTIDL "\n";
    print OUTPUTIDL "#ifndef DO_NO_IMPORTS\n";
    print OUTPUTIDL map { ($_ eq "IGEN_DOMImplementation") ? "import \"IGEN_DOMDOMImplementation.idl\";\n" : "import \"$_.idl\";\n" } sort keys(%IDLImports);
    print OUTPUTIDL "#endif\n";
    print OUTPUTIDL "\n";

    # Add content
    print OUTPUTIDL @IDLContent;

    close(OUTPUTIDL);

    @IDLHeader = ();
    @IDLContent = ();

    if ($pureInterface) {
        my $CPPInterfaceHeaderFileName = "$outputDir/" . $TEMP_PREFIX . "DOM" . $name . ".h";
        unlink($CPPInterfaceHeaderFileName);

        open(OUTPUTCPPInterfaceHeader, ">$CPPInterfaceHeaderFileName") or die "Couldn't open file $CPPInterfaceHeaderFileName";

        print OUTPUTCPPInterfaceHeader @CPPInterfaceHeader;

        close(OUTPUTCPPInterfaceHeader);

        @CPPInterfaceHeader = ();
    } else {
        my $CPPHeaderFileName = "$outputDir/" . $TEMP_PREFIX . "DOM" . $name . ".h";
        unlink($CPPHeaderFileName);

        # -- CPP Header --
        open(OUTPUTCPPHeader, ">$CPPHeaderFileName") or die "Couldn't open file $CPPHeaderFileName";

        # Add header
        print OUTPUTCPPHeader @CPPHeaderHeader;

        # Add includes
        print OUTPUTCPPHeader map { ($_ eq "GEN_DOMImplementation.h") ? "#include \"GEN_DOMDOMImplementation.h\"\n" : "#include \"$_\"\n" } sort keys(%CPPHeaderIncludes);
        print OUTPUTCPPHeader map { "#include <$_>\n" } sort keys(%CPPHeaderIncludesAngle);

        foreach my $dontDeclare (keys(%CPPHeaderDontForwardDeclarations)) {
            delete $CPPHeaderForwardDeclarations{$dontDeclare} if ($CPPHeaderForwardDeclarations{$dontDeclare});
        }
        print OUTPUTCPPHeader "\n";
        print OUTPUTCPPHeader map { "interface $_;\n" } sort keys(%CPPHeaderForwardDeclarations);
        print OUTPUTCPPHeader "\n";

        # Add content
        print OUTPUTCPPHeader @CPPHeaderContent;

        close(OUTPUTCPPHeader);

        @CPPHeaderHeader = ();
        @CPPHeaderContent = ();


        # -- CPP Implementation --
        my $CPPImplementationFileName = "$outputDir/" . $TEMP_PREFIX . "DOM" . $name . ".cpp";
        unlink($CPPImplementationFileName);

        open(OUTPUTCPPImplementation, ">$CPPImplementationFileName") or die "Couldn't open file $CPPImplementationFileName";

        # Add header
        print OUTPUTCPPImplementation @CPPImplementationHeader;
        print OUTPUTCPPImplementation "\n";

        # Add includes
        foreach my $dontInclude (keys(%CPPImplementationDontIncludes)) {
            delete $CPPImplementationIncludes{$dontInclude} if ($CPPImplementationIncludes{$dontInclude});
        }
        print OUTPUTCPPImplementation map { ($_ eq "GEN_DOMImplementation.h") ? "#include \"GEN_DOMDOMImplementation.h\"\n" : "#include \"$_\"\n" } sort keys(%CPPImplementationIncludes);
        print OUTPUTCPPImplementation map { "#include <$_>\n" } sort keys(%CPPImplementationIncludesAngle);
        print OUTPUTCPPImplementation "\n";

        print OUTPUTCPPImplementation "#pragma warning(push, 0)\n";
        print OUTPUTCPPImplementation map { "#include <WebCore/$_>\n" } sort keys(%CPPImplementationWebCoreIncludes);
        print OUTPUTCPPImplementation "#pragma warning(pop)\n";

        # Add content
        print OUTPUTCPPImplementation @CPPImplementationContent;

        close(OUTPUTCPPImplementation);

        @CPPImplementationHeader = ();
        @CPPImplementationContent = ();
    }
}

1;