Subversion Repositories DevTools

# -*- mode: perl -*- 
#
# Module name   : cygnus_thyron
# Module type   : Makefile system
# Compiler(s)   : ANSI C
# Environment(s): Cygnus/Thyron
#
# Description:
#   Cygnus C/C++ toolset 
#
# Version   Who      Date        Description
# 1.0       APY      17/10/02    Created
#............................................................................#

##############################################################################
#   ToolsetInit()
#       Runtime initialisation
#
##############################################################################

ToolsetInit();

$CygnusVersion              = "2.0";            # Compiler version

sub ToolsetInit
{
#.. Parse arguments
#
    Debug( "cygnus_thyron(@args)\n" );

    foreach $_ ( @args ) {
        if (/^--Version=(.*)/) {                # Compiler version
            $MriVersion = "$1";

        } else {                                # Unknown option
            Message( "cygnus_thyron: unknown option $_ -- ignored\n" );
        }
    }

#.. Standard.rul requirements
#
    $s = asm;
    $o = o;
    $a = a;
    $exe = "";

#.. Define environment
#
    Init( "cygnus_thyron" );

    ToolsetDefine( "#################################################" );
    ToolsetDefine( "# Compiler version" );
    ToolsetDefine( "#" );
    ToolsetDefine( "cygnus_ver      = $CygnusVersion" );
    ToolsetDefine( "" );
    ToolsetDefine( "#" );

    ToolsetDefines( "cygnus_thyron.def" );
    ToolsetRules( "cygnus_thyron.rul" );
    ToolsetRules( "standard.rul" );
}


###############################################################################
#   ToolsetCC( $source, $obj, \@args )
#       This subroutine takes the user options and builds the rule(s)
#       required to compile the source file 'source' to 'obj'
#
###############################################################################

sub ToolsetCC
{
    my( $source, $obj, $pArgs ) = @_;

    Debug( "CC:  $source -> $obj" );
    foreach ( @$pArgs ) {
        Debug( "option:    $_" );
        if ( /--Shared$/ ) {                    # Building a 'shared' object
            $cflags = "$cflags \$(SHCFLAGS)";
            Debug( "CC:    as shared object" );
        } else {                                # unknown option
            Message( "CC: unknown option $_ -- ignored\n" );
        }
    }

    MakePrint( "\n\t\$(CC)\n" );
    MakePrint( "\$(OBJDIR)/$i.${o}:\tCFLAGS +=$cflags\n" )
        if ( $cflags );
}

###############################################################################
#   ToolsetCCDepend( $depend, \@sources )
#       This subroutine takes the user options and builds the
#       rule(s) required to build the dependencies for the source
#       files 'sources' to 'depend'.
#
###############################################################################

sub ToolsetCCDepend
{
    MakePrint( "\t\$(CCDEPEND)\n" );
}


###############################################################################
#   ToolsetCXX( $source, $obj, \@args )
#       This subroutine takes the user options and builds the rule(s)
#       required to compile the source file 'source' to 'obj'
#
###############################################################################

sub ToolsetCXX
{
    my( $source, $obj, $pArgs ) = @_;
    my( $cflags ) = "";

    Debug( "CCX: $source -> $obj" );
    foreach ( @$pArgs ) {
        Debug( "option:    $_" );
        if ( /--Shared$/ ) {                    # Building a 'shared' object
            $cflags = "$cflags \$(SHCXXFLAGS)";
            Debug( "CCX:    as shared object" );
        } else {
            Message( "CCX: unknown option $_ -- ignored\n" );
        }
    }

    MakePrint( "\n\t\$(CXX)\n" );
    MakePrint( "\$(OBJDIR)/$i.${o}:\tCXXFLAGS +=$cflags\n" )
        if ( $cflags );
}


###############################################################################
#   ToolsetCXXDepend( $depend, \@sources )
#       This subroutine takes the user options and builds the
#       rule(s) required to build the dependencies for the source
#       files 'sources' to 'depend'.
#
###############################################################################

sub ToolsetCXXDepend
{
    #ToolsetCCDepend() handles both CC and CXX source
}


###############################################################################
#   ToolsetAS( $source, $obj, \@args )
#       This subroutine takes the user options and builds the rule(s)
#       required to compile the source file 'source' to 'obj'
#
###############################################################################

