mkfilegen.tcl

This Source-Navigator, an IDE for C/C++/Fortran/Java/Tcl/PHP/Python and a host of other languages.

# Copyright (c) 2000, 2001, Red Hat, Inc.
# 
# This file is part of Source-Navigator.
# 
# Source-Navigator is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as published
# by the Free Software Foundation; either version 2, or (at your option)
# any later version.
# 
# Source-Navigator is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
# 
# You should have received a copy of the GNU General Public License along
# with Source-Navigator; see the file COPYING.  If not, write to
# the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
# MA 02111-1307, USA.
# 
################################################
##
## Makefile generation for SN-IDE.
## Copyright (c) 1999 Cygnus Solutions, Inc.
## Written by Ian Roxborough <[e-mail]>
##
################################################

itcl::class MakefileGen {

    # public data members
    public variable TargetName ""
    # The build target name

    # private date members
    protected variable b_target ""
    # Build target object
    protected variable toolchain ""
    # Use this toolchain


    method constructor {target_name {tool_chain ""} {args "" }} {

        set TargetName ${target_name}
        set toolchain ${tool_chain}

    }

    method GenerateMakefile {{filename ""}} {

        #TODO: CheckValidBuildTarget


        # Inialize and load build target data.

        set b_target [snBuildTarget tmptar]
        ${b_target} LoadData ${TargetName}

        DummyCreateToolChain_spec


        if {${toolchain}!=""} {
            #TODO: select toolchain
        } else {
            set toolchainname [${b_target} GetToolChain]
            set toolchain [GetToolChainObject ${toolchainname}]
        }


        if {${filename}==""} {
            # We have been passed a blank files so let generate one
            set dirname [${b_target} GetBuildDirectory]

            # If the build directory does not exist, create it now
            if {![file exists ${dirname}]} {
                if {[catch {file mkdir ${dirname}}]!=0} {

                    # We couldn't create the directory.
                    sn_error_dialog "The Directory \"${dirname}\" cannot be\
                      created."

                    # Delete temp build target.
                    itcl::delete object ${b_target}

                    # Return the $dirname, everything else should unwind safely.
                    return ${dirname}
                }
            }

            set filename [file join ${dirname} snMakefile]
        }


        if {[file exists ${filename}]} {
            file delete ${filename}
        }

        set fd [open ${filename} "CREAT RDWR"]
        if {${fd}==0} {
            # OH no we've got a problem
            # TODO: error reporting
        }

        # Give the Makefile a header (target name, time, date, etc)
        WriteHeader ${fd}

        WriteSUFFIXES ${fd}

        WriteVPATHs ${fd}

        WriteMarcoTool ${fd}
        WriteMarcoFLAGs ${fd}
        WriteMarcoINCLUDES ${fd}
        WriteMarcoDEFINES ${fd}
        WriteMarcoLIBS ${fd}
        WriteMacroLINKER ${fd}

        WriteMacroOBJFILES ${fd}

        WriteRuleALL ${fd}

        WriteRuleTarget ${fd}

        WritePostLinkRule ${fd}

        WriteRuleBuilds ${fd}

        WriteRuleDependences ${fd}

        WriteRuleclean ${fd}

        close ${fd}

        # Delete temp build target
        itcl::delete object ${b_target}

        return ${filename}
    }


    method Test1 {channel tool_chain build_target} {

        set toolchain ${tool_chain}
        set b_target ${build_target}
        set fd ${channel}

        # Give the Makefile a header (target name, time, date, etc)
        puts ${fd} "<<< Testing WriteHeader >>>"
        flush ${fd}
        WriteHeader ${fd}

        puts ${fd} "<<< Testing WriteMarcoTool >>>"
        flush ${fd}
        WriteMarcoTool ${fd}

        puts ${fd} "<<< Testing WriteMarcoFLAGs >>>"
        flush ${fd}
        WriteMarcoFLAGs ${fd}

        puts ${fd} "<<< Testing WriteMarcoINCLUDES >>>"
        flush ${fd}
        WriteMarcoINCLUDES ${fd}

        puts ${fd} "<<< Testing WriteMarcoDEFINES >>>"
        flush ${fd}
        WriteMarcoDEFINES ${fd}

        puts ${fd} "<<< Testing WriteMarcoLIBS >>>"
        flush ${fd}
        WriteMarcoLIBS ${fd}

        puts ${fd} "<<< Testing WriteMacroLINKER >>>"
        flush ${fd}
        WriteMacroLINKER ${fd}

        puts ${fd} "<<< Testing WriteMacroOBJFILES >>>"
        flush ${fd}
        WriteMacroOBJFILES ${fd}

        puts ${fd} "<<< Testing WriteRuleALL >>>"
        flush ${fd}
        WriteRuleALL ${fd}

        puts ${fd} "<<< Testing WriteRuleTarget >>>"
        flush ${fd}
        WriteRuleTarget ${fd}

        puts ${fd} "<<< Testing WriteRuleBuilds >>>"
        flush ${fd}
        WriteRuleBuilds ${fd}

        puts ${fd} "<<< Testing WriteRuleDependences >>>"
        flush ${fd}
        WriteRuleDependences ${fd}

    }


    method WriteHeader {file_d} {

        set time [clock format [clock seconds] -format "%r"]
        set date [clock format [clock seconds] -format "%h %d %Y"]

        puts ${file_d}\
          "#########################################################"
        puts ${file_d} "# Makefile auto generated by Cygnus Source Navigator."
        puts ${file_d} "# Target: ${TargetName} Date: ${date} Time: ${time}"
        puts ${file_d} "#\n"
        flush ${file_d}
    }

    method WriteSUFFIXES {file_d} {

        # Make array indexed by valid file extensions
        foreach rule [${toolchain} GetRulesList] {
            if {[${b_target} GetRuleStatus ${rule}]=="Enabled"} {
                foreach rulesuffix [${toolchain} GetRuleSuffixList ${rule}] {
                    set srcsuffix [split ${rulesuffix} "."]

                    # Add the source file extension.
                    set validExtensions(.[lindex ${srcsuffix} 1]) ""

                    # If we can see it, add the target extension (e.g. .o .obj).
                    if {[lindex ${srcsuffix} 2]!=""} {
                        set validExtensions(.[lindex ${srcsuffix} 2]) ""
                    }
                }
            }
        }

        set suffixes ""
        foreach suff [array names validExtensions] {
            set suffixes "${suffixes} ${suff}"
        }
        puts ${file_d} "\n.SUFFIXES:${suffixes}\n"
    }

    method WriteVPATHs {file_d} {
        puts ${file_d} "\nVPATH = [${b_target} GetSourceFilePaths]\n\n"
    }

    method WriteMarcoTool {file_d} {

        # Get a list of tools and types JAVA CC CPP etc...

        set ruletypeslist [${toolchain} GetRulesList]

        foreach rule_type ${ruletypeslist} {
            set tool [${b_target} GetTool ${rule_type}]
            if {${tool}==""} {
                set tool [${toolchain} GetTool ${rule_type}]
            }
            puts ${file_d} "${rule_type} = ${tool}"
        }
    }

    method WriteMarcoFLAGs {file_d} {

        set ruletypeslist [${toolchain} GetRulesList]

        foreach ruletype ${ruletypeslist} {
            set flags ""
            foreach flagstype "Debug Optimize Warning CodeGen" {
                set flagsetting [${b_target} GetToolChainFlags ${ruletype}\
                  ${flagstype}]
                set flags "${flags} [${toolchain} GetRuleFlags ${ruletype}\
                  ${flagstype} ${flagsetting}]"
            }
            set flags "${flags} [${b_target} GetToolChainFlags ${ruletype}\
              UserFlags]"
            set tmp "_FLAGS"
            puts ${file_d} "${ruletype}${tmp} = ${flags}"
        }
    }

    method WriteMarcoINCLUDES {file_d} {
        set ruletypeslist [${toolchain} GetRulesList]

        foreach ruletype ${ruletypeslist} {
            set includes_list1 [${b_target} GetUserIncludes ${ruletype}]
            set includes_list2 [${b_target} GetAutoIncludes ${ruletype}]
            set includes_list [concat ${includes_list1} ${includes_list2}]
            set include_spec [${toolchain} FormatIncludes ${ruletype}\
              ${includes_list}]
            set tmp "_INCLUDES"
            puts ${file_d} "${ruletype}${tmp} = ${include_spec}"
        }
    }

    method WriteMarcoDEFINES {file_d} {
        set ruletypeslist [${toolchain} GetRulesList]

        foreach ruletype ${ruletypeslist} {
            set defines_list [${b_target} GetUserDefines ${ruletype}]
            set defines_spec [${toolchain} FormatDefines ${ruletype}\
              ${defines_list}]
            set tmp "_DEFINES"
            puts ${file_d} "${ruletype}${tmp} = ${defines_spec}"
        }
    }

    method WriteMarcoLIBS {file_d} {
        set lib_files [${b_target} GetLibraryFiles]
        set tmpstr "_LIBS"