Subversion Repositories DevTools

#

# Module name   : DELPHI7

# Module type   : Makefile system

# Compiler(s)   : Delphi Pascal

# Environment(s): WIN32

#

# Description:

#       Delphi7 for WIN32

#............................................................................#

use strict;

use warnings;

use FileUtils;

################################################################################

#   Globals

#

my $toolset_version;

my $implib_found;

##############################################################################

#   ToolsetInit()

#       Runtime initialisation

#

##############################################################################

ToolsetInit();

sub ToolsetInit

{

#.. Parse arguments (Toolset arguments)

#

    Debug( "Delphi7(@::ScmToolsetArgs)" );

    foreach $_ ( @::ScmToolsetArgs ) {

        if (/^--Version=(.*)/) {                # MS SDK Version

            $toolset_version = $1;

        } else {

            Message( "Delphi7 toolset: unknown option $_ -- ignored\n" );

        }

    }

#.. Parse arguments (platform arguments)

#

    Debug( "Delphi7(@::ScmPlatformArgs)" );

    foreach $_ ( @::ScmPlatformArgs ) {

        if (/^--product=(.*)/) {                # GBE product

        } elsif (/^--Version=(.*)/) {           # MS SDK Version

            $toolset_version = $1;

        } else {

            Message( "Delphi7 toolset: unknown platform argument $_ -- ignored\n" );

        }

    }

#.. Validate SDK version

#   Currently only one is supported

#       1) Delphi7 installed

#

    Error( "Unknown version: $toolset_version" ) if ( defined $toolset_version );

#.. Standard.rul requirements

#

    $::s = 'asm';

    $::o = '';

    $::a = 'dcu';

    $::so = 'dll';

    $::exe = '.exe';

#.. Toolset configuration

#

    $::ScmToolsetVersion = "1.0.0";             # our version

    $::ScmToolsetGenerate = 0;                  # generate optional

    $::ScmToolsetProgDependancies = 0;          # handle Prog dependancies myself

    $::ScmToolsetSingleType = 1;                # Cannot support debug and production builds

#.. define Delphi7 environment

    Init( "delphi7" );

    ToolsetDefines( "delphi7.def" );

    ToolsetRequire( "exctags" );                # and Exuberant Ctags

    ToolsetRules( "delphi7.rul" );

    ToolsetRules( "standard.rul" );

    #.. Extend the CompilerOption directive

    #   Create a standard data structure

    #   This is a hash of hashes

    #       The first hash is keyed by CompileOption keyword

    #       The second hash contains pairs of values to set or remove

    #

    %::ScmToolsetCompilerOptions =

    (

        #

        #   Control the thread model to use

        #   This will affect the compiler options and the linker options

        #

        'subsystem:windows'  => { 'LDSUBSYSTEM' , '-CG' },

        'subsystem:console'  => { 'LDSUBSYSTEM' , '-CC' },

    );

    #

    #   Set default options

    #

    $::ScmCompilerOpts{'LDSUBSYSTEM'} = '-CG';

#.. Cleanup rules

#   None at the moment as we only build projects

#

    return 1;

}

#-------------------------------------------------------------------------------

# Function        : ToolsetGenLibName

#

# Description     : Function to generate the names of static libraries

#                   Will be used if it exists

#

# Inputs          : $name                   - Base Name of the library

#

# Returns         : Path to generated name

#

sub ToolsetGenLibName

{

    my ($name) = @_;

    return "$name.$::a";

}

#-------------------------------------------------------------------------------

# Function        : ToolsetPreprocess

#

# Description     : Called once all the user directives have been parsed

#                   In this toolset it is used as a hook to allow

#                   the creation of a 'simple' target to perform some

#                   level of dependency testing

#

#                   Basically. Create a target that consists on ALL the

#                   source files. This is then used as a prerequisite

#                   for all Libs, SharedLibs and Progs

#

#                   It is crude and ugly - but it does the job

#                   Would be better to parse the Delphi project files

#                   and determine the prerequisites ourselves, but ...

#

# Inputs          : None

#

# Returns         : Nothing directly

#

sub ToolsetPreprocess

{

    my @dlist;

    foreach ( values %::SRCS )

    {

        #

        #   Strip out known project files

        #   Must leave in .pas files

        #

        next if ( m~\.dpr$~i );

        next if ( m~\.dpk$~i );

        next if ( m~^descpkg$~ );

        push @dlist, $_;

    }

    if ( @dlist )

    {

        #

        #   Would like to use nice function that create nice text, but

        #   at the moment the makefile is not yet being written

        #

        #   Trick: Create an in-memory filehandle and use it

        #          The MAKEFILE handle is used by nice writers

        #

        my $data;

        local (*MAKEFILE);

        open(MAKEFILE, '>>', \$data) || Error ("Cannot open in-memory file");

        MakeHeader  ( "All Delphi Sources");

        MakeDefEntry( "DELPHISRCS", "=",  \@dlist );

        close MAKEFILE;

        #

        #   Add the generated data as a 'define'

        #   This will be placed early in the makefile so that it can be used

        #   by the rules that need it.

        #

        ToolsetDefine ($data);

    }

}

