1347 lines
45 KiB
Ruby
Executable File
1347 lines
45 KiB
Ruby
Executable File
require 'xml'
|
|
require 'active_support/ordered_hash'
|
|
require 'pipeline/coding/projbuild/project'
|
|
require 'pipeline/coding/xml2vsxml'
|
|
require 'pipeline/coding/projbuild/scriptutility'
|
|
require 'pipeline/coding/projbuild/generators/vsshared'
|
|
require 'pipeline/coding/projbuild/custom/custom_build_step'
|
|
require 'pipeline/os/file'
|
|
require 'pipeline/os/path'
|
|
|
|
module Pipeline
|
|
|
|
module ProjBuild
|
|
|
|
# DW - WTF is this shit?
|
|
#HACK: Global search paths to be shared across all RageGen2010SolutionLoaders created.
|
|
$search_guid_paths = Hash.new()
|
|
|
|
class RageGen2010SolutionLoader
|
|
|
|
@@log = nil
|
|
|
|
def RageGen2010SolutionLoader.log
|
|
|
|
@@log = Log.new( 'ragegen2010solutionloader' ) if @@log == nil
|
|
@@log
|
|
end
|
|
|
|
def initialize()
|
|
|
|
if $search_guid_paths == nil
|
|
$search_guid_paths = Hash.new()
|
|
end
|
|
end
|
|
|
|
def import( path, output_format, options )
|
|
|
|
RageGen2010SolutionLoader.log.info("Trying to import #{path} with ragegen project loader.")
|
|
|
|
selected_template = ScriptUtility.determine_solution_template(path)
|
|
|
|
if selected_template == nil
|
|
RageGen2010SolutionLoader.log.info("Template doesn't exist: #{selected_template}!")
|
|
return false
|
|
end
|
|
|
|
config_filename = "#{selected_template}.configs"
|
|
|
|
if File.exists?(config_filename) == false then
|
|
print "Config file does not exist: #{config_filename}\n"
|
|
RageGen2010SolutionLoader.log.info("template doesn't exist: #{config_filename}")
|
|
return false
|
|
end
|
|
|
|
solution_generation = ScriptUtility.acquire_variable(path, 'NO_SOLUTION_GENERATION')
|
|
if solution_generation != nil and solution_generation != ""
|
|
#Due to our reliance on the RageGen generation method to generate multiple projects
|
|
#in one folder, the ability to circumvent solution generation is inserted here.
|
|
print "No solution generation is switched on within #{path}. No solutions will be generated.\n"
|
|
return true
|
|
end
|
|
|
|
testers_var = ScriptUtility.acquire_variable(path, 'TESTERS')
|
|
testers_var = "" if testers_var.nil?
|
|
|
|
RageGen2010SolutionLoader.log.info("testers_var #{testers_var}")
|
|
|
|
archive = ScriptUtility.acquire_variable(path, 'ARCHIVE')
|
|
testers_var += " " + archive if archive.nil? == false
|
|
|
|
@tester_array = testers_var.split(" ")
|
|
@working_directory = File.dirname(path)
|
|
|
|
build_data = ProjBuildData::instance()
|
|
build_data.reset
|
|
|
|
success = true
|
|
projects = Array.new()
|
|
@tester_array.each do |tester|
|
|
|
|
RageGen2010SolutionLoader.log.info("running tester #{tester}")
|
|
basename = OS::Path.get_basename(tester)
|
|
solution_file = OS::Path::combine(@working_directory, basename)
|
|
|
|
print "Generating #{solution_file}...\n"
|
|
|
|
#Read the .config file for all configurations to add to the solution.
|
|
platforms = ActiveSupport::OrderedHash.new()
|
|
targets = ActiveSupport::OrderedHash.new()
|
|
|
|
File.readlines(config_filename).each { |line|
|
|
|
|
tokens = line.split("=")
|
|
|
|
sln = tokens[0]
|
|
proj = tokens[1]
|
|
|
|
sln_tokens = sln.split("|")
|
|
if sln_tokens.size == 1
|
|
line.strip!
|
|
print "Unable to parse line \"#{line}\" in #{config_filename}!\n"
|
|
next
|
|
end
|
|
|
|
sln_target = sln.split("|")[0].strip
|
|
sln_platform = VSProjShared.get_platform(sln.split("|")[1].strip)
|
|
|
|
if proj == nil then
|
|
|
|
proj = sln
|
|
end
|
|
|
|
if platforms[sln_platform] == nil then
|
|
|
|
platforms[sln_platform] = Hash.new()
|
|
end
|
|
|
|
platforms[sln_platform][sln_target] = proj
|
|
}
|
|
|
|
#load in the root project...
|
|
guid_filename = OS::Path::combine(@working_directory, basename) + ".guid"
|
|
guid = VSProjShared.create_guid(guid_filename, @p4)
|
|
|
|
project = Info::Project.new(basename)
|
|
project.guid = guid
|
|
project.path = Dir.getwd
|
|
|
|
platforms.keys.each { |sln_platform|
|
|
targets = platforms[sln_platform]
|
|
|
|
targets.keys.each { |sln_target|
|
|
proj_cfg = targets[sln_target]
|
|
|
|
proj_platform, proj_target = VSProjShared.parse_config_name(proj_cfg)
|
|
build_data.add_projectconfig(sln_platform,sln_target,project.guid,proj_platform,proj_target)
|
|
}
|
|
}
|
|
|
|
build_data.projects[project.guid] = project
|
|
build_data.root_guid = guid
|
|
|
|
#load in each of the dependent projects...
|
|
|
|
search_paths = Array.new()
|
|
|
|
xproj = ScriptUtility.acquire_variable(path, 'XPROJ')
|
|
if xproj != nil
|
|
xproj.split(' ').each { |xpath|
|
|
|
|
search_paths << xpath
|
|
}
|
|
end
|
|
|
|
self_search_path = File.dirname(path) + "/"
|
|
self_search_path = OS::Path.normalise(self_search_path)
|
|
search_paths << self_search_path
|
|
|
|
search_paths << "%RAGE_DIR%\\stlport\\STLport-5.0RC5\\"
|
|
search_paths << "%RAGE_DIR%\\base\\src\\"
|
|
search_paths << "%RAGE_DIR%\\suite\\src\\"
|
|
search_paths << "%RAGE_DIR%\\base\\samples\\"
|
|
search_paths << "%RAGE_DIR%\\suite\\samples\\"
|
|
search_paths << "%RAGE_DIR%\\base\\tools\\"
|
|
search_paths << "%RAGE_DIR%\\suite\\tools\\"
|
|
|
|
libs = ScriptUtility.acquire_expanded_libs(path, basename)
|
|
|
|
RageGen2010SolutionLoader.log.info("libs #{libs.length} #{libs}")
|
|
|
|
Dir.chdir(OS::Path.get_directory(path)) {
|
|
|
|
if libs != nil
|
|
|
|
libs.each { |lib|
|
|
|
|
lib_name = OS::Path.get_basename(lib)
|
|
|
|
lib = OS::Path.normalise(lib)
|
|
guid = nil
|
|
guid_filename = nil
|
|
|
|
if (lib.index(":") == nil) and (lib.index("/") == nil) then
|
|
|
|
found = false
|
|
ambiguous = false
|
|
base_guid_name = "#{lib_name}.guid"
|
|
|
|
search_paths.each { |search_path|
|
|
|
|
search_path = ScriptUtility.convert_paths_in_line(search_path)
|
|
|
|
if $search_guid_paths[base_guid_name] != nil
|
|
found = true
|
|
guid_filename = $search_guid_paths[base_guid_name]
|
|
break
|
|
|
|
else
|
|
|
|
search_path = File.join(search_path, "**", base_guid_name)
|
|
search_path.gsub!("\\", "/")
|
|
found_files = Dir.glob( search_path )
|
|
|
|
if found_files.size == 1
|
|
found = true
|
|
guid_filename = found_files[0]
|
|
|
|
$search_guid_paths[base_guid_name] = guid_filename
|
|
break
|
|
elsif found_files.size > 1
|
|
ambiguous = true
|
|
break
|
|
end
|
|
end
|
|
}
|
|
|
|
if found == false
|
|
|
|
if ambiguous == true
|
|
RageGen2010SolutionLoader.log.debug("Ambiguous project! Multiple objects found; unable to resolve without a more precise path for project: #{lib}!")
|
|
print "Multiple GUID files have been found with the same name #{lib}.guid. Unable to proceed!\n"
|
|
else
|
|
RageGen2010SolutionLoader.log.debug("Unable to find any file for the library: #{lib}!")
|
|
print "Unable to find the library GUID: #{lib}\n"
|
|
|
|
return
|
|
end
|
|
|
|
next
|
|
end
|
|
else
|
|
|
|
lib = OS::Path.remove_extension(lib)
|
|
lib = File.expand_path(lib)
|
|
guid_filename = "#{lib}.guid"
|
|
end
|
|
|
|
guid_filename = OS::Path::make_relative( guid_filename, @working_directory )
|
|
guid = VSProjShared.create_guid(guid_filename, @p4)
|
|
if guid == nil
|
|
RageGen2010SolutionLoader.log.debug("Unable to acquire guid #{guid_filename}!")
|
|
print "Unable to acquire guid #{guid_filename}!\n"
|
|
return
|
|
end
|
|
|
|
guid = guid.strip.upcase
|
|
|
|
child_project = Info::Project.new(lib_name)
|
|
child_project.guid = guid
|
|
child_project.path = OS::Path.get_directory(guid_filename)
|
|
|
|
search_guid = child_project.guid[1..-2]
|
|
|
|
ignore_guids = ENV['IGNORE_GUIDS']
|
|
ignore_guids = ScriptUtility.acquire_variable(path, 'IGNORE_GUIDS') if ignore_guids == nil
|
|
|
|
#Assume that the startup project is dependent on all child projects.
|
|
if ignore_guids == nil or ignore_guids.index(search_guid) == nil then
|
|
|
|
project.dep_guids << child_project.guid
|
|
end
|
|
|
|
platforms.keys.each { |sln_platform|
|
|
targets = platforms[sln_platform]
|
|
|
|
targets.each_pair { |sln_target,proj_cfg|
|
|
|
|
proj_platform, proj_target = VSProjShared.parse_config_name(proj_cfg)
|
|
build_data.add_projectconfig(sln_platform,sln_target,child_project.guid,proj_platform,proj_target)
|
|
}
|
|
}
|
|
|
|
RageGen2010SolutionLoader.log.info("#Adding dependent project #{child_project.guid} #{child_project}")
|
|
build_data.dependent_projects[child_project.guid] = child_project
|
|
}
|
|
end
|
|
}
|
|
|
|
projects << project
|
|
end
|
|
|
|
return true, projects
|
|
end
|
|
end
|
|
|
|
|
|
#===================================================================
|
|
#
|
|
#
|
|
#
|
|
class RageGen2010ProjectLoader < VSProjShared
|
|
|
|
@@log = nil
|
|
|
|
def RageGen2010ProjectLoader.log
|
|
|
|
@@log = Log.new( 'ragegen2010projectloader' ) if @@log == nil
|
|
@@log
|
|
end
|
|
|
|
def initialize()
|
|
|
|
config = Pipeline::Config.instance
|
|
|
|
@p4 = SCM::Perforce.new()
|
|
@p4.port = config.sc_server
|
|
@p4.client = config.sc_workspace
|
|
@p4.user = config.sc_username
|
|
@p4.connect()
|
|
|
|
end
|
|
|
|
def find_files(path, extension, array)
|
|
|
|
#Handle any regular expressions
|
|
found_files = []
|
|
found_files = OS::FindEx::find_files_recurse( path + extension )
|
|
found_files.each do |found_file|
|
|
|
|
array.insert(array.size, found_file)
|
|
end
|
|
end
|
|
|
|
|
|
def process_qa_items(input_path)
|
|
input_dir = File.dirname(input_path)
|
|
|
|
found_files = OS::FindEx::find_files( OS::Path::combine(input_dir, "*.cpp") )
|
|
|
|
if found_files.size > 0
|
|
|
|
qaitems_header_path = OS::Path::combine(input_dir, "qaitems.h")
|
|
qaitems_source_path = OS::Path::combine(input_dir, "qaitems.cpp")
|
|
|
|
edit_in_p4(@p4, qaitems_header_path)
|
|
edit_in_p4(@p4, qaitems_source_path)
|
|
|
|
source_file_path = OS::Path::combine( input_dir, "*.cpp")
|
|
grep_exe = get_egrep_exe_path()
|
|
result = system(grep_exe + ' -h "^QA_ITEM" ' + source_file_path + ' > ' + qaitems_header_path)
|
|
if result == false
|
|
|
|
if File.exists?(qaitems_header_path)
|
|
File.delete(qaitems_header_path)
|
|
end
|
|
|
|
revert_from_p4(@p4, qaitems_header_path)
|
|
return
|
|
end
|
|
|
|
edit_in_p4(@p4, qaitems_header_path)
|
|
|
|
#QA Items have been found, so add qaitems as a tester to regenerate and add to source control.
|
|
@testers = @testers + " qaitems"
|
|
|
|
result = system( grep_exe + ' -s -h "^QA_ITEM_DRAW" ' + qaitems_header_path )
|
|
if result == false
|
|
|
|
if ENV["RAGE_DIR"] != nil
|
|
system('copy' + ENV["RAGE_DIR"] + '\qa\src\unittest\qaitemsdraw.cpp ' + qaitems_source_path)
|
|
end
|
|
|
|
edit_in_p4(@p4, qaitems_source_path)
|
|
return
|
|
end
|
|
|
|
@xdefine_var = @xdefine_var + " QA_ITEMS_DEPEND_ON_SAMPLE_GRCORE"
|
|
end
|
|
end
|
|
|
|
|
|
# DW - I seriously do not understand why this step is required - what does it achieve?
|
|
def create_project_definition_file( directory, project_name, guid, specified_files )
|
|
|
|
project_definition_file_name = OS::Path::combine(directory, "#{project_name}.rsp")
|
|
|
|
project_file = OS::Path::combine(directory, project_name)
|
|
if File.exist?(project_file + ".cpp")
|
|
|
|
project_file_source = project_file + ".cpp"
|
|
duplicate_file = false
|
|
specified_files.each do |file|
|
|
if project_file_source == file
|
|
duplicate_file = true
|
|
break
|
|
end
|
|
end
|
|
|
|
if duplicate_file == false
|
|
specified_files.insert(specified_files.size, project_file_source)
|
|
end
|
|
|
|
elsif File.exist?(project_file + ".c")
|
|
|
|
project_file_source = project_file + ".c"
|
|
duplicate_file = false
|
|
specified_files.each do |file|
|
|
if project_file_source == file
|
|
duplicate_file = true
|
|
break
|
|
end
|
|
end
|
|
|
|
if duplicate_file == false
|
|
specified_files.insert(specified_files.size, project_file_source)
|
|
end
|
|
end
|
|
|
|
#Add all extra files to the list.
|
|
# TODO: Re-evaluate if this is ever necessary.
|
|
if specified_files.size == 0
|
|
specified_files = []
|
|
specified_files = OS::FindEx::find_files( Pipeline::OS::Path::combine(directory, "*.h") ) #/.*[.]h|.*[.]cpp|(.*)[.]c/
|
|
specified_files += OS::FindEx::find_files( Pipeline::OS::Path::combine(directory, "*.cpp") )
|
|
specified_files += OS::FindEx::find_files( Pipeline::OS::Path::combine(directory, "*.c") )
|
|
end
|
|
|
|
file = File.new(project_definition_file_name, 'w')
|
|
|
|
#First line is always the project name
|
|
file.write(project_name + "\n")
|
|
|
|
#Second line is always the guid.
|
|
file.write(guid + "\n")
|
|
|
|
specified_files.each do |found_file|
|
|
|
|
file.write(found_file + "\n")
|
|
end
|
|
|
|
file.close
|
|
return project_definition_file_name
|
|
end
|
|
|
|
# DW - look here modularity!
|
|
# supports import method
|
|
def read_makefile(path)
|
|
#Makefile Variables
|
|
@testers = ScriptUtility.acquire_variable( path, 'TESTERS' )
|
|
@testers = "" if @testers.nil?
|
|
@xdefine_var = ScriptUtility.acquire_variable(path, 'XDEFINE')
|
|
@xdefine_var = "" if @xdefine_var.nil?
|
|
|
|
@custom_var = ScriptUtility.acquire_variable(path, 'CUSTOM')
|
|
@custom_var = "" if @custom_var.nil?
|
|
|
|
@archive = ScriptUtility.acquire_variable(path, 'ARCHIVE')
|
|
#Add the VSI.nul object to the CUSTOM variable if on TESTER_BASE has been determined.
|
|
tester_base = ScriptUtility.acquire_variable(path, 'TESTER_BASE')
|
|
|
|
if @archive == nil
|
|
#Deal with the QA Items
|
|
RageGen2010ProjectLoader.log.info("Deal with the QA Items ? What? speak English!!!!")
|
|
process_qa_items(path)
|
|
end
|
|
|
|
#Acquire a list of all the pertinent environment variables here.
|
|
@xproj_var = ScriptUtility.acquire_variable(path, 'XPROJ')
|
|
@xproj_var = "" if @xproj_var.nil?
|
|
|
|
@xinclude_var = ScriptUtility.acquire_variable(path, 'XINCLUDE')
|
|
@xinclude_var = "" if @xinclude_var.nil?
|
|
|
|
@temp_additional_includes = []
|
|
@temp_additional_includes = @xproj_var.split(" ")
|
|
@temp_additional_includes.concat(@xinclude_var.split(" "))
|
|
|
|
@force_include = ScriptUtility.acquire_variable(path, 'FORCE_INCLUDE')
|
|
@force_include = "" if @force_include.nil?
|
|
|
|
@xbox_title_id = ScriptUtility.acquire_variable(path, 'XBOX_TITLE_ID')
|
|
|
|
@xbox_spa_path = ScriptUtility.acquire_variable(path, 'XBOX_SPA_PATH')
|
|
|
|
@warning_level = ScriptUtility.acquire_variable(path, 'WARNINGS')
|
|
|
|
@parser_files = ScriptUtility.acquire_variable(path, 'PARSE')
|
|
|
|
@output_name_pattern_var = ScriptUtility.acquire_variable(path, 'OUTPUT_NAME_PATTERN')
|
|
|
|
@additional_includes = []
|
|
@temp_additional_includes.each do |include|
|
|
|
|
include = ScriptUtility.find_include_definition( include )
|
|
|
|
found_duplicate = false
|
|
@additional_includes.each do |added_include|
|
|
if include.eql?(added_include) == true
|
|
found_duplicate = true
|
|
break
|
|
end
|
|
end
|
|
|
|
if found_duplicate == false
|
|
|
|
@additional_includes.insert(@additional_includes.size, include)
|
|
end
|
|
end
|
|
end
|
|
|
|
# supports import method
|
|
def determine_tester_templates()
|
|
ENV["TESTERS"] = @testers
|
|
|
|
@tester_array = @testers.split(" ")
|
|
|
|
@process_array = @tester_array
|
|
@process_array << @archive if @archive != nil
|
|
end
|
|
|
|
# supports import method
|
|
def import_template_vcprojs( path, output_format, options )
|
|
projects = []
|
|
|
|
@process_array.each do |process_project|
|
|
|
|
process_project += VSProjShared.get_project_suffix_2010(output_format)
|
|
vcproj = OS::Path::combine(@working_directory, process_project)
|
|
|
|
RageGen2010ProjectLoader.log.info("Importing vcproj #{vcproj} path #{path} output_format #{output_format}")
|
|
result, project = import_project(path, vcproj, output_format, options)
|
|
|
|
projects << project if result == true
|
|
RageGen2010ProjectLoader.log.info("Importing FAILED!!!!!!!!!!!!!!!!!!!") unless result == true
|
|
end
|
|
|
|
projects
|
|
end
|
|
|
|
#==================================================================
|
|
# DW - this is the meat, reads makefile & template .vcproj together
|
|
def import( path, output_format, options )
|
|
|
|
@working_directory = File.dirname(path)
|
|
|
|
# 1. read makefile varibles.
|
|
read_makefile(path)
|
|
|
|
# 2. work out the lst of templates to use
|
|
determine_tester_templates()
|
|
|
|
# 3. import the vcproj projects
|
|
projects = import_template_vcprojs( path, output_format, options )
|
|
|
|
projects
|
|
end
|
|
|
|
# support method for import_project
|
|
def get_selected_template(path, output_name, options)
|
|
selected_template = nil
|
|
if options[:template].nil? == false and File.exist?(options[:template]) == true
|
|
|
|
projbuild_root = Globals::instance().toolsconfig + "/projbuild"
|
|
selected_template = OS::Path::combine(projbuild_root, selected_template)
|
|
else
|
|
|
|
selected_template = ScriptUtility.determine_project_template(path, output_name)
|
|
end
|
|
end
|
|
|
|
# get the template filename, return nil if it doesn't exist
|
|
def get_template_filename( selected_template, output_format )
|
|
|
|
RageGen2010ProjectLoader.log.info("get_template_filename output_format #{output_format}")
|
|
|
|
if File.exists?(selected_template) == false
|
|
|
|
template_filename = selected_template + VSProjShared.get_project_suffix_2010(output_format)
|
|
|
|
RageGen2010ProjectLoader.log.info("template_filename is #{template_filename}")
|
|
|
|
if template_filename.nil?
|
|
RageGen2010ProjectLoader.log.info("templeate filename is nil")
|
|
RageGen2010ProjectLoader.log.error("Unable to properly acquire a template file!")
|
|
return nil
|
|
elsif File.exists?(template_filename) == false
|
|
RageGen2010ProjectLoader.log.info("templeate filename exists #{template_filename}")
|
|
print "Unable to find template file: #{template_filename}.\n"
|
|
RageGen2010ProjectLoader.log.error("Unable to find template file #{template_filename}!")
|
|
return nil
|
|
end
|
|
end
|
|
template_filename
|
|
end
|
|
|
|
|
|
def get_makefile_expanded_files(path)
|
|
expanded_files = [] # A list of all files with their extensions to add to the project
|
|
combined_files_value = ScriptUtility.acquire_variable( path, "FILES" )
|
|
if combined_files_value != nil
|
|
value_files = combined_files_value.split(" ")
|
|
|
|
value_files.each do |value_file|
|
|
|
|
filename = OS::Path::combine(@working_directory, value_file)
|
|
filename = File.expand_path(filename)
|
|
|
|
find_files(filename, ".h", expanded_files)
|
|
find_files(filename, ".c", expanded_files)
|
|
find_files(filename, ".cpp", expanded_files)
|
|
|
|
if File.exist?(filename)
|
|
expanded_files << value_file
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
#Find a list of all header files included in this combined file.
|
|
combined_files_value = ScriptUtility.acquire_variable( path, "HEADONLY" )
|
|
if combined_files_value != nil
|
|
RageGen2010ProjectLoader.log.info("acquired combined_files_value1")
|
|
header_files = combined_files_value.split(" ")
|
|
|
|
header_files.each do |header_file|
|
|
header_file = header_file + ".h"
|
|
expanded_files << header_file
|
|
end
|
|
end
|
|
|
|
combined_files_value = ScriptUtility.acquire_variable( path, "CCODEONLY" )
|
|
if combined_files_value != nil
|
|
|
|
c_files = combined_files_value.split(" ")
|
|
|
|
c_files.each do |c_file|
|
|
c_file = c_file + ".c"
|
|
expanded_files << c_file
|
|
end
|
|
end
|
|
|
|
combined_files_value = ScriptUtility.acquire_variable( path, "CODEONLY" )
|
|
if combined_files_value != nil
|
|
cpp_files = combined_files_value.split(" ")
|
|
|
|
cpp_files.each do |cpp_file|
|
|
|
|
#Ensure we're testing for existence from the correct root.
|
|
full_path_file = OS::Path::combine(output_path, cpp_file)
|
|
full_path_file = File.expand_path(full_path_file)
|
|
|
|
if File.exist?(full_path_file + ".cpp")
|
|
expanded_files << cpp_file + ".cpp"
|
|
elsif File.exist?(full_path_file + ".c")
|
|
expanded_files << cpp_file + ".c"
|
|
else File.exist?(full_path_file)
|
|
expanded_files << cpp_file
|
|
end
|
|
end
|
|
end
|
|
|
|
#Any additional custom files.
|
|
combined_files_value = @custom_var
|
|
if combined_files_value != nil
|
|
expanded_files += combined_files_value.split(" ")
|
|
end
|
|
|
|
#Additional Resource objects.
|
|
combined_files_value = ScriptUtility.acquire_variable( path, "RESOURCES" )
|
|
if combined_files_value != nil
|
|
expanded_files += combined_files_value.split(" ")
|
|
end
|
|
|
|
expanded_files
|
|
end
|
|
|
|
# get embedded shaders and append to the expanded files
|
|
def get_embedded_shaders_and_expanded_files(path,expanded_files)
|
|
#Additional Embedded Shaders.
|
|
embedded_shaders = nil
|
|
combined_files_value = ScriptUtility.acquire_variable( path, "EMBEDDEDSHADERS" )
|
|
if combined_files_value != nil
|
|
embedded_shaders = combined_files_value.split(" ")
|
|
expanded_files += embedded_shaders
|
|
end
|
|
embedded_shaders
|
|
end
|
|
|
|
def create_guid(output_name)
|
|
guid_filename = OS::Path::combine(@working_directory, output_name) + ".guid"
|
|
guid = VSProjShared.create_guid(guid_filename, @p4)
|
|
end
|
|
|
|
def get_guid_and_project_name_and_files( project_definition_file_name, path )
|
|
|
|
#Assume this is a project definition file.
|
|
files = File.readlines(project_definition_file_name)
|
|
project_name = files.delete_at(0).strip
|
|
guid = files.delete_at(0).strip
|
|
|
|
files.collect { |x|
|
|
|
|
x.strip!
|
|
}
|
|
|
|
guid_filename = OS::Path.remove_extension(path) + ".guid"
|
|
|
|
if File.exists?(guid_filename) then
|
|
|
|
guid = File.readlines(guid_filename)[0].upcase
|
|
RageGen2010ProjectLoader.log.info("guid filename #{guid_filename}, guid changed to: #{guid}")
|
|
else
|
|
RageGen2010ProjectLoader.log.info("guid filename #{guid_filename}, doesnt exist")
|
|
end
|
|
return guid, project_name, files
|
|
end
|
|
|
|
CONDITION = "'$(Configuration)|$(Platform)'"
|
|
|
|
def get_output_directory(doc, full_config)
|
|
node = doc.find("//Project/PropertyGroup/OutDir[@Condition=\"#{CONDITION}=='#{full_config}'\"]")
|
|
return node.to_a[0].content.gsub("\\","") if (node and node.to_a and node.to_a[0] and node.to_a[0].content)
|
|
return nil
|
|
end
|
|
|
|
def get_item_definition_group(doc, full_config)
|
|
node = doc.find("//Project/ItemDefinitionGroup[@Condition=\"#{CONDITION}=='#{full_config}'\"]")
|
|
node
|
|
end
|
|
|
|
def get_embedded_lib_var(path, platform)
|
|
@embedded_lib_var = nil
|
|
|
|
case platform
|
|
when :xbox360:
|
|
@embedded_lib_var_name = 'EMBEDDEDLIB_XENON'
|
|
when :ps3:
|
|
@embedded_lib_var_name = 'EMBEDDEDLIB_PSN'
|
|
when :win32
|
|
@embedded_lib_var_name = 'EMBEDDEDLIB_WIN32'
|
|
when :win64
|
|
@embedded_lib_var_name = 'EMBEDDEDLIB_WIN64'
|
|
end
|
|
|
|
@embedded_lib_var = ScriptUtility.acquire_variable(path, @embedded_lib_var_name) if @embedded_lib_var_name.nil?
|
|
@embedded_lib_var = "" if @embedded_lib_var.nil?
|
|
end
|
|
|
|
|
|
def get_ouput_pattern_variables(platform, platform_config)
|
|
output_pattern, output_pattern_pdb = nil, nil
|
|
if @output_name_pattern_var != nil
|
|
|
|
output_pattern_noext = @output_name_pattern_var
|
|
output_pattern_noext = output_pattern_noext.gsub(/PLATFORM_CONFIG/,platform_config) if platform_config != nil
|
|
|
|
output_pattern = ""
|
|
output_pattern_pdb = ""
|
|
|
|
case platform
|
|
when :xbox360:
|
|
output_pattern = output_pattern_noext.gsub(/EXT/,"xex")
|
|
when :ps3:
|
|
output_pattern = output_pattern_noext.gsub(/EXT/,"self")
|
|
when :psp2:
|
|
output_pattern = output_pattern_noext.gsub(/EXT/,"self")
|
|
else
|
|
output_pattern = output_pattern_noext.gsub(/EXT/,"exe")
|
|
end
|
|
|
|
output_pattern_pdb = output_pattern_noext.gsub(/EXT/,"pdb")
|
|
end
|
|
return output_pattern, output_pattern_pdb
|
|
end
|
|
|
|
|
|
def patch_additional_include_directories(node)
|
|
if @xproj_var != nil
|
|
setting = node.find_first("AdditionalIncludeDirectories")
|
|
if setting
|
|
setting.content += ";" + @additional_includes.join(";")
|
|
RageGen2010ProjectLoader.log.info("AdditionalIncludeDirectories => #{setting.content}")
|
|
else
|
|
RageGen2010ProjectLoader.log.error("ERROR ERROR ERROR! - a setting (AdditionalIncludeDirectories) was not found")
|
|
end
|
|
else
|
|
RageGen2010ProjectLoader.log.info("Ignoring AdditionalIncludeDirectories - is this ok?")
|
|
end
|
|
end
|
|
|
|
def patch_force_include_files(node)
|
|
if @force_include != nil
|
|
setting = node.find_first("ForcedIncludeFiles")
|
|
if setting
|
|
setting.content = setting.content.gsub("FORCE_INCLUDE",@force_include)
|
|
RageGen2010ProjectLoader.log.info("ForcedIncludeFiles (#{@force_include}) => #{setting.content}")
|
|
else
|
|
RageGen2010ProjectLoader.log.error("ERROR ERROR ERROR! - a setting was not found")
|
|
end
|
|
else
|
|
RageGen2010ProjectLoader.log.info("Ignoring ForcedIncludeFiles - is this ok?")
|
|
end
|
|
end
|
|
|
|
def patch_preprocessor_definitions(node)
|
|
if @xdefine_var != nil
|
|
setting = node.find_first("PreprocessorDefinitions")
|
|
if setting
|
|
setting.content = setting.content.gsub!("XDEFINE",@xdefine_var)
|
|
RageGen2010ProjectLoader.log.info("PreprocessorDefinitions => #{setting.content}")
|
|
else
|
|
RageGen2010ProjectLoader.log.error("ERROR ERROR ERROR! - a setting (PreprocessorDefinitions) was not found")
|
|
end
|
|
else
|
|
RageGen2010ProjectLoader.log.info("Ignoring PreprocessorDefinitions - is this ok?")
|
|
end
|
|
end
|
|
|
|
def patch_program_database_filename( node, output_name, output_pattern_pdb )
|
|
setting = node.find_first("ProgramDataBaseFileName")
|
|
if setting
|
|
if output_pattern_pdb.nil?
|
|
|
|
setting.content = setting.content.gsub!("OUTPUT_FILE_NAME", output_name)
|
|
setting.content = setting.content.gsub!(template_name, output_name)
|
|
else
|
|
setting.content = output_pattern_pdb
|
|
end
|
|
RageGen2010ProjectLoader.log.info("ProgramDataBaseFileName => #{setting.content}")
|
|
else
|
|
RageGen2010ProjectLoader.log.error("ERROR ERROR ERROR! - a setting (ProgramDataBaseFileName) was not found")
|
|
|
|
end
|
|
end
|
|
|
|
def patch_warning_level( node )
|
|
if @warning_level != nil
|
|
setting = node.find_first("WarningLevel")
|
|
|
|
if setting
|
|
setting.content = @warning_level
|
|
RageGen2010ProjectLoader.log.info("WarningLevel => #{setting.content}")
|
|
else
|
|
RageGen2010ProjectLoader.log.error("ERROR ERROR ERROR! - a setting (WarningLevel) was not found")
|
|
end
|
|
else
|
|
RageGen2010ProjectLoader.log.info("Ignoring warning level - is this ok?")
|
|
end
|
|
end
|
|
|
|
def patch_output_file( node, output_name, output_pattern )
|
|
|
|
setting = node.find_first("OutputFile")
|
|
if (setting)
|
|
if output_pattern.nil?
|
|
setting.content = setting.content.gsub("OUTPUT_FILE_NAME", output_name)
|
|
setting.content = setting.content.gsub(template_name, output_name)
|
|
else
|
|
setting.content = output_pattern
|
|
end
|
|
RageGen2010ProjectLoader.log.info("OutputFile => #{setting.content}")
|
|
else
|
|
RageGen2010ProjectLoader.log.error("ERROR ERROR ERROR! - a setting (OutputFile) was not found")
|
|
end
|
|
end
|
|
|
|
def patch_additional_dependencies( node )
|
|
if @embedded_lib_var != nil
|
|
setting = node.find_first("AdditionalDependencies")
|
|
setting.content = setting.content.gsub(@embedded_lib_var_name, @embedded_lib_var.split(" ").join(";"))
|
|
RageGen2010ProjectLoader.log.info("AdditionalDependencies => #{setting.content}")
|
|
else
|
|
RageGen2010ProjectLoader.log.info("Ignoring AdditionalDependencies - is this ok?")
|
|
end
|
|
end
|
|
|
|
def patch_deployment_files(node)
|
|
setting = node.find_first("DeploymentFiles")
|
|
if setting
|
|
|
|
replaceval = ENV['XBOX_DEPLOYMENT_FILES']
|
|
replaceval = "" if replaceval == nil
|
|
|
|
setting.content = setting.content.gsub("XBOX_DEPLOYMENT_FILES",replaceval)
|
|
RageGen2010ProjectLoader.log.info("DeploymentFiles => #{setting.content}")
|
|
else
|
|
RageGen2010ProjectLoader.log.error("ERROR ERROR ERROR! - a setting (DeploymentFiles) was not found")
|
|
end
|
|
end
|
|
|
|
def patch_imagexex_output_filename( node, output_name, output_pattern )
|
|
# DW - Hrm - its not clear what needs done here
|
|
# if output_pattern.nil?
|
|
# setting = node.find_first("OutputFileName")
|
|
# if setting
|
|
# setting.content = setting.content.gsub("OUTPUT_FILE_NAME", output_name)
|
|
# RageGen2010ProjectLoader.log.info("OutputFileName => #{setting.content}")
|
|
# else
|
|
# RageGen2010ProjectLoader.log.error("ERROR ERROR ERROR! - a setting (OutputFileName) was not found")
|
|
# end
|
|
# else
|
|
# node.attributes["OutputFileName"] = output_pattern
|
|
# end
|
|
end
|
|
|
|
def patch_imagexex_additional_sections(node)
|
|
setting = node.find_first("AdditionalSections")
|
|
if ( setting and @xbox_title_id != nil and @xbox_spa_path != nil )
|
|
setting.content = setting.content.gsub("XboxSpaLinkOpt","#{@xbox_title_id}=#{@xbox_spa_path}")
|
|
RageGen2010ProjectLoader.log.info("AdditionalSections => #{setting.content}")
|
|
else
|
|
RageGen2010ProjectLoader.log.error("ERROR ERROR ERROR! - a setting (AdditionalSections) was not found")
|
|
end
|
|
end
|
|
|
|
def patch_imagexex_title_id(node)
|
|
setting = node.find_first("TitleID")
|
|
if setting and @xbox_title_id != nil
|
|
|
|
#Backwards Compatibility - if the title id does not have 0x prefix in front of it.
|
|
if @xbox_title_id.index("0x") != 0
|
|
setting.content = setting.content.gsub("XboxTitleId", "0x" + @xbox_title_id)
|
|
else
|
|
setting.content = setting.content.gsub("XboxTitleId", @xbox_title_id)
|
|
end
|
|
RageGen2010ProjectLoader.log.info("XboxTitleId => #{setting.content}")
|
|
else
|
|
RageGen2010ProjectLoader.log.info("Ignoring TitleID - is this ok?")
|
|
end
|
|
end
|
|
|
|
def patch_imagexex_project_defaults(node)
|
|
setting = node.find_first("ProjectDefaults")
|
|
if (setting)
|
|
setting.content = setting.content.gsub("XboxImageXexConfig","")
|
|
RageGen2010ProjectLoader.log.info("ProjectDefaults => #{setting.content}")
|
|
end
|
|
end
|
|
|
|
def patch_prebuild_event(node)
|
|
if @parser_files != nil
|
|
|
|
#Add pre-build event attributes
|
|
setting = node.find_first("CommandLine")
|
|
if (setting)
|
|
setting.content = setting.content + "\n" + '$(RS_TOOLSROOT)\\bin\\coding\\python\\parCodeGen.exe ' + @parser_files
|
|
RageGen2010ProjectLoader.log.info("CommandLine => #{setting.content}")
|
|
|
|
setting = node.find_first("Description")
|
|
setting.content = "Executing pre-build steps and generating parser code..."
|
|
|
|
else
|
|
RageGen2010ProjectLoader.log.error("ERROR ERROR ERROR! - a setting (CommandLine) was not found")
|
|
end
|
|
else
|
|
RageGen2010ProjectLoader.log.info("Ignoring parser_files prebuild event - is this ok?")
|
|
end
|
|
end
|
|
|
|
def set_name(doc, project_name)
|
|
doc.root.attributes["Name"] = project_name
|
|
|
|
find_node = doc.find_first("//Project[@Name]")
|
|
RageGen2010ProjectLoader.log.error("Error didn't write the name") if find_node.nil?
|
|
end
|
|
|
|
def set_guid(doc, guid)
|
|
doc.root.attributes["ProjectGUID"] = "{#{guid}}"
|
|
|
|
find_node = doc.find_first("//Project[@ProjectGUID]")
|
|
RageGen2010ProjectLoader.log.error("Error didn't write the ProjectGUID") if find_node.nil?
|
|
end
|
|
|
|
def add_files_to_compile( doc, output_path, files )
|
|
file_node = doc.find_first("//Project")
|
|
|
|
RageGen2010ProjectLoader.log.error("Can't find project root node") unless file_node
|
|
|
|
files.each do |filename|
|
|
|
|
out_path = OS::Path.combine(output_path,filename)
|
|
out_path = File.expand_path(out_path)
|
|
out_path = OS::Path.make_relative(out_path,output_path)
|
|
out_path = OS::Path.dos_format(out_path)
|
|
|
|
item_group = XML::Node.new("ItemGroup")
|
|
|
|
new_node = XML::Node.new("ClCompile")
|
|
new_node["Include"] = out_path
|
|
item_group << new_node
|
|
RageGen2010ProjectLoader.log.info("Adding file #{out_path}")
|
|
|
|
do_some_embedded_shader_stuff_I_cant_yet_understand()
|
|
|
|
file_node << item_group
|
|
end
|
|
end
|
|
|
|
# DW - After modularising this I've discovered what this really does is it 'patches' the vcxproj in it's xml doc and adds files to the project.
|
|
def parse_template_append_details_and_save( doc, project_name, guid, embedded_shaders, expanded_files, selected_template, temporary_filename, path, output_name, files, output_path )
|
|
|
|
set_name(doc, project_name)
|
|
set_guid(doc, guid)
|
|
|
|
RageGen2010ProjectLoader.log.info("parse_template_append_details_and_save")
|
|
|
|
doc.find("/Project/ItemGroup/ProjectConfiguration").each do |config_node|
|
|
|
|
# 1. Get the full config
|
|
full_config = config_node.attributes["Include"]
|
|
RageGen2010ProjectLoader.log.info("Processing configuration #{full_config}")
|
|
|
|
# 2. Get the platform and config
|
|
platform,config = VSProjShared.parse_config_name(full_config)
|
|
platform_config = get_output_directory( doc, full_config )
|
|
next if platform_config.nil?
|
|
RageGen2010ProjectLoader.log.info("platform #{platform} config #{config} platform_config #{platform_config}")
|
|
|
|
# 3. Get embedded lib
|
|
get_embedded_lib_var(path, platform)
|
|
|
|
# 4. Get output pattern
|
|
output_pattern, output_pattern_pdb = get_ouput_pattern_variables(platform, platform_config)
|
|
RageGen2010ProjectLoader.log.info("output_pattern #{output_pattern} output_pattern_pdb #{output_pattern_pdb}")
|
|
|
|
# 5. Get item definition group - the settings for this full_config
|
|
nodes = get_item_definition_group(doc, full_config)
|
|
RageGen2010ProjectLoader.log.error("Cant find the node for #{full_config}" ) if nodes.nil?
|
|
RageGen2010ProjectLoader.log.info("#{nodes.length} #{nodes.class} configuration nodes to process")
|
|
|
|
nodes.each do |section|
|
|
|
|
section.each do |node|
|
|
|
|
RageGen2010ProjectLoader.log.info("Item definition group node found #{node.name}" )
|
|
case node.name
|
|
|
|
when "PreBuildEvent":
|
|
RageGen2010ProjectLoader.log.info("*****patch_prebuild_event*****")
|
|
patch_prebuild_event(node)
|
|
|
|
when "ClCompile": # VS2010
|
|
|
|
patch_additional_include_directories(node)
|
|
patch_force_include_files(node)
|
|
patch_preprocessor_definitions(node)
|
|
patch_program_database_filename(node, output_name,output_pattern_pdb)
|
|
patch_warning_level(node)
|
|
|
|
when "Link": # VS2010
|
|
|
|
patch_output_file(node,output_name,output_pattern)
|
|
patch_additional_dependencies(node)
|
|
|
|
when "ImageXex":
|
|
|
|
patch_imagexex_output_filename(node,output_name,output_pattern)
|
|
patch_imagexex_additional_sections(node)
|
|
patch_imagexex_title_id(node)
|
|
patch_imagexex_project_defaults(node)
|
|
when "Deploy":
|
|
|
|
patch_deployment_files(node)
|
|
|
|
when "text", "PostBuildEvent":
|
|
# deliberately ignored
|
|
else
|
|
RageGen2010ProjectLoader.log.error("Node #{node.name} was not processed. #{node}")
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
# Finally we add the files this project needs to buid
|
|
add_files_to_compile( doc, output_path, files )
|
|
|
|
RageGen2010ProjectLoader.log.info("Saving temporary file to #{temporary_filename}.")
|
|
doc.save(temporary_filename)
|
|
end
|
|
|
|
|
|
# DW : this is commented out until it can be understood.
|
|
def do_some_embedded_shader_stuff_I_cant_yet_understand()
|
|
=begin
|
|
#Add any custom file configurations for this file.
|
|
if embedded_shaders != nil
|
|
|
|
base_filename = File.basename(out_path)
|
|
embedded_shaders.each do |embedded_shader|
|
|
|
|
if base_filename.eql?(embedded_shader) == true
|
|
|
|
embedded_shader = OS::Path::combine(@working_directory, embedded_shader)
|
|
|
|
#For every configuration add a new FileConfiguration
|
|
doc.find("/VisualStudioProject/Configurations/Configuration").each do |config_node|
|
|
|
|
config_name = config_node.attributes["Name"]
|
|
|
|
platform,target = VSProjShared.parse_config_name(config_name)
|
|
|
|
custom_step = Info::FxCustomBuild.new(embedded_shader, out_path, platform)
|
|
custom_step_node = custom_step.create_node()
|
|
|
|
file_configuration_node = XML::Node.new("FileConfiguration")
|
|
file_configuration_node["Name"] = config_name
|
|
file_configuration_node << custom_step_node
|
|
|
|
new_node << file_configuration_node
|
|
end
|
|
end
|
|
end
|
|
else
|
|
|
|
#For all non-standard files, look for a custom object in the projbuild root to use as a template.
|
|
extension = File.extname(filename)
|
|
extension = extension[1...extension.size]
|
|
if extension.eql?("cpp") == false and extension.eql?("c") == false and extension.eql?("h") == false and extension.eql?("nul") == false
|
|
|
|
custom_root = ScriptUtility.get_custom_root()
|
|
custom_path = OS::Path::combine(custom_root, "#{extension}.custom")
|
|
full_path = OS::Path::combine(@working_directory, filename)
|
|
|
|
if File.exist?(custom_path) == true
|
|
|
|
#For every configuration add a new FileConfiguration
|
|
doc.find("/VisualStudioProject/Configurations/Configuration").each do |config_node|
|
|
|
|
config_name = config_node.attributes["Name"]
|
|
file_configuration = CustomBuildStep::get_file_configuration(custom_path, full_path, config_name)
|
|
|
|
next if file_configuration.nil?
|
|
|
|
file_configuration_node = XML::Node.new("FileConfiguration")
|
|
tool_node = XML::Node.new(file_configuration)
|
|
|
|
file_configuration_node["Name"] = config_name
|
|
file_configuration_node << tool_node
|
|
|
|
new_node << file_configuration_node
|
|
end
|
|
end
|
|
end
|
|
end
|
|
=end
|
|
end
|
|
|
|
# import a vcproj
|
|
def import_project(path, output, output_format, options)
|
|
|
|
return false if File.exists?(path) == false
|
|
|
|
RageGen2010ProjectLoader.log.info("Importing #{path}")
|
|
# 0. extract sundry info from params
|
|
version_suffix = VSProjShared.get_project_suffix_2010(output_format)
|
|
output_name = File.basename(output, version_suffix) #Remove the version suffix.
|
|
output_path = OS::Path.get_directory(output)
|
|
|
|
# 1. Get the selected template
|
|
selected_template = get_selected_template(path, output_name, options)
|
|
return true if selected_template.nil? #Defer this to possibly another generator. This is not an error.
|
|
|
|
RageGen2010ProjectLoader.log.info("Trying to import #{path} with ragegen project loader. the selected_template is #{selected_template}")
|
|
|
|
# 2. Get the template filename
|
|
template_filename = get_template_filename( selected_template, output_format )
|
|
return false if template_filename.nil?
|
|
@template_name = File.basename(selected_template)
|
|
|
|
# 3. Get files in the makefile
|
|
expanded_files = get_makefile_expanded_files(path)
|
|
|
|
# 4. Get embedded shaders
|
|
embedded_shaders = get_embedded_shaders_and_expanded_files(path,expanded_files)
|
|
|
|
RageGen2010ProjectLoader.log.info("Checking template: #{template_filename}.")
|
|
|
|
# 5. Load the xml file that is the template vcproj file
|
|
parser = XML::Parser.file(template_filename)
|
|
doc = parser.parse
|
|
|
|
# 6. Check the version
|
|
#Dw - todo support VS2010 properly ... /Project/PropertyGroup/_ProjectFileVersion>10.0.30319.1
|
|
#correct_version = VSProjShared.get_version(output_format)
|
|
#if doc.root.attributes["Version"] != correct_version then
|
|
# RageGen2010ProjectLoader.log.error("Template is not the correct Visual Studio version: #{doc.root.attributes['Version']} not #{correct_version}.")
|
|
# return false
|
|
#end
|
|
|
|
# 7. Get guid
|
|
guid = create_guid(output_name)
|
|
|
|
project_definition_file_name = create_project_definition_file(@working_directory, output_name, guid, expanded_files)
|
|
return false if File.exists?(project_definition_file_name) == false
|
|
RageGen2010ProjectLoader.log.info("Project definition file at: #{project_definition_file_name} exists - it was created - for what reason I don;t know")
|
|
|
|
guid, project_name,files = get_guid_and_project_name_and_files( project_definition_file_name, path )
|
|
File.delete(project_definition_file_name)
|
|
|
|
|
|
# 8. The template is parsed for specific settings then as these settings are read we consider the state of the ragegen2010 calss and write back into the xml doc
|
|
# eventually it is saved and then is reloaded so that it can be loaded as an internal representation of the project. A bit too elaborate for my liking but anyway...
|
|
|
|
temporary_filename = OS::Path.combine(Globals::instance().toolstemp,"temp.vcxproj")
|
|
RageGen2010ProjectLoader.log.info("Filling temporary vcproj #{temporary_filename}.")
|
|
|
|
parse_template_append_details_and_save( doc, project_name, guid, embedded_shaders, expanded_files, selected_template, temporary_filename, path, output_name, files, output_path )
|
|
|
|
# 9. Load / import the temp vcproj - and we now have an internal representation of the rage gen 2010 format.
|
|
|
|
RageGen2010ProjectLoader.log.info("Passing #{temporary_filename} to Visual Studio loader.")
|
|
if output_format == :vs2005
|
|
result, curr_project = VS2005VSProjLoader.new().import(temporary_filename, output_path)
|
|
elsif output_format == :vs2008
|
|
result, curr_project = VS2008VSProjLoader.new().import(temporary_filename, output_path)
|
|
elsif output_format == :vs2010
|
|
result, curr_project = VS2010VSProjLoader.new().import(temporary_filename, output_path)
|
|
end
|
|
|
|
# this is a hack to deal with linker librarys in VS2010.
|
|
=begin
|
|
RageGen2010ProjectLoader.log.info("DW attempting to add to the doc the library dependencies")
|
|
|
|
testers_var = ScriptUtility.acquire_variable(path, 'TESTERS')
|
|
testers_var = "" if testers_var.nil?
|
|
|
|
RageGen2010SolutionLoader.log.info("DW attempting to add to the doc the library dependencies testers_var #{testers_var}")
|
|
|
|
archive = ScriptUtility.acquire_variable(path, 'ARCHIVE')
|
|
testers_var += " " + archive if archive.nil? == false
|
|
|
|
@tester_array = testers_var.split(" ")
|
|
@working_directory = File.dirname(path)
|
|
|
|
build_data = ProjBuildData::instance()
|
|
build_data.reset
|
|
|
|
success = true
|
|
projects = Array.new()
|
|
@tester_array.each do |tester|
|
|
|
|
RageGen2010SolutionLoader.log.info("DW attempting to add to the doc the library dependencies : running tester #{tester}")
|
|
basename = OS::Path.get_basename(tester)
|
|
|
|
libs = ScriptUtility.acquire_expanded_libs(path, basename)
|
|
|
|
RageGen2010SolutionLoader.log.info("libs #{libs.length} #{libs}")
|
|
|
|
Dir.chdir(OS::Path.get_directory(path)) {
|
|
|
|
if libs != nil
|
|
|
|
libs.each { |lib|
|
|
|
|
lib_name = OS::Path.get_basename(lib)
|
|
|
|
lib = OS::Path.normalise(lib)
|
|
guid = nil
|
|
guid_filename = nil
|
|
|
|
|
|
lib = OS::Path.remove_extension(lib)
|
|
lib = File.expand_path(lib)
|
|
guid_filename = "#{lib}.guid"
|
|
|
|
guid_filename = OS::Path::make_relative( guid_filename, @working_directory )
|
|
guid = VSProjShared.create_guid(guid_filename, @p4)
|
|
if guid == nil
|
|
RageGen2010SolutionLoader.log.debug("Unable to acquire guid #{guid_filename}!")
|
|
print "Unable to acquire guid #{guid_filename}!\n"
|
|
return
|
|
end
|
|
|
|
guid = guid.strip.upcase
|
|
|
|
child_project = Info::Project.new(lib_name)
|
|
child_project.guid = guid
|
|
child_project.path = OS::Path.get_directory(guid_filename)
|
|
|
|
search_guid = child_project.guid[1..-2]
|
|
|
|
ignore_guids = ENV['IGNORE_GUIDS']
|
|
ignore_guids = ScriptUtility.acquire_variable(path, 'IGNORE_GUIDS') if ignore_guids == nil
|
|
|
|
#Assume that the startup project is dependent on all child projects.
|
|
if ignore_guids == nil or ignore_guids.index(search_guid) == nil then
|
|
|
|
curr_project.dep_guids << child_project.guid
|
|
end
|
|
|
|
RageGen2010SolutionLoader.log.info("#Adding dependent project #{child_project.guid} #{child_project}")
|
|
build_data.dependent_projects[child_project.guid] = child_project
|
|
|
|
RageGen2010SolutionLoader.log.info("curr_project.config.xml_data #{curr_project.config.xml_data}")
|
|
project_refs_node = XML::Node.new("ProjectReferences")
|
|
project_ref_node = XML::Node.new("ProjectReference")
|
|
project_node = XML::Node.new("Project")
|
|
|
|
project_node.content = "#{child_project.guid}"
|
|
project_ref_node["Include"] = "#{child_project.path}/#{lib_name}_2010.vcxproj"
|
|
project_ref_node << project_node
|
|
|
|
project_refs_node << project_ref_node
|
|
curr_project.config.xml_data << project_refs_node
|
|
RageGen2010SolutionLoader.log.info("curr_project.config.xml_data #{curr_project.config.xml_data}")
|
|
|
|
#curr_project.config.xml_data.find("ProjectReferences/ProjectReference")
|
|
}
|
|
end
|
|
}
|
|
end
|
|
=end
|
|
|
|
return result, curr_project
|
|
end
|
|
end
|
|
|
|
class RageGen2010Generator
|
|
|
|
@@unity_build_filenames = nil # if true filenames that are created have "_unity" in them.
|
|
def set_unity_build_filenames( set )
|
|
@@unity_build_filenames = set
|
|
end
|
|
|
|
def get_unity_build_filenames( )
|
|
@@unity_build_filenames
|
|
end
|
|
|
|
def export( path, project, options = nil )
|
|
|
|
true
|
|
end
|
|
|
|
def import( path, options = nil )
|
|
|
|
return false if options == nil
|
|
|
|
case options[:type]
|
|
|
|
when :solution:
|
|
|
|
loader = RageGen2010SolutionLoader.new()
|
|
return loader.import(path, options[:out_format], options)
|
|
when :project:
|
|
RageGen2010ProjectLoader.log.info("importing a ragegen project")
|
|
loader = RageGen2010ProjectLoader.new()
|
|
return loader.import(path, options[:out_format], options)
|
|
end
|
|
|
|
false
|
|
end
|
|
end
|
|
|
|
end #module ProjBuild
|
|
|
|
end #module Pipeline
|