buildtarget.tcl

来自「This Source-Navigator, an IDE for C/C++/」· TCL 代码 · 共 711 行 · 第 1/2 页

            # We don't need to set it since we know
            # we can guess it.
            set LinkerApplication ""
        } else {
            set LinkerApplication ${linker}
        }
    }

    method GuessProjectType {} {

        set tchain_obj [GetToolChainObject ${ToolChain}]

        set JavaFiles 0
        set CPPFiles 0
        set CFiles 0

        foreach file ${SrcFiles} {
            switch [${tchain_obj} GetFileType ${file}] {
                JAVA {
                        incr JavaFiles
                    }
                CPP {
                        incr CPPFiles
                    }
                CC {
                        incr CFiles
                    }
            }
        }

        if {${JavaFiles}!=0} {
            return JAVA
        }
        if {${CPPFiles}!=0} {
            return CPP
        }
        # NB: The file type might be UNKNOWN but return CC anyway.
        return CC
    }

    method GetLinkerLocation {} {
        set tchain_obj [GetToolChainObject ${ToolChain}]
        if {${LinkerApplication}==""} {
            set projecttype [GuessProjectType]
            if {${TargetType}=="Executable"} {
                set tool [GetTool ${projecttype}]
            } else {
                #Must be a library then.
                set tool [${tchain_obj} GetLibLinkerTool]
            }

            if {${tool}==""} {
                set tchain_obj [GetToolChainObject ${ToolChain}]
                set tool [GetTool ${projecttype}]
            }

            return ${tool}
        }

        return ${LinkerApplication}
    }

    method SetLaunchWithDebugger {use_debugger} {
        set LaunchDebugger ${use_debugger}
    }

    method GetLaunchWithDebugger {} {
        if {${LaunchDebugger}==""} {
            set LaunchDebugger 0
        }

        return ${LaunchDebugger}
    }

    method LoadData {{target_name ""}} {
        sn_log "IDE_DEBUG(snBuildTarget::LoadData)"

        if {${target_name}!=""} {
            set TargetName ${target_name}
        }

	# Get user custom/client data.
	set userToolChainData [paf_db_proj get -key "IDEUserData${TargetName}"]

        # Get Build Directory
        set BuildDir [paf_db_proj get -key "IDEBuildDir${TargetName}"]

        # Get Target Type
        set db_target_type [paf_db_proj get -key "IDETargetType${TargetName}"]
        if {${db_target_type}!=""} {
            set TargetType ${db_target_type}
        }

        # Get Tool Chain
        set ToolChain [paf_db_proj get -key "IDEToolChain${TargetName}"]

        # Get Source Files
        set SrcFiles [paf_db_proj get -key "IDESourceFiles${TargetName}"]

        # Get the link output file name.
        set OutputFilename [paf_db_proj get -key "IDELinkOutFile${TargetName}"]

        # Get the user linker flags.
        set UserLinkFlags [paf_db_proj get\
          -key "IDEUserLinkerFlags${TargetName}"]

        # Get the link entry point.
        set LinkerEntryPoint [paf_db_proj get\
          -key "IDELinkEntryPoint${TargetName}"]

  	# Get the link command/executable
        set LinkerApplication [paf_db_proj get\
	  -key "IDELinkerApplication${TargetName}"]

        # Get the defines list
        # TODO: Get rule type from toolchain
        foreach ruletype "CC CPP JAVA" {
            set Defines(${ruletype}) [paf_db_proj get\
              -key "IDEMacroDefines${ruletype}${TargetName}"]
        }

        # Get Auto Generated Includes.
        set IncludesAuto(CC) [paf_db_proj get\
          -key "IDEGenIncludesCC${TargetName}"]
        set IncludesAuto(CPP) [paf_db_proj get\
          -key "IDEGenIncludesCPP${TargetName}"]
        set IncludesAuto(JAVA) [paf_db_proj get\
          -key "IDEGenIncludesJAVA${TargetName}"]

        # Get User specified Includes.
        set IncludesUser(CC) [paf_db_proj get\
          -key "IDEUserIncludesCC${TargetName}"]
        set IncludesUser(CPP) [paf_db_proj get\
          -key "IDEUserIncludesCPP${TargetName}"]
        set IncludesUser(JAVA) [paf_db_proj get\
          -key "IDEUserIncludesJAVA${TargetName}"]

        # Get Launch with debugger flag.
        set LaunchDebugger [paf_db_proj get\
          -key "IDEUseDebuggerOnLaunch${TargetName}"]
        set LaunchCommandLine [paf_db_proj get\
          -key "IDELaunchCommandLine${TargetName}"]

        set NeedsRebuild [paf_db_proj get -key "IDENeedsRebuild${TargetName}"]
        if {${NeedsRebuild} == ""} {
            set NeedsRebuild 0
        }

        LoadToolChainFlags

        # Load Rule Status settings.
        LoadRuleStatus

        # Get Librarys to linked against.
        set LibFiles [paf_db_proj get -key "IDELibFiles${TargetName}"]

        paf_db_proj sync
    }

    method SaveData {{target_name ""}} {
        sn_log "IDE_DEBUG(snBuildTarget::SaveData)"

        if {${target_name}!=""} {
            set TargetName ${target_name}
        }

	# Store user custom/client data.
	paf_db_proj put "IDEUserData${TargetName}" ${userToolChainData}

        # Store Build Directory
        paf_db_proj put "IDEBuildDir${TargetName}" ${BuildDir}

        # Store Target Type
        paf_db_proj put "IDETargetType${TargetName}" ${TargetType}

        # Store Tool Chain
        paf_db_proj put "IDEToolChain${TargetName}" ${ToolChain}

        # Store Source Files
        paf_db_proj put "IDESourceFiles${TargetName}" ${SrcFiles}

        # Store the link output file name.
        paf_db_proj put "IDELinkOutFile${TargetName}" ${OutputFilename}

        # Store the user linker flags.
        paf_db_proj put "IDEUserLinkerFlags${TargetName}" ${UserLinkFlags}

        # Store the link entry point.
        paf_db_proj put "IDELinkEntryPoint${TargetName}" ${LinkerEntryPoint}

 	# Store the link command/executable
        paf_db_proj put "IDELinkerApplication${TargetName}" $LinkerApplication

        # Store the defines list
        # TODO: Get rule type from toolchain
        foreach ruletype "CC CPP JAVA" {
            paf_db_proj put\
              "IDEMacroDefines${ruletype}${TargetName}" $Defines(${ruletype})
        }

        # Store Auto Generated Includes.
        paf_db_proj put "IDEGenIncludesCC${TargetName}" $IncludesAuto(CC)
        paf_db_proj put "IDEGenIncludesCPP${TargetName}" $IncludesAuto(CPP)
        paf_db_proj put "IDEGenIncludesJAVA${TargetName}" $IncludesAuto(JAVA)

        # Store User specified Includes.
        paf_db_proj put "IDEUserIncludesCC${TargetName}" $IncludesUser(CC)
        paf_db_proj put "IDEUserIncludesCPP${TargetName}" $IncludesUser(CPP)
        paf_db_proj put "IDEUserIncludesJAVA${TargetName}" $IncludesUser(JAVA)

        # Save ToolChain flags.
        SaveToolChainFlags

        # Save Rule Status settings.
        SaveRuleStatus

        # Store Launch with debugger flag.
        paf_db_proj put "IDEUseDebuggerOnLaunch${TargetName}" ${LaunchDebugger}
        paf_db_proj put "IDELaunchCommandLine${TargetName}" ${LaunchCommandLine}

        paf_db_proj put "IDENeedsRebuild${TargetName}" ${NeedsRebuild}

        # Store Librarys to linked against.
        paf_db_proj put "IDELibFiles${TargetName}" ${LibFiles}

        paf_db_proj sync
    }

    method DeleteData {{target_name ""}} {
        sn_log "IDE_DEBUG(snBuildTarget::DeleteData)"

        if {${target_name}!=""} {
            set TargetName ${target_name}
        }

	# Delete user custom/client data.
	paf_db_proj delete "IDEUserData${TargetName}"

        # Delete Build Directory
        paf_db_proj delete "IDEBuildDir${TargetName}"

        # Delete Target Type
        paf_db_proj delete "IDETargetType${TargetName}"

        # Delete Tool Chain
        paf_db_proj delete "IDEToolChain${TargetName}"

        # delete Source Files
        paf_db_proj delete "IDESourceFiles${TargetName}"

        # delete the link output file name.
        paf_db_proj delete "IDELinkOutFile${TargetName}"

        # delete the user linker flags.
        paf_db_proj delete "IDEUserLinkerFlags${TargetName}"

        # delete the link entry point.
        paf_db_proj delete "IDELinkEntryPoint${TargetName}"

 	# delete the link command/executable
        paf_db_proj delete "IDELinkerApplication${TargetName}"

        # delete the defines list
        # TODO: Get rule type from toolchain
        foreach ruletype "CC CPP JAVA" {
            paf_db_proj delete "IDEMacroDefines${ruletype}${TargetName}"
        }

        # delete Auto Generated Includes.
        paf_db_proj delete "IDEGenIncludesCC${TargetName}"
        paf_db_proj delete "IDEGenIncludesCPP${TargetName}"
        paf_db_proj delete "IDEGenIncludesJAVA${TargetName}"

        # delete User specified Includes.
        paf_db_proj delete "IDEUserIncludesCC${TargetName}"
        paf_db_proj delete "IDEUserIncludesCPP${TargetName}"
        paf_db_proj delete "IDEUserIncludesJAVA${TargetName}"

        DeleteToolChainFlags

        # Delete Rule Status settings.
        DeleteRuleStatus

        # Delete Launch with debugger flag.
        paf_db_proj delete "IDEUseDebuggerOnLaunch${TargetName}"
        paf_db_proj delete "IDELaunchCommandLine${TargetName}"

        paf_db_proj delete "IDENeedsRebuild${TargetName}"

        # delete Librarys to linked against.
        paf_db_proj delete "IDELibFiles${TargetName}"

        paf_db_proj sync
    }

    method SaveToolChainFlags {} {
        set flagkeys [array names ToolChainFlags]

        paf_db_proj put "IDEFlagKeys${TargetName}" ${flagkeys}

        foreach flagkey ${flagkeys} {
            paf_db_proj put\
              "IDEFlagKey_${flagkey}${TargetName}" $ToolChainFlags(${flagkey})
        }
    }

    method LoadToolChainFlags {} {
        set flagkeys [paf_db_proj get -key "IDEFlagKeys${TargetName}"]

        foreach flagkey ${flagkeys} {
            set ToolChainFlags(${flagkey}) [paf_db_proj get\
              -key "IDEFlagKey_${flagkey}${TargetName}"]
        }
    }

    method DeleteToolChainFlags {} {
        set flagkeys [paf_db_proj get -key "IDEFlagKeys${TargetName}"]

        paf_db_proj delete "IDEFlagKeys${TargetName}"

        foreach flagkey ${flagkeys} {
            paf_db_proj delete "IDEFlagKey_${flagkey}${TargetName}"
        }
    }

    method SaveRuleStatus {} {
        set rulestatuskeys [array names ruleStatus]

        # Only Save the disabled rules.
        set disabledRules ""
        foreach rulestat ${rulestatuskeys} {
            if {[GetRuleStatus ${rulestat}]=="Disabled"} {
                set disabledRules "${disabledRules} ${rulestat}"
            }
        }
        paf_db_proj put "IDEDisabledRules${TargetName}" ${disabledRules}
    }

    method LoadRuleStatus {} {
        set rulestatuskeys [paf_db_proj get\
          -key "IDEDisabledRules${TargetName}"]

        foreach rulestat ${rulestatuskeys} {
            set ruleStatus(${rulestat}) "Disabled"
        }
    }

    method DeleteRuleStatus {} {
        paf_db_proj delete "IDEDisabledRules${TargetName}"
    }

}