Subversion Repositories DevTools

Rev

Rev 247 | Rev 263 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed 

#! perl
########################################################################
# Copyright ( C ) 2004 ERG Limited, All rights reserved
#
# Module name   : jats.sh
# Module type   : Makefile system
# Compiler(s)   : n/a
# Environment(s): jats
#
# Description   : Provide varions functions used by the BuildVersion
#                 directive.
#
#                 Use only within buildlib.pl as this package assumes
#                 a great deal about its environment.
#
# Usage:
#
# Version   Who      Date        Description
#
#......................................................................#

require 5.006_001;
use strict;
use warnings;

our $Clobber;
our $CurrentYear;
our $CurrentTime;
our $Srcdir;
our $BuildVersion;
our $BUILDNAME;
our $BUILDNAME_PACKAGE;
our $BUILDNAME_VERSION;
our $BUILDNAME_PROJECT;

package BuildVersion;
use JatsError;
use JatsSystem;
use JatsVersionUtils;

our (@ISA, @EXPORT, @EXPORT_OK, %EXPORT_TAGS, $VERSION);
use Exporter;

$VERSION = 1.00;
@ISA = qw(Exporter);

# Symbols to autoexport (:DEFAULT tag)
@EXPORT = qw( BuildVersionC
              BuildVersionCdefs
              BuildVersionCSharp
              BuildVersionWinRC
              BuildVersionProperties
            );

#-------------------------------------------------------------------------------
# Function        : BuildVersionCSharp
#
# Description     : Generate a C# versionn information file to allow
#                   insertion of data into an assembly
#
# Inputs          : $FileName           - Output filename (Optional)
#
# Returns         :
#
sub BuildVersionCSharp
{
    my ( $fname ) = @_;
    $fname = 'AssemblyVersionInfo.cs' unless $fname;

    #
    #   Store the files location for use at runtime
    #   It will be a file that is 'known' to JATS
    #
    $fname = ::BuildAddKnownFile ( $Srcdir, $fname );
    return if ( $Clobber );      # clobber mode ?

    #
    #   Determine the build version
    #
    my ($major, $minor, $patch, $build, $raw_patch) = SplitVersion($BUILDNAME_VERSION);
    my $vstring = "$major.$minor.$patch.$build";


    my $fh = ConfigurationFile::New( $fname, '--Type=CSharp' );
    $fh->HeaderSimple( "buildlib (Version $BuildVersion)",
                       "CSharp Assembly Version Definition" );

    $fh->Write( "\n" );
    $fh->Write( "using System.Reflection;\n" );
    $fh->Write( "using System.Runtime.CompilerServices;\n" );
    $fh->Write( "\n" );
    $fh->Write( "[assembly: AssemblyCompany(\"ERG Group\")]\n" );
    $fh->Write( "[assembly: AssemblyProduct(\"$BUILDNAME_PACKAGE\")]\n" );
    $fh->Write( "[assembly: AssemblyCopyright(\"ERG Group $CurrentYear\")]\n" );
    $fh->Write( "[assembly: AssemblyTrademark(\"\")]\n" );
    $fh->Write( "\n");
    $fh->Comment( "\n");
    $fh->Comment( "Version information for an assembly consists of the following four values:\n");
    $fh->Comment( "\n");
    $fh->Comment( "     Major Version   -ERG:Major\n");
    $fh->Comment( "     Minor Version  - ERG:Minor\n");
    $fh->Comment( "     Build Number   - ERG:Patch\n");
    $fh->Comment( "     Revision       - ERG:Build Number\n");
    $fh->Comment( "\n");
    $fh->Write( "\n");
    $fh->Write( "[assembly: AssemblyVersion(\"$vstring\")]\n" );
    $fh->Write( "\n");

    $fh->Close();
}