#-------------------------------------------------------------------------------

# Function        : ToolsetPostprocess

#

# Description     : Process any .RC files that have been specified

#                   by the user

#

# Inputs          : 

#

# Returns         : 

#

sub ToolsetPostprocess

{

    foreach my $rcfile ( @::RCSRCS )

    {

        my $name = StripDirExt($rcfile);

        my $base = StripDir($rcfile);

        my $res_name = '$(OBJDIR)/' . $name . '.res';

        #

        #   Create rules and recipes to build file

        #

        my $me = MakeEntry::New (*MAKEFILE, $res_name );

        $me->AddComment ("Create Resource File: $name" );

        $me->AddDependancy ( $rcfile );

        $me->AddDependancy ( '$(SCM_MAKEFILE)' );

        $me->AddDependancy ( '$(GBE_OBJDIR)' );

        $me->AddDependancy ( split( /$;/, $::SRC_DEPEND{$base} ) ) if exists($::SRC_DEPEND{$base});

        $me->AddRecipe ( '$(DRES)' );

        $me->Print();

        #

        #   Add the file to the list of generated files

        #   This will ensure that its created early

        #

        GenerateSrcFile( 1, $res_name );

    }

}

#-------------------------------------------------------------------------------

# Function        : ToolsetAR

#

# Description     : Toolset processing to create a static library

#                   In Delphi these are called a unit

#                   In Delphi there are several restrictions

#                       * Name of the library and the name of the source are

#                         fixed - the user cannot provide a source name

#

#                       * A library can contain only one element

#

#

# Inputs          : $name   - Base name of the library

#                   $pArgs  - Ref to an array of arguments

#                   $pObjs  - Ref to an array of objects

#                   $pLib   - Ref to complete library entry

#

# Returns         : 

#

sub ToolsetAR

{

    my( $name, $pArgs, $pObjs, $pLib ) = @_;

    #.. Parse arguments

    #

    foreach $_ ( @$pArgs )

    {

        Message( "AR: unknown option $_ -- ignored" );

    }

    #

    #   Ensure that the user has not provided a source

    #   The name of the source will be calculated from the target

    #

    Error( "Delphi7 toolset: User source file names not supported")

        if ( scalar @$pObjs );

    #

    #   Source the required source file

    #   It must exist

    #

    my $sfile = MakeSrcResolve ( "$name.pas" );

    Error ("AR: Required source file not found: $sfile")

        unless ( -f $sfile );

    my $lib_name = $pLib->getPath();

    #

    #   Rule to create the target

    #

    my $me = MakeEntry::New (*MAKEFILE, $lib_name );

    $me->AddComment ("Build Unit: $name as a DCU" );

    $me->AddDependancy ( $sfile );

    $me->AddDependancy ( '$(SCM_MAKEFILE)' );

    $me->AddDependancy ( '$(DELPHISRCS)' );

    $me->AddRecipe ( '$(DCC_AR)' );

    $me->AddDefn ('PSOURCE', $sfile );

    $me->Print();

}

###############################################################################

#   ToolsetSHLD( $name, \@args, \@objs, \@libraries, $ver )

#       This subroutine takes the user options and builds the rules

#       required to link the shared library 'name'.

#

#   Arguments:

#       $name       - Name of the target program

#       $pArgs      - Ref to an array of argumennts

#       $pObjs      - Ref to an array of object files

#       $pLibs      - Ref to an array of libraries

#       $ver        - Version String

#

#   Output:

#       Makefile recipes to create the Program

#

#   Notes:

#       This Program Builder will handle its own dependancies

#       It will also create rules and recipes to construct various

#       parts directly from source

#

#       In Delphi there are several restrictions

#           * Name of the program and the name of the source are

#             linked. The user can provide only one file

#

#   Options:

#       --NoImplib                      # Supress creation of Import Library

#       --Package                       # Force Package Mode

#       Source File                     # Dependency usage only

#

#

###############################################################################

sub ToolsetSHLD