sub ToolsetAS
{
    my( $source, $obj, $pArgs ) = @_;

    foreach $_ ( @$pArgs ) {
        Message( "CC: unknown option $_ -- ignored\n" );
    }

    MakePrint( "\n\t\$(AS)\n" );
}

sub ToolsetASDepend
{
}


###############################################################################
#   ToolsetAR( $name, \@args, \@objs )
#       This subroutine takes the user options and builds the rules
#       required to build the library 'name'.
#
#   Arguments:
#       n/a
#
#   Output:
#       [ $(BINDIR)/name$.${a}:   .... ]
#           $(AR)
#
#       name_ld += ...  Linker command file
#           :
#
#       name_dp += ...  Dependency list
#           :
#
###############################################################################

sub ToolsetAR
{
    my( $name, $pArgs, $pObjs ) = @_;

    local( $name_ld );

#.. Parse arguments
#
    foreach $_ ( @$pArgs ) 
    {
        Message( "AR: unknown option $_ -- ignored\n" );
    }

#.. Build library rule (just append to standard rule)
#
    MakeEntry( "\$(LIBDIR)/$name\$(SCM_TYPE).${a}:\t",
                  "", "\\\n\t\t", ".${o} ", @$pObjs );

    MakePrint( "\n\t\$(AR)\n\n" );
}


###############################################################################
#   ToolsetLD( $name, \@args, \@objs, \@libraries )
#       This subroutine takes the user options and builds the rules
#       required to link the program 'name'.
#
#   Arguments:
#        n/a
#
#   Output:
#       $(BINDIR)/name${exe}:
#                       $(BINDIR)/name.dep \
#                       $(BINDIR)/name.[abs|bin]
#
#       .PHONY:                 $(BINDIR)/name${exe}:
#
#       $(BINDIR)/name.dep:     $(SCM_PLATFORM).mk
#               $(LDDEPEND)
#
#       ifeq "$(IFLAG)" "2"
#       -include        "$(BINDIR)/name.dep"
#       endif
#
#       $(BINDIR)/name.[abs|bin]
#                       objs ...
#               $(LD)
#
#       name_ld += ...  Linker command file
#           :
#
#       name_dp += ...  Dependency list
#           :
#
###############################################################################

