toolchain.tcl

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

    # bit to the targeteditor dialog.
    method GetRemoveUserTargetEditGUI {} {
	return $userRemoveGUIcode
    }

    # The proc set here will be used to
    # generate the make rule later.
    method SetUserPostLinkerRuleProc {proc suffixes} {
	set userPostLinkerRule $proc
	set postLinkerSuffixes $suffixes
    }

    method GetUserPostLinkerRuleProc {} {
	return $userPostLinkerRule
    }

    method GetPostLinkerSuffixes {} {
	return $postLinkerSuffixes
    }

    method SetLibSpecProc {spec_proc} {
        set GenLibSpec ${specProc}
    }

    method SetIncludeSpecProc {rule_type spec_proc} {
        #TODO: Check rule type is good
        set FormatIncludeProcs(${rule_type}) ${spec_proc}
    }

    method SetDefinesSpecProc {rule_type spec_proc} {
        #TODO: Check rule type is good
        set FormatDefinesProcs(${rule_type}) ${spec_proc}
    }

    method FormatIncludes {rule_type includes_list} {
        #TODO: Check rule type is good
        return [$FormatIncludeProcs(${rule_type}) ${includes_list}]
    }

    method FormatDefines {rule_type defines_list} {
        #TODO: Check rule type is good
        return [$FormatDefinesProcs(${rule_type}) ${defines_list}]
    }

    method GetFileType {src_file} {

        # Get it's extention
        set fileext [lindex [split [file extension ${src_file}] .] 1]

        foreach ruletype [GetRulesList] {
            foreach rulesuffix $ruleSuffix(${ruletype}) {
                set suffix [lindex [split ${rulesuffix} "."] 1]
                if {${fileext}==${suffix}} {
                    return ${ruletype}
                }
            }
        }
        return UNKNOWN
    }

    method GetObjectFileList {src_file_list} {
        # Get list of rule types
        set ruletypes [array names ruleSuffix]

        # Create an array for file translation look ups
        foreach ruletype ${ruletypes} {
            foreach suffixset $ruleSuffix(${ruletype}) {
                set suffix [split ${suffixset} "."]
                set suffixlookup([lindex ${suffix} 1]) [lindex ${suffix} 2]
            }
        }

        set objfiles ""
        # Process src_file_list to get object file list
        foreach srcfile ${src_file_list} {
            set fileext [lindex [split [file extension ${srcfile}] .] 1]
            while {[info exists suffixlookup(${fileext})]} {
                set fileext $suffixlookup(${fileext})
            }

            # if the file extention (fileent) is set to nothing
            # then this is probably a glich or bug, ignore it.
            if {${fileext}!=""} {
                lappend objfiles "[file tail [file rootname\
                  ${srcfile}]].${fileext}"
            }
        }
        return ${objfiles}
    }

    method GetIsEmbedded {} {
        return ${isEmbedded}
    }

    method SetIsEmbedded {val} {
        set isEmbedded ${val}
    }

    method SetDebuggerName {name} {
        set debuggerName ${name}
    }

    method GetDebuggerName {} {
        return ${debuggerName}
    }

    method SetShortName {name} {
        set shortName ${name}
    }

    method GetShortName {} {
        return ${shortName}
    }

    method GetLongName {} {
	return $fulldescription
    }

    method SetLongName {name} {
	set fulldescription $name
    }
}

##############################################
# CreateFlagIDTag
#
# Since you can't have spaces in an array, we create and IDTag
# for the string which can be later reterived when it is needed.
#

proc CreateFlagIDTag {id_tag textstr} {
    global FlagTags
    set FlagTags(${id_tag}) ${textstr}
}

#Create Toolchain flags and strings.

CreateFlagIDTag DBG_DEFAULT "Compiler Default"
CreateFlagIDTag DBG_NONE "Disabled"
CreateFlagIDTag DBG_STD "Standard Debug"
CreateFlagIDTag DBG_OLD "Old Style Debug"

#OPTIMIZATION FLAGS
CreateFlagIDTag OPT_DEFAULT "Compiler Default"
CreateFlagIDTag OPT_NONE "Disabled"
CreateFlagIDTag OPT_L1 "Level 1"
CreateFlagIDTag OPT_L2 "Level 2"
CreateFlagIDTag OPT_L3 "Level 3 (high)"
CreateFlagIDTag OPT_SPEED "for maximum speed"
CreateFlagIDTag OPT_SIZE "for minimum size only"
CreateFlagIDTag OPT_BOTH "best speed and size"