#-------------------------------------------------------------------------------
# Function        : BuildVersionWinRC
#
# Description     : Create a Windows RC file to describe the build version
#                   This file may be used directly
#
# Inputs          : $FileName           - Output filename (Optional)
#                   $icon               - Name of icon (optional )
#
# Returns         :
#
sub BuildVersionWinRC
{
    my ( $fname, $icon ) = @_;
    $fname = 'version.rc' unless $fname;

    #
    #   Store the files location for use at runtime
    #   It will be a file that is 'known' to JATS
    #
    $fname = ::BuildAddKnownFile ( $Srcdir, $fname );
    return if ( $Clobber );      # clobber mode ?
    
    Message ("Creating Windows Resource File: $fname" );
    #
    #   Determine the build version
    #
    my ($major, $minor, $patch, $build, $raw_patch) = SplitVersion($BUILDNAME_VERSION);
    my $product_version = "$major, $minor, $patch, $build";
    

    #
    #   Create the file
    #
    my $fh = ConfigurationFile::New( $fname, '--Type=C++' );
    $fh->HeaderSimple( "buildlib (Version $BuildVersion)",
                       "Windows Resource Version Definition" );

    sub prc
    {
        return "@_\n";
    }

    sub pdefs
    {
        my ($arg, $val) = @_;
        return "#define $arg \"$val\\0\"\n";
    }

    sub pdef
    {
        my ($arg, $val) = @_;
        return "#define $arg $val\n";
    }

    $fh->Write(prc     (""));
#    $fh->Write(prc     ("#include \"afxres.h\""));
#    $fh->Write(prc     (""));
    $fh->Write(prc     (""));
    $fh->Write(pdefs   ("RC_STR_EMPTY"         , "" ));
    $fh->Write(pdefs   ("RC_STR_COMPANY"       , "ERG Group" ));
    $fh->Write(pdefs   ("RC_STR_PRODUCTNAME"   , "ERG Group test" ));
    $fh->Write(pdefs   ("RC_STR_COMMENT"       , "Build Date: $CurrentTime" ));
    $fh->Write(pdefs   ("RC_STR_DESCRIPTION"   , "From: $BUILDNAME_PACKAGE" ));
    $fh->Write(pdefs   ("RC_STR_NAME"          , $BUILDNAME_PACKAGE ));
    $fh->Write(pdefs   ("RC_STR_VERSION"       , $product_version ));
    $fh->Write(pdef    ("RC_NUM_VERSION"       , $product_version ));
    $fh->Write(pdefs   ("RC_STR_COPYRIGHT"     , "Copyright ERG Group $CurrentYear" ));
    $fh->Write(prc     ('#ifdef _DEBUG'));
    $fh->Write(pdefs   ("RC_STR_SPECIAL"       , "Debug Version" ));
    $fh->Write(prc     ('#else'));
    $fh->Write(pdefs   ("RC_STR_SPECIAL"       , "Production Version" ));
    $fh->Write(prc     ('#endif'));
    $fh->Write(prc     (""));

    $fh->Write(prc     (''));
    $fh->Write(prc     ('VS_VERSION_INFO VERSIONINFO'));
    $fh->Write(prc     (' FILEVERSION      RC_NUM_VERSION'));
    $fh->Write(prc     (' PRODUCTVERSION   RC_NUM_VERSION'));
    $fh->Write(prc     (' FILEFLAGSMASK 0x3fL'));
    $fh->Write(prc     ('#ifdef _DEBUG'));
    $fh->Write(prc     (' FILEFLAGS 0x1L'));
    $fh->Write(prc     ('#else'));
    $fh->Write(prc     (' FILEFLAGS 0x0L'));
    $fh->Write(prc     ('#endif'));
    $fh->Write(prc     (' FILEOS 0x40004L'));
    $fh->Write(prc     (' FILETYPE 0x1L'));
    $fh->Write(prc     (' FILESUBTYPE 0x0L'));
    $fh->Write(prc     ('BEGIN'));
    $fh->Write(prc     ('    BLOCK "StringFileInfo"'));
    $fh->Write(prc     ('    BEGIN'));
    $fh->Write(prc     ('        BLOCK "0c0904b0"'));
    $fh->Write(prc     ('        BEGIN'));
    $fh->Write(prc     ('            VALUE "Comments",         RC_STR_COMMENT'));
    $fh->Write(prc     ('            VALUE "CompanyName",      RC_STR_COMPANY'));
    $fh->Write(prc     ('            VALUE "FileDescription",  RC_STR_DESCRIPTION'));
    $fh->Write(prc     ('            VALUE "FileVersion",      RC_STR_VERSION'));
    $fh->Write(prc     ('            VALUE "InternalName",     RC_STR_NAME'));
    $fh->Write(prc     ('            VALUE "LegalCopyright",   RC_STR_COPYRIGHT'));
    $fh->Write(prc     ('            VALUE "LegalTrademarks",  RC_STR_EMPTY'));
    $fh->Write(prc     ('            VALUE "OriginalFilename", RC_STR_NAME'));
    $fh->Write(prc     ('            VALUE "PrivateBuild",     RC_STR_EMPTY'));
    $fh->Write(prc     ('            VALUE "ProductName",      RC_STR_PRODUCTNAME'));
    $fh->Write(prc     ('            VALUE "ProductVersion",   RC_STR_VERSION'));
    $fh->Write(prc     ('            VALUE "SpecialBuild",     RC_STR_SPECIAL'));
    $fh->Write(prc     ('        END'));
    $fh->Write(prc     ('    END'));
    $fh->Write(prc     ('        BLOCK "VarFileInfo"'));
    $fh->Write(prc     ('        BEGIN'));
    $fh->Write(prc     ('            VALUE "Translation", 0xc09, 1200'));
    $fh->Write(prc     ('        END'));
    $fh->Write(prc     ('END'));
    $fh->Write(prc     (''));

    if ( $icon )
    {
    $fh->Write(prc     (''));
    $fh->Write(prc     ('/////////////////////////////////////////////////////////////////////////////'));
    $fh->Write(prc     ('//'));
    $fh->Write(prc     ('// Icon'));
    $fh->Write(prc     ('//'));
    $fh->Write(prc     ('// Icon with lowest ID value placed first to ensure application icon'));
    $fh->Write(prc     ('// remains consistent on all systems.'));
    $fh->Write(prc     ("101       ICON    DISCARDABLE     \"$icon\""));
    $fh->Write(prc     (''));
    }
    

    $fh->Close();
}