sub ToolsetLD
{
    my( $name, $pArgs, $pObjs, $pLibs ) = @_;
    my( $bin );
    local( $varname );

#.. Parse arguments
#
    $bin = 0;                                   # toolset options

    foreach $_ ( @$pArgs )
    {
    #.. Target specific
    #
        if (/^--Bin/) {                         # Download image
            $bin = 1;
        } elsif (/^--Abs/) {                    # Powerscope image
            $bin = 0;

    #.. Toolset specific
    #
        } else {
            Message( "LD: unknown option $_ -- ignored\n" );
        }
    }

#.. Command file EOS dependencies
#

#.. Cleanup rules
#
    ToolsetGenerate( "\$(BINDIR)/${name}.ld" );
    ToolsetGenerate( "\$(BINDIR)/${name}.dep" );
if ($bin) {
    ToolsetGenerate( "\$(BINDIR)/${name}.bin" );
    ToolsetGenerate( "\$(BINDIR)/${name}.s2" );
}
    ToolsetGenerate( "\$(BINDIR)/${name}.map" );

#.. Linker command file
#
#       Now the fun part... piecing together a variable $(name_ld)
#       which ends up in the command file.
#
if ($bin)
{
    MakePrint( "\\\n\t\t\$(BINDIR)/${name}.dep " .
               "\\\n\t\t\$(BINDIR)/${name}.prg\n\n" .
               ".PHONY:\t\t\t\$(BINDIR)/${name}${exe}\n\n" );

    MakePrint( "\$(BINDIR)/${name}.dep:\t\$(SCM_PLATFORM).mk\n".
                    "\t\$(LDDEPEND)\n\n" );

    MakePrint( "ifeq \"\$(IFLAG)\" \"2\"\n" .
               "-include\t\$(BINDIR)/${name}.dep\n" .
               "endif\n\n" );

    MakePrint( "\$(BINDIR)/${name}.prg:" );
    foreach $i ( @$pObjs ) {
        MakePrint( " \\\n\t\t$i.${o}" );
    }
    MakePrint( "\n\t\$(LD)" );
    MakePrint( "\n\t\$(cygnus)\\objcopy -O srec \$(basename \$@).bin \$(basename \$@).s2" );
    MakePrint( "\n\t\$(thyron)\\thyron\\tools\\s2toprog \$(basename \$@).s2 \$@" );
}
else
{
    MakePrint( "\\\n\t\t\$(BINDIR)/${name}.dep " .
               "\\\n\t\t\$(BINDIR)/${name}.abs\n\n" .
               ".PHONY:\t\t\t\$(BINDIR)/${name}${exe}\n\n" );

    MakePrint( "\$(BINDIR)/${name}.dep:\t\$(SCM_PLATFORM).mk\n".
                    "\t\$(LDDEPEND)\n\n" );

    MakePrint( "ifeq \"\$(IFLAG)\" \"2\"\n" .
               "-include\t\$(BINDIR)/${name}.dep\n" .
               "endif\n\n" );

    MakePrint( "\$(BINDIR)/${name}.abs:" );
    foreach $i ( @$pObjs ) {
        MakePrint( " \\\n\t\t$i.${o}" );
    }
    MakePrint( "\n\t\$(LD)\n" );
}
    MakePrint( "\n" );

#.. Linker command file
#
#       Now the fun part... piecing together a variable $(name_ld)
#       which ends up in the command file.
#
    $varname = "${name}_ld";
    sub VarCmd {                                # with line feed ...
        MakeQuote "$varname += @_\\n\n";
    }
    sub VarCmd2 {                               # without line feed ...
        MakeQuote "$varname += @_\n";
    }
    sub VarPrt {
        MakePrint "@_\n";
    }


        # Section definitions and startup code:
        #
        #   HDI  file to generate ABS target for HDI.
        #   OS   files to generate S2 target to run under operating system.
        #..

        VarPrt( "ifeq \"\$(DEBUG)\" \"1\"" );
            VarCmd( "\$(MPTLIB)/Lib/Debug/Bin/start.o" );
    VarPrt( "else" );
        VarCmd( "\$(MPTLIB)/Lib/Release/Bin/start.o" );
    VarPrt( "endif" );

    foreach $i ( @$pObjs ) {
        VarCmd( "\$(strip $i).${o}" );
    }
    foreach $i ( @$pLibs ) {
        VarCmd( "@(vpath,$i.${a},GCC_LIB)" );
    }

        VarPrt( "ifeq \"\$(DEBUG)\" \"1\"" );
        VarCmd( "\$(MPTLIB)/Lib/Debug/Bin/appllib.a" );
                VarCmd( "\$(MPTLIB)/Lib/Debug/Bin/payclibh.a" );
        VarCmd( "-L \$(MPTLIB)/Lib/Debug/Bin" );
        VarCmd( "-L \$(MPTLIB)/StdCLib/Debug/Bin" );
    VarPrt( "else" );
        VarCmd( "\$(MPTLIB)/Lib/Release/Bin/appllib.a" );
            VarCmd( "-L \$(MPTLIB)/Lib/Release/Bin" );
        VarCmd( "-L \$(MPTLIB)/StdCLib/Release/Bin" );
    VarPrt( "endif" );

    VarCmd( "-Map \$(BINDIR)/${name}.map" );

        if ($bin)
        {
        VarCmd( "-o \$(BINDIR)/${name}.bin" );
        }
        else
        {
        VarCmd( "-o \$(BINDIR)/${name}.abs" );
        }

        VarPrt( "ifeq \"\$(DEBUG)\" \"1\"" );
        VarCmd( "-T \$(MPTLIB)/Lib/Debug/Lnk/link.cmd" );
#               VarCmd( "-lg" );                                                # Required for HDI debugger
                VarCmd( "-lgdb" );                                              # Required for Insight debugger
    VarPrt( "else" );
        VarCmd( "-T \$(MPTLIB)/Lib/Release/Lnk/link.cmd" );
    VarPrt( "endif" );

    VarCmd( "-lc" );
        VarCmd( "-lm" );
        VarCmd( "-lgcc" );

    VarPrt( "" );

#.. Dependency link,
#
#       Now piece together a variable $(name_dp) which ends up in
#       the command file building the application dependency list.
#
    $varname = "${name}_dp";

    foreach $i ( @$pLibs ) {
         VarCmd("\$(BINDIR)/${name}${exe}: @(vpath,$i.${a},GCC_LIB)" );
    }
}

#.. Successful termination
1;