{

    my ( $name, $pArgs, $pObjs, $pLibs, $ver ) = @_;

    my @psource;

    my $no_implib = 0;

    my $auto_type = '';

    #.. Parse arguments

    #

    foreach ( @$pArgs ) {

        if (/^--NoImplib$/) {

            $no_implib = 1;

        } elsif ( /^--DCU/i ) {

            $auto_type = 'dcu';

        } elsif ( /^--Package/i ) {

            $auto_type = 'pkg';

        } elsif ( /^--NoPackage/i || /^--DLL/i ) {

            $auto_type = 'dll';

        } elsif ( !/^-/ ) {

            push @psource, MakeSrcResolve($_);

        } else {

            Message( "Delphi7 LD: unknown option $_ -- ignored\n" );

        }

    }

    #

    #   Objs are not supported in this toolset

    #

    Error( "Delphi7 toolset: User source file names not supported")

        if ( scalar @$pObjs );

    #

    #   Determine the source project name

    #   Will have the same name as the EXE, but the suffix may be

    #   .dpr or .pas

    #

    my $source;

    $::ScmQuiet = 3;                                # Can be done better !

    foreach my $suffix ( '.dpk', '.dpr', '.pas' )

    {

        $source = MakeSrcResolve ( "$name$suffix" );

        last if ( -f $source );

        $source = undef;

    }

    $::ScmQuiet = 0;

    Error ("Shared Library source not found",

           "It must have the same name as the library: $name")

            unless ( $source  );

    #

    #   Determine the type of SharedLib being created

    #       Library that creates DLLs

    #       Library that creates a Delphi Package

    #

    #   User can force the mode

    #

    unless ( $auto_type )

    {

        $auto_type = 'pkg' if ($source =~ m~\.dpk~);

        $auto_type = 'dcu' if ($source =~ m~\.pas~);

    }

    if ( $auto_type eq 'pkg' )

    {

        #

        #   Determine the target output name

        #

        my $base = $name;

        my $root = "\$(LIBDIR)/$base";

        my $bpl = $root . '.bpl';

        my $bcp = $root . '.dcp';

        #

        #   Create Rules and Recipes to create the Package

        #

        my $me = MakeEntry::New (*MAKEFILE, $bpl );

        $me->AddComment ("Build Delpi Package: $name" );

        $me->AddName ( $bcp );

        $me->AddDependancy ( $source );

        $me->AddDependancy ( '$(SCM_MAKEFILE)' );

        $me->AddDependancy ( '$(DELPHISRCS)' );

        $me->AddDependancy ( @psource );

        $me->AddRecipe ( '$(SHDCC)' );

        $me->AddDefn ('SHLIBBASE', $base );

        $me->AddDefn ('PSOURCE', $source );

        $me->AddDefn ('PFLAGS',  '' );

        $me->AddDefn ('PACKAGES',  join ' ', @$pLibs );

        $me->Print();

        #

        #   Files to clean up

        #

        ToolsetGenerate( "$root.map" );

        ToolsetGenerate( "$base.drc" );                 # Created in CWD

        #

        #   Specify the files to be packaged as part of the shared library

        #

        PackageShlibAddFiles ( $name, $bpl );

        PackageShlibAddFiles ( $name, $bcp );

        PackageShlibAddFiles ( $name, "$root.map", "Class=map" );

    }

    elsif ( $auto_type eq 'dcu' )

    {

        #

        #   Really building a DCU

        #   Done as a shared lib so that it can access other packages

        #   with the -L option

        #

        my $base = $name;

        my $root = "\$(LIBDIR)/$base";

        my $dcu = $root . '.dcu';

        #

        #   Create Rules and Recipes to create the Package

        #

        my $me = MakeEntry::New (*MAKEFILE, $dcu );

        $me->AddComment ("Build Delpi Package: $name" );

        $me->AddDependancy ( $source );

        $me->AddDependancy ( '$(SCM_MAKEFILE)' );

        $me->AddDependancy ( '$(DELPHISRCS)' );

        $me->AddDependancy ( @psource );

        $me->AddRecipe ( '$(DCC_AR)' );

        $me->AddDefn ('PSOURCE', $source );

        $me->AddDefn ('PFLAGS',  '' );

        $me->AddDefn ('PACKAGES',  join ' ', @$pLibs );

        $me->Print();

        #

        #   Files to clean up

        #

        ToolsetGenerate( "$base.drc" );                 # Created in CWD

        #

        #   Specify the files to be packaged as part of the shared library

        #

        PackageShlibAddFiles ( $name, $dcu );

    }

    else

    {

        #

        #   Determine the target output name

        #

        my $base = $name;

        my $root = "\$(LIBDIR)/$base";

        my $full = $root . '.' . $::so;

        my $stub = $root . '.lib';

        #

        #   Create Rules and Recipes to create the Shared Library

        #

        my $me = MakeEntry::New (*MAKEFILE, $full );

        $me->AddComment ("Build Shared Library: $name" );

        $me->AddDependancy ( $source );

        $me->AddDependancy ( '$(SCM_MAKEFILE)' );

        $me->AddDependancy ( '$(DELPHISRCS)' );

        $me->AddDependancy ( @psource );

        $me->AddRecipe ( '$(SHDCC)' );

        $me->AddDefn ('SHLIBBASE', $base );

        $me->AddDefn ('PSOURCE', $source );

        $me->AddDefn ('PFLAGS',  '' );

        $me->AddDefn ('PACKAGES',  join ' ', @$pLibs );

        $me->Print();

        #

        #   Files to clean up

        #

        ToolsetGenerate( "$root.map" );

        ToolsetGenerate( "$base.drc" );                 # Created in CWD

        #

        #   Specify the files to be packaged as part of the shared library

        #

        PackageShlibAddFiles ( $name, $full );

        PackageShlibAddFiles ( $name, "$root.map", "Class=map" );

        #

        #   Shared libaries are really need an import library

        #   Create an import library

        #

        unless ( $no_implib )

        {

            #

            #   Need:

            #       impdef.exe from Borland Cbuilder builder

            #       link.exe from MS VC6

            #

            my $me = MakeEntry::New (*MAKEFILE, $stub );

            $me->AddComment ("Build Import Library: $name" );

            $me->AddDependancy ( $full );

            $me->AddRecipe ( '$(IMPLIB)' );

            $me->AddDefn ('TMPFILE', "$root.tmp" );

            $me->Print();

            ToolsetGenerate( "$root.tmp" );

            ToolsetGenerate( "$root.exp" );

            PackageShlibAddFiles ( $name, $stub );

        }

    }

}