#-------------------------------------------------------------------------------
# Function        : BuildVersionC
#
# Description     : Create a "C" style version.c and version.h file
#
# Inputs          : $Prefix         - Text to prefix generated variables with
#                                     Used to avoid namespace conflicts
#                   $Type           - Type of version to create
#                                     Only allowed value is 'array'
#
# Returns         :
#

sub BuildVersionC
{
    my( $Prefix, $Type ) = @_;
    my $ver;

    if ( $Clobber )                             # clobber mode ?
    {
        #
        #   Clobber common version.c and version.h
        #
        System( "$::GBE_BIN/rm -f $Srcdir/version.c $Srcdir/version.h" );
        return;
    }

    #
    #   Default prefix is none
    #   Set to a defined, bet empty, string
    #
    $Prefix = "" if ( ! defined( $Prefix ) );
    $Type   = "" if ( ! defined( $Type ) );

    #   src/version.c
    #..
    open( VERSIONC, ">$Srcdir/version.c" ) ||
        Error( "cannot create $Srcdir/version.c" );

    print VERSIONC
        "/* Please do not edit this file.\n" .
        " * It was auto-generated by Buildlib ($BuildVersion) on $::CurrentTime\n" .
        " */\n" .
        "#include \"version.h\"\n";

    print VERSIONC
        "\n" .
        "static char what[] = \"@(#) $BUILDNAME $::CurrentDate ERG\";\n" .
        "\n";


    my @PACKAGEVERS = PackageEntry::GetPackageVersionList();
    if ( $Type eq "array" )
    {                                           # new style
        print VERSIONC
           "static const char *pkgarray[] = \n" .
           "{\n";

        foreach $ver ( @PACKAGEVERS   ) {
            print VERSIONC "    \"$ver\",\n";
        }

        print VERSIONC
           "    0\n",
           "};\n\n";

        print VERSIONC
           "\nconst char *\n$Prefix"."VersionString(void)\n" .
           "{\n".
           "    return \"$BUILDNAME\";\n" .
           "}\n" .
           "\nconst char **\n$Prefix"."PkgStrings(void)\n" .
           "{\n".
           "    return pkgarray;\n" .
           "}\n" .
           "\nconst char *\n$Prefix"."GetModuleInfo(void)\n" .
           "{\n" .
           "    return \"$BUILDNAME_PACKAGE ($BUILDNAME_VERSION.$BUILDNAME_PROJECT) @PACKAGEVERS\";\n" .
           "}\n";
    }
    else
    {                                           # old style
        print VERSIONC
           "\nconst char *\n$Prefix"."VersionString(void)\n" .
           "{\n".
           "    return \"$BUILDNAME @PACKAGEVERS\";\n" .
           "}\n" .
           "\nconst char *\n$Prefix"."GetModuleInfo(void)\n" .
           "{\n" .
           "    return \"$BUILDNAME_PACKAGE ($BUILDNAME_VERSION.$BUILDNAME_PROJECT) @PACKAGEVERS\";\n" .
           "}\n";
    }
    close VERSIONC;

#   src/version.h
#..
    open( VERSIONH, ">$Srcdir/version.h" ) ||
        Error( "cannot create $Srcdir/version.h" );

    print VERSIONH
        "#ifndef VERSION_H_INCLUDED\n" .
        "#define VERSION_H_INCLUDED\n" .
        "/* Please do not edit this file.\n" .
        " * It was auto-generated by Buildlib ($BuildVersion) on $::CurrentTime\n" .
        " */\n\n" .
        "#define BUILDNAME     \"$BUILDNAME\"\n" .
        "#define BUILDDATE     \"$::CurrentTime\"\n" .
        "\n";

    print VERSIONH
        "#ifdef __cplusplus\n" .
        "    extern \"C\" {           /* force C calling convention when using C++ */\n" .
        "#endif\n" .
        "\n";

    if ( $Type eq "array" )
    {                                           # extended interface
        print VERSIONH
        "extern const char **  $Prefix"."PkgStrings(void);\n";
    }
    print VERSIONH
        "extern const char *   $Prefix"."VersionString(void);\n".
        "extern const char *   $Prefix"."GetModuleInfo(void);\n";

    print VERSIONH
        "\n" .
        "#ifdef __cplusplus\n" .
        "    } /* extern \"C\" */\n" .
        "#endif\n" .
        "\n";

    print VERSIONH
        "\n#endif /*VERSION_H_INCLUDED*/\n";
    close VERSIONH;
}