#CODE GENERATION FLAGS
CreateFlagIDTag CG_DEFAULT "Compiler Default"
CreateFlagIDTag CG_BLEND "Bended Model"
CreateFlagIDTag CG_386 "Optimize for 80386"
CreateFlagIDTag CG_486 "Optimize for 80486"
CreateFlagIDTag CG_PENT "Optimize for Pentium"
CreateFlagIDTag CG_PPRO "Optimize for Pentium Pro"
CreateFlagIDTag CG_WINAPP "Optimize for Win32 App"
CreateFlagIDTag CG_DLL "Optimize for Win32 DLL"
CreateFlagIDTag CG_SHORTENUMS "Use short enums"
CreateFlagIDTag CG_SHAREDATA "Use Shared Data"
CreateFlagIDTag CG_PIC "Generate position-independent code"
CreateFlagIDTag CG_NONULL "Assume refs not null"
CreateFlagIDTag CG_INLINE "Inline functions where possible"
CreateFlagIDTag CG_NOBOUND "No array bound checking"

#WARNING FLAGS
CreateFlagIDTag WN_DEFAULT "Compiler Default"
CreateFlagIDTag WN_L0 "Level 0"
CreateFlagIDTag WN_L1 "Level 1"
CreateFlagIDTag WN_L2 "Level 2"
CreateFlagIDTag WN_L3 "Level 3"
CreateFlagIDTag WN_L4 "Level 4"
CreateFlagIDTag WN_ERR "Warnings as Errors"
CreateFlagIDTag WN_ANSI "Strict ANSI Warnings"
CreateFlagIDTag WN_STD "Standard Warnings"
CreateFlagIDTag WN_NONE "No Warnings"
CreateFlagIDTag WN_ALL "Report All Warnings"
CreateFlagIDTag WN_STRICT_JAVA "Strict Java Warnings"

proc InitializeToolChainInfo {} {

    global sn_path
    # TODO: We need to add support to check
    #       a user toolchain directory so that
    #       users don't have to install toolchain
    #       spex in .../share/etc/sn_toolchains

    # Check .../share/etc/sn_toolchains for toolchain spex.
    
    set toolchain_dir [file join [pwd] $sn_path(toolchaindir)]

    set toolchain_files [sn_glob $toolchain_dir]

    foreach file $toolchain_files {
        if {![file isdirectory $file]} {
            source $file
	}
    }
}

proc GetActiveToolChains {} {
    
    set installed ""

    foreach toolchain [itcl::find objects -class snToolChain] {
	# TODO: Test toolchain is installed
        lappend installed $toolchain
    }
    return $installed
}

proc GetToolChainObject {tool_chain_name} {

    set toolchains [GetActiveToolChains]

    foreach toolchain $toolchains {
	if {[$toolchain GetLongName] == $tool_chain_name} {
	    return $toolchain
	}
    }

    # FIXME: To avoid issues just return GNUPro and pray...
    return GNUPro
}

proc DummyProcessArgs {{args ""}} {
    return ""
}

proc sn_add_simple_ide_rule {ident args} {

    set suffixList ""
    set basicAction ""
    set tool ""
    set description ""
    set fileType ${ident}

    # For the time being we are only supporting one
    # toolchain at a time.  So we will just default
    # to GNUPro 
    #set toolchain GNUPro

    for {set i 0} {${i} < [llength ${args}]} {incr i} {
        set arg [lindex ${args} ${i}]
        incr i
        set val [lindex ${args} ${i}]

        switch -- ${arg} {
            "-suffix-list" {
                    set suffixList ${val}
                }
            "-action" {
                    set basicAction ${val}
                }
            "-tool" {
                    set tool ${val}
                }
            "-description" {
                    set description ${val}
                }
            "-file-type" {
                    set fileType ${val}
                }
        }
    }

    if {${suffixList}!=""} {
        set firstSuffix [lindex ${suffixList} 0]
    } else {
        #TODO: error!!!
    }

    #TODO: check other flags to make sure we have enough to
    # create the toolchain properly

    set toolchains [itcl_info objects -class snToolChain]

    foreach toolchain ${toolchains} {
        #Create tool spec.
        ${toolchain} AddRule ${ident} ${firstSuffix} ${tool} ${basicAction}
        ${toolchain} AddRuleInfo ${ident} ${fileType} ${description}

        # Add any remaining suffixes
        foreach suffix ${suffixList} {
            if {${suffix}!=${firstSuffix}} {
                ${toolchain} AddRuleSuffix ${ident} ${suffix}
            }
        }

        # Set other dummy stuff that we won't handle.
        ${toolchain} SetIncludeSpecProc ${ident} DummyProcessArgs
        ${toolchain} SetDefinesSpecProc ${ident} DummyProcessArgs

        # Set default settings for Optimize, Debug, Warnings and
        # Code Generation.  This make the configure tool dialog
        # work without having to change it.    
        ${toolchain} AddRuleFlagSet ${ident} Optimize "" OPT_DEFAULT
        ${toolchain} AddRuleFlagSet ${ident} Debug "" DBG_DEFAULT
        ${toolchain} AddRuleFlagSet ${ident} Warning "" WN_DEFAULT
        ${toolchain} AddRuleFlagSet ${ident} CodeGen "" CG_DEFAULT
    }
}