###############################################################################

#   ToolsetLD( $name, \@args, \@objs, \@libraries )

#       This subroutine takes the user options and builds the rules

#       required to link the program 'name'.

#

#   Arguments:

#       $name       - Name of the target program

#       $pArgs      - Ref to an array of argumennts

#       $pObjs      - Ref to an array of object files

#       $pLibs      - Ref to an array of libraries

#

#   Output:

#       Makefile recipes to create the Program

#

#   Notes:

#       This Program Builder will handle its own dependancies

#       It will also create rules and recipes to construct various

#       parts directly from source

#

#       In Delphi there are several restrictions

#           * Name of the program and the name of the source are

#             linked. The user can provide only one file

#

#   Options:

#       --Console                       # Console app

#       --Windows                       # Windows app (default)

#       Source File                     # Dependency usage only

#

#

###############################################################################

sub ToolsetLD

{

    my ( $name, $pArgs, $pObjs, $pLibs ) = @_;

    my @psource;

    my $link_target = $::ScmCompilerOpts{'LDSUBSYSTEM'};

    #.. Parse arguments

    #

    foreach ( @$pArgs ) {

        if (/^--Windows/) {

            $link_target = '-CC';

        } elsif (/^--Console/) {

            $link_target = '-CG';

        } elsif ( !/^-/ ) {

            push @psource, MakeSrcResolve($_);

        } else {

            Message( "Delphi7 LD: unknown option $_ -- ignored\n" );

        }

    }

    #

    #   Objs are not supported in this toolset

    #

    Error( "Delphi7 toolset: User source file names not supported")

        if ( scalar @$pObjs );

    #

    #   Determine the target output name

    #

    my $base = $name;

    my $root = "\$(BINDIR)/$base";

    my $full = $root . $::exe;

    #

    #   Determine the source project name

    #   Will have the same name as the EXE, but the suffix may be

    #   .dpr or .pas

    #

    my $source;

    $::ScmQuiet = 3;                                # Can be done better !

    foreach my $suffix ( '.dpr', '.pas' )

    {

        $source = MakeSrcResolve ( "$name$suffix" );

        last if ( -f $source );

        $source = undef;

    }

    $::ScmQuiet = 0;

    Error ("Program source not found",

           "It must have the same name as the program: $name")

            unless ( $source  );

    #

    #   Create Rules and Recipes to create the Program

    #   This will be a combination of source

    #

    my $me = MakeEntry::New (*MAKEFILE, $full );

    $me->AddComment ("Build Program: $name" );

    $me->AddDependancy ( $source );

    $me->AddDependancy ( '$(SCM_MAKEFILE)' );

    $me->AddDependancy ( '$(DELPHISRCS)' );

    $me->AddDependancy ( @psource );

    $me->AddRecipe ( '$(DCC)' );

    $me->AddDefn ('PSOURCE', $source );

    $me->AddDefn ('PFLAGS',  $link_target );

    $me->AddDefn ('PACKAGES',  join ' ', @$pLibs );

    $me->Print();

    #

    #   Files to clean up

    #

    ToolsetGenerate( "$root.map" );

    ToolsetGenerate( "$base.drc" );                 # Created in CWD

    #.. Package up files that are a part of the program

    #

    PackageProgAddFiles ( $name, $full );

    PackageProgAddFiles ( $name, "$root.map", "Class=map" );

}

#.. Successful termination

1;