#-------------------------------------------------------------------------------
# Function        : BuildVersionCdefs
#
# Description     : Generate a "C" style version definitions file
#                   This file simply contains definitions
#
# Inputs          : $Mode           - File suffix
#                   $ModePrefix     - Tag for all generated definitions
#
# Returns         :
#

sub BuildVersionCdefs
{
    my ( $Mode, $ModePrefix ) = @_;
    my $fname = "version_$Mode.h";

    if ( $Clobber )                             # clobber mode ?
    {
        System( "$::GBE_BIN/rm -f $Srcdir/$fname" );
        return;
    }

    #
    #   Generate version_defs.h
    #   This file contains ONLY definitions. It may be used by assembler
    #   programs (that support a preprocessor) to access version information
    #
    #   Allow for a user supplied filename fragment that will be used within
    #   all the definitions with in the file.
    #
    my ($major, $minor, $patch, $build, $raw_patch) = SplitVersion($BUILDNAME_VERSION);
    my @PACKAGEVERS = PackageEntry::GetPackageVersionList();

    #
    #   Base names on a user supplied value or a default
    #
    my $vtag = uc( "VERSION$ModePrefix" );
    my $guard_name = uc($fname);
       $guard_name =~ s~\.~_~g;

    open( VERSIOND, ">$Srcdir/$fname" ) ||
        Error( "cannot create $Srcdir/$fname" );

    print VERSIOND
        "#ifndef $guard_name\n" .
        "#define $guard_name\n" .
        "/* Please do not edit this file.\n" .
        " * It was auto-generated by Buildlib ($BuildVersion) on $::CurrentTime\n" .
        " */\n\n" .
        "\n".
        "#define ${vtag}_BUILDNAME      \"$BUILDNAME\"\n".
        "#define ${vtag}_BUILDDATE      \"$::CurrentTime\"\n".
        "\n".
        "#define ${vtag}_PACKAGE        \"$BUILDNAME_PACKAGE\"\n".
        "#define ${vtag}_VERSION        \"$BUILDNAME_VERSION\"\n".
        "#define ${vtag}_MAJOR_STR      \"$major\"\n".
        "#define ${vtag}_MINOR_STR      \"$minor\"\n".
        "#define ${vtag}_PATCH_STR      \"$patch\"\n".
        "#define ${vtag}_BUILD_STR      \"$build\"\n".
        "#define ${vtag}_PATCHBUILD_STR \"$raw_patch\"\n".
        "#define ${vtag}_PROJECT        \"$BUILDNAME_PROJECT\"\n".
        "#define ${vtag}_MAJOR          " . strip_zeros($major) . "\n".
        "#define ${vtag}_MINOR          " . strip_zeros($minor) . "\n".
        "#define ${vtag}_PATCH          " . strip_zeros($patch) . "\n".
        "#define ${vtag}_BUILD          " . strip_zeros($build) . "\n".
        "#define ${vtag}_PATCHBUILD     " . strip_zeros($raw_patch) . "\n".
        "#define ${vtag}_ALL            \"$BUILDNAME_PACKAGE ($BUILDNAME_VERSION.$BUILDNAME_PROJECT) @PACKAGEVERS\"\n".
        "#define ${vtag}_BUILDTIME      " . strip_zeros(time()) . "\n".
        "\n".
        "#endif /* $guard_name */\n";

    close VERSIOND;
}

#-------------------------------------------------------------------------------
# Function        : BuildVersionProperties
#
# Description     : Generate a "Java" style version definitions file
#                   This is a simple properties file
#
# Inputs          : $FileName       - Output filename (Optional)
#                   $Prefix         - Tag for all generated definitions
#
# Returns         :
#
sub BuildVersionProperties
{
    my ( $fname, $Prefix ) = @_;

    #
    #   Default name of the file
    #
    $fname = 'version.properties' unless $fname;

    #
    #   Store the files location for use at runtime
    #   It will be a file that is 'known' to JATS
    #
    $fname = ::BuildAddKnownFile ( $Srcdir, $fname );
    return if ( $Clobber );      # clobber mode ?

    #
    #   Generate version properties file
    #
    #   This file contains ONLY definitions. It may be included by the ANT
    #   builds. Its not intended to be imported by the java code


    #
    #   Allow for a user supplied property prefix
    #   Not really needed as
    #
    my $vtag = '';
    $vtag = $Prefix . '.' if $Prefix;


    my ($major, $minor, $patch, $build, $raw_patch) = SplitVersion($BUILDNAME_VERSION);
    my @PACKAGEVERS = PackageEntry::GetPackageVersionList();

    #
    #   Create properties in the same form as for "C" definitions
    #   Note:
    #       The 'ALL' is in a format used by other software. Do not change
    #
    open( VERSIOND, ">$fname" ) ||
        Error( "cannot create $fname" );

    print VERSIOND
        "# Please do not edit this file.\n" .
        "# It was auto-generated by Buildlib ($BuildVersion) on $::CurrentTime\n" .
        "#\n" .
        "${vtag}BUILDNAME      = $BUILDNAME\n".
        "${vtag}BUILDDATE      = $::CurrentTime\n".
        "\n".
        "${vtag}PACKAGE        = $BUILDNAME_PACKAGE\n".
        "${vtag}VERSION        = $BUILDNAME_VERSION\n".
        "${vtag}MAJOR_STR      = $major\n".
        "${vtag}MINOR_STR      = $minor\n".
        "${vtag}PATCH_STR      = $patch\n".
        "${vtag}BUILD_STR      = $build\n".
        "${vtag}PATCHBUILD_STR = $raw_patch\n".
        "${vtag}PROJECT        = $BUILDNAME_PROJECT\n".
        "${vtag}MAJOR          = " . strip_zeros($major) . "\n".
        "${vtag}MINOR          = " . strip_zeros($minor) . "\n".
        "${vtag}PATCH          = " . strip_zeros($patch) . "\n".
        "${vtag}BUILD          = " . strip_zeros($build) . "\n".
        "${vtag}PATCHBUILD     = " . strip_zeros($raw_patch) . "\n".
        "${vtag}ALL            = $BUILDNAME_PACKAGE ($BUILDNAME_VERSION.$BUILDNAME_PROJECT) @PACKAGEVERS\n".
        "${vtag}BUILDTIME      = " . strip_zeros(time()) . "\n".
        "\n";
    #
    #   Create a set of definitions for each dependent package
    #
    print VERSIOND "# Dependent Packages and Versions\n".
                   "#\n";
    
    foreach my $tag ( PackageEntry::GetPackageList() )
    {
        my ($name, $version, $type) = PackageEntry::GetPackageData($tag);
#        push @attributes, "build=\"true\"" if $type =~ /Build/i;
        print VERSIOND "${vtag}PACKAGE.$name=$version\n";
    }
    close VERSIOND;
}

#-------------------------------------------------------------------------------
# Function        : stip_zeros
#
# Description     : Remove leading 0's from a string
#
# Inputs          : A string
#
# Returns         : A string without leading zeros
#
sub strip_zeros
{
    my ($text) = @_;

    $text =~ s~^0*~~;
    $text = '0' unless ( $text );
    return $text;
}
 
1;