969 lines
31 KiB
JavaScript
969 lines
31 KiB
JavaScript
//
|
|
// $Id: projectdef.js 590686 2007-10-31 14:49:24Z faridz $
|
|
//
|
|
// projectdef.js - ProjectDef class definition
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Licensed to the Apache Software Foundation (ASF) under one or more
|
|
// contributor license agreements. See the NOTICE file distributed
|
|
// with this work for additional information regarding copyright
|
|
// ownership. The ASF licenses this file to you under the Apache
|
|
// License, Version 2.0 (the "License"); you may not use this file
|
|
// except in compliance with the License. You may obtain a copy of
|
|
// the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
// implied. See the License for the specific language governing
|
|
// permissions and limitations under the License.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
var TristateUseDefault = -2;
|
|
var TristateTrue = -1;
|
|
var TristateFalse = 0;
|
|
|
|
var dte = null;
|
|
var VCProjectEngine = null;
|
|
var ICConvertTool = "ICProjConvert90.exe";
|
|
|
|
// test availability of utility file
|
|
// returns true if utility is available
|
|
// otherwise returns false
|
|
function TestUtil(cmd)
|
|
{
|
|
try
|
|
{
|
|
return (0 == WshShell.Run(cmd + " /?", 0, true));
|
|
}
|
|
catch (e) {}
|
|
|
|
return false;
|
|
}
|
|
|
|
// init VisualStudio objects using specified configuration
|
|
// config - name of configuration (e.g. msvc-7.0)
|
|
// freedte - if undefined or true then free dte inside function
|
|
function InitVSObjects(config, freedte)
|
|
{
|
|
getCompilerOpts(config);
|
|
|
|
try
|
|
{
|
|
dte = WScript.CreateObject("VisualStudio.DTE." + VERSION);
|
|
if (DEVENV == "")
|
|
{
|
|
// use devenv.com executable, if it present
|
|
var comName = dte.FullName.replace(/\.exe$/i, ".com");
|
|
DEVENV = fso.FileExists(comName) ? comName : dte.FullName;
|
|
}
|
|
}
|
|
catch (e) {}
|
|
|
|
if (CONVERT)
|
|
{
|
|
if (ICCCONVERT == "")
|
|
ICCCONVERT = "ICProjConvert90.exe";
|
|
|
|
var ICConvertTool = ICCCONVERT;
|
|
|
|
var arrPath = new Array(ICConvertTool);
|
|
|
|
if (0 > ICConvertTool.indexOf("\\"))
|
|
{
|
|
// no file path specified
|
|
// try to detect the path
|
|
if (null != dte)
|
|
{
|
|
try
|
|
{
|
|
var isettings = dte.GetObject("IntelOptions");
|
|
for (var i = 1; i <= isettings.CompilersCount; ++i)
|
|
{
|
|
var paths = isettings.Compiler(i).ExecutablePath.split(";");
|
|
for (var j = 0; j < paths.length; ++j)
|
|
arrPath.push("\"" + isettings.Evaluate(paths[j]) + "\\" + ICConvertTool + "\"");
|
|
}
|
|
isettings = null;
|
|
}
|
|
catch (e) {}
|
|
}
|
|
}
|
|
|
|
var success = false;
|
|
|
|
for (var i = 0; i < arrPath.length; ++i)
|
|
if (TestUtil(arrPath[i]))
|
|
{
|
|
success = true;
|
|
ICCCONVERT = arrPath[i];
|
|
break;
|
|
}
|
|
|
|
if (!success)
|
|
{
|
|
WScript.StdErr.WriteLine(ICCCONVERT + " conversion utility not found");
|
|
WScript.StdErr.WriteLine("You should check ICCCONVERT configuration variable");
|
|
WScript.Quit(3);
|
|
}
|
|
}
|
|
|
|
if (("undefined" == typeof(freedte) || true == freedte) && (null != dte))
|
|
{
|
|
dte.Quit();
|
|
dte = null;
|
|
}
|
|
|
|
try
|
|
{
|
|
VCProjectEngine = WScript.CreateObject("VisualStudio.VCProjectEngine." + VERSION);
|
|
}
|
|
catch (e)
|
|
{
|
|
WScript.StdErr.WriteLine("Unable to create VCProjectEngine object: " + e.message);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//------------------------------------------------
|
|
// ProjectDef class
|
|
//------------------------------------------------
|
|
|
|
// ProjectDef .ctor
|
|
function ProjectDef(name, type)
|
|
{
|
|
this.Name = name;
|
|
this.Type = type;
|
|
this.SubSystem = typeGeneric == type ? null :
|
|
(typeApplication == type ? subSystemConsole : subSystemWindows);
|
|
this.RTTI = true;
|
|
this.VCProjDir = "%BUILDDIR%";
|
|
this.FilterDefs = new Array();
|
|
this.Defines = null;
|
|
this.Includes = null;
|
|
this.PrepOpts = null
|
|
this.CppOpts = null;
|
|
this.LnkOpts = null;
|
|
this.LibOpts = null;
|
|
this.OutDir = null;
|
|
this.IntDir = null;
|
|
this.Libs = null;
|
|
this.OutFile = null;
|
|
this.CustomBuildFile = null;
|
|
this.CustomBuildDesc = null;
|
|
this.CustomBuildCmd = null;
|
|
this.CustomBuildOut = null;
|
|
this.CustomBuildDeps = null;
|
|
this.PreLinkDesc = null;
|
|
this.PreLinkCmd = null;
|
|
this.PreBuildDesc = null;
|
|
this.PreBuildCmd = null;
|
|
this.PostBuildDesc = null;
|
|
this.PostBuildCmd = null;
|
|
this.VSProject = null;
|
|
this.PrjRefs = new Array();
|
|
this.PrjDeps = new Array();
|
|
}
|
|
|
|
ProjectDef.prototype.clone = projectCloneDef;
|
|
ProjectDef.prototype.createVCProject = projectCreateVCProject;
|
|
ProjectDef.prototype.createProjectDefsFromFolder = projectCreateProjectDefsFromFolder;
|
|
ProjectDef.prototype.createLocaleDefs = projectCreateLocaleDefs;
|
|
ProjectDef.prototype.createTestLocaleDefs = projectCreateTestLocaleDefs;
|
|
ProjectDef.prototype.createTestLocalesDef = projectCreateTestLocalesDef;
|
|
|
|
// returns copy of ProjectDef object
|
|
function projectCloneDef()
|
|
{
|
|
var clone = new ProjectDef(this.Name, this.Type);
|
|
|
|
clone.SubSystem = this.SubSystem;
|
|
clone.RTTI = this.RTTI;
|
|
clone.VCProjDir = this.VCProjDir;
|
|
clone.FilterDefs = this.FilterDefs.concat(new Array());
|
|
clone.Defines = this.Defines;
|
|
clone.Includes = this.Includes;
|
|
clone.PrepOpts = this.PrepOpts;
|
|
clone.CppOpts = this.CppOpts;
|
|
clone.LnkOpts = this.LnkOpts;
|
|
clone.LibOpts = this.LibOpts;
|
|
clone.OutDir = this.OutDir;
|
|
clone.IntDir = this.IntDir;
|
|
clone.Libs = this.Libs;
|
|
clone.OutFile = this.OutFile;
|
|
clone.CustomBuildFile = this.CustomBuildFile;
|
|
clone.CustomBuildDesc = this.CustomBuildDesc;
|
|
clone.CustomBuildCmd = this.CustomBuildCmd;
|
|
clone.CustomBuildOut = this.CustomBuildOut;
|
|
clone.CustomBuildDeps = this.CustomBuildDeps;
|
|
clone.PreLinkDesc = this.PreLinkDesc;
|
|
clone.PreLinkCmd = this.PreLinkCmd;
|
|
clone.PreBuildDesc = this.PreBuildDesc;
|
|
clone.PreBuildCmd = this.PreBuildCmd;
|
|
clone.PostBuildDesc = this.PostBuildDesc;
|
|
clone.PostBuildCmd = this.PostBuildCmd;
|
|
clone.VSProject = this.VSProject;
|
|
clone.PrjRefs = this.PrjRefs.concat(new Array());
|
|
clone.PrjDeps = this.PrjDeps.concat(new Array());
|
|
|
|
return clone;
|
|
}
|
|
|
|
// preprocess defines using info about selected configuration
|
|
// defines - string with compiler defines, separated by ';'
|
|
// the define syntax can contain ?: construction
|
|
// supported conditions: debug, dll, mt
|
|
// i.e. "debug?_RWSTD_DEBUG:_RWSTD_RELEASE"
|
|
// will be replaced to "_RWSTD_DEBUG" in debug configurations
|
|
// and to "_RWSTD_RELEASE" in non-debug configurations
|
|
// confInfo - configuration info object
|
|
function processDefines(defines, confInfo)
|
|
{
|
|
var arr = defines.split(";");
|
|
var res = new Array();
|
|
for (var i = 0; i < arr.length; ++i)
|
|
{
|
|
var str = arr[i];
|
|
var pos1 = str.indexOf("?");
|
|
if (pos1 > 0)
|
|
{
|
|
var pos2 = str.indexOf(":", pos1 + 1);
|
|
if (pos2 < 0)
|
|
pos2 = str.length;
|
|
var s1 = str.substring(0, pos1);
|
|
var s2 = str.substring(pos1 + 1, pos2);
|
|
var s3 = pos2 < str.length ? str.substr(pos2 + 1) : "";
|
|
|
|
switch (s1)
|
|
{
|
|
case "debug":
|
|
str = confInfo.debug ? s2 : s3;
|
|
break;
|
|
case "dll":
|
|
str = confInfo.dll ? s2 : s3;
|
|
break;
|
|
case "mt":
|
|
str = confInfo.mt ? s2 : s3;
|
|
break;
|
|
}
|
|
}
|
|
if (str.length > 0)
|
|
res.push(str);
|
|
}
|
|
return res.join(";");
|
|
}
|
|
|
|
// returns string with list of files in VCFiles of VCFilters collection
|
|
// files - source VCFiles or VCFilters collection
|
|
// delim - delimiter
|
|
function combFiles(files, delim)
|
|
{
|
|
var ret = "";
|
|
for (var i = 1; i <= files.Count; ++i)
|
|
{
|
|
if (ret != "")
|
|
ret += delim;
|
|
ret += files.Item(i).RelativePath;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
// returns string with list of files in VCFilter object
|
|
// filter - source VCFilter object
|
|
// delim - delimiter
|
|
function combFilter(filter, delim)
|
|
{
|
|
var ret = combFiles(filter.Files, delim);
|
|
if (ret != "")
|
|
ret += delim;
|
|
ret += combFilters(filter.Filters, delim);
|
|
return ret;
|
|
}
|
|
|
|
// returns string with list of files in VCFilters collection
|
|
// filters - VCFilters collection
|
|
// delim - delimiter
|
|
function combFilters(filters, delim)
|
|
{
|
|
var ret = "";
|
|
for (var i = 1; i <= filters.Count; ++i)
|
|
{
|
|
if (ret != "")
|
|
ret += delim;
|
|
ret += combFilter(filters.Item(i), delim);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
// assign value to a property if it's exists
|
|
function setProperty(property, value)
|
|
{
|
|
if ("undefined" != typeof(property))
|
|
{
|
|
property = value;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// create VCProject object from ProjectDef
|
|
// engine - VCProjectEngine object
|
|
// report - callback function to report progress
|
|
function projectCreateVCProject(engine, report)
|
|
{
|
|
if (typeof(report) != "undefined" && null != report)
|
|
report(" Creating " + this.Name + "...");
|
|
|
|
var PrjName = removeLeadingDot(this.Name);
|
|
|
|
var prjMacros = cmnMacros.concat();
|
|
prjMacros.push(new Macro("%PRJNAME%", PrjName));
|
|
|
|
var VCProject = engine.CreateProject(this.Name);
|
|
|
|
VCProject.Name = this.Name;
|
|
var PrjDir = ReplaceMacros(this.VCProjDir, prjMacros);
|
|
var PrjFile = PrjDir + "\\" + PrjName + ".vcproj";
|
|
VCProject.ProjectFile = PrjFile;
|
|
VCProject.ProjectGUID = createUUID();
|
|
|
|
VCProject.AddPlatform(PLATFORM);
|
|
|
|
var FixedPrjName = PrjName;
|
|
var dotObj = ".obj";
|
|
|
|
var VC7xWknd = 0 <= PrjName.indexOf(dotObj)
|
|
&& ("7" == VERSION || "7.1" == VERSION);
|
|
|
|
var PostBuildCmd = this.PostBuildCmd;
|
|
|
|
if (VC7xWknd)
|
|
{
|
|
FixedPrjName = FixedPrjName.replace(new RegExp(dotObj, "ig"), "_obj");
|
|
if (null != PostBuildCmd)
|
|
PostBuildCmd += "\r\n";
|
|
else
|
|
PostBuildCmd = "";
|
|
|
|
var srcDir = "$(OutDir)\\" + FixedPrjName;
|
|
var dstDir = "$(OutDir)\\" + PrjName;
|
|
PostBuildCmd += "md \"" + dstDir + "\"\r\n" +
|
|
"copy \"" + srcDir + "\\" + FixedPrjName + dotObj + "\" \"" + dstDir + "\\" + PrjName + dotObj + "\"\r\n" +
|
|
"copy \"" + srcDir + "\\buildlog.htm\" \"" + dstDir + "\"";
|
|
}
|
|
|
|
for (var i = 0; i < confNames.length; ++i)
|
|
VCProject.AddConfiguration(confNames[i]);
|
|
|
|
var OutDir = this.OutDir != null ?
|
|
ReplaceMacros(this.OutDir, prjMacros) : "%CONFIG%";
|
|
var IntDir = this.IntDir != null ?
|
|
ReplaceMacros(this.IntDir, prjMacros) : OutDir + "\\" + FixedPrjName;
|
|
|
|
// add files
|
|
for (var i = 0; i < this.FilterDefs.length; ++i)
|
|
this.FilterDefs[i].createVCFilter(VCProject);
|
|
|
|
prjMacros.push(new Macro("%FILES%", combFiles(VCProject.Files, ";")));
|
|
|
|
var VCCustomFile = null;
|
|
if (null != this.CustomBuildFile)
|
|
VCCustomFile = VCProject.Files(this.CustomBuildFile);
|
|
|
|
// set common configuration settings
|
|
for (var i = 1; i <= VCProject.Configurations.Count; ++i)
|
|
{
|
|
var conf = VCProject.Configurations.Item(i);
|
|
var confInfo = configs.get(conf.ConfigurationName);
|
|
|
|
var cfgMacros = new Array(
|
|
new Macro("%CONFIG%", confInfo.out),
|
|
new Macro("%CFGNAME%", conf.ConfigurationName));
|
|
|
|
conf.CharacterSet = charSetMBCS;
|
|
conf.IntermediateDirectory = ReplaceMacros(IntDir, cfgMacros);
|
|
conf.OutputDirectory = ReplaceMacros(OutDir, cfgMacros);
|
|
conf.ConfigurationType = (typeLibrary != this.Type) ?
|
|
this.Type :
|
|
(confInfo.dll ? typeDynamicLibrary : typeStaticLibrary);
|
|
|
|
var ext = "";
|
|
switch (conf.ConfigurationType)
|
|
{
|
|
case typeApplication:
|
|
ext = ".exe";
|
|
break;
|
|
case typeDynamicLibrary:
|
|
ext = ".dll";
|
|
break;
|
|
case typeStaticLibrary:
|
|
ext = ".lib";
|
|
break;
|
|
}
|
|
cfgMacros.push(new Macro("%EXT%", ext));
|
|
|
|
var allMacros = prjMacros.concat(cfgMacros);
|
|
|
|
var OutFile = this.OutFile != null ?
|
|
ReplaceMacros(this.OutFile, allMacros) :
|
|
"$(OutDir)\\" + PrjName + ext;
|
|
|
|
var IngoreLibs = "";
|
|
if (confInfo.dll)
|
|
{
|
|
IngoreLibs = confInfo.debug ? "msvcprtd.lib" : "msvcprt.lib";
|
|
}
|
|
else
|
|
{
|
|
if (confInfo.mt || NOSTCRT)
|
|
IngoreLibs = confInfo.debug ? "libcpmtd.lib" : "libcpmt.lib";
|
|
else
|
|
IngoreLibs = confInfo.debug ? "libcpd.lib" : "libcp.lib";
|
|
}
|
|
|
|
var compiler = conf.Tools.Item("VCCLCompilerTool");
|
|
if (null != compiler)
|
|
{
|
|
if (null != this.Includes)
|
|
compiler.AdditionalIncludeDirectories =
|
|
ReplaceMacros(this.Includes, allMacros);
|
|
|
|
compiler.AdditionalOptions = CPPFLAGS + " " +
|
|
(null != this.CppOpts ? this.CppOpts : "");
|
|
if (null != this.PrepOpts)
|
|
compiler.GeneratePreprocessedFile = this.PrepOpts;
|
|
compiler.DebugInformationFormat = debugEnabled;
|
|
|
|
if (typeStaticLibrary == conf.ConfigurationType)
|
|
{
|
|
// generate the source pdb in the OutDir
|
|
compiler.ProgramDataBaseFileName = changeFileExt(OutFile, "pdb");
|
|
}
|
|
|
|
compiler.SuppressStartupBanner = true;
|
|
compiler.WarningLevel = warningLevel_3;
|
|
setProperty(compiler.Detect64BitPortabilityProblems, false);
|
|
|
|
if (null != this.Defines)
|
|
compiler.PreprocessorDefinitions = processDefines(this.Defines, confInfo);
|
|
|
|
if (confInfo.debug)
|
|
{
|
|
compiler.Optimization = optimizeDisabled;
|
|
compiler.MinimalRebuild = true;
|
|
//setProperty(compiler.SmallerTypeCheck, true);
|
|
setProperty(compiler.BasicRuntimeChecks, runtimeBasicCheckAll);
|
|
compiler.BufferSecurityCheck = true;
|
|
}
|
|
else
|
|
{
|
|
if (typeApplication == conf.ConfigurationType)
|
|
{
|
|
if (!setProperty(compiler.OptimizeForWindowsApplication, true))
|
|
compiler.AdditionalOptions += " /GA";
|
|
}
|
|
compiler.Optimization = optimizeMaxSpeed;
|
|
compiler.MinimalRebuild = false;
|
|
setProperty(compiler.SmallerTypeCheck, false);
|
|
setProperty(compiler.BasicRuntimeChecks, runtimeBasicCheckNone);
|
|
compiler.BufferSecurityCheck = false;
|
|
}
|
|
|
|
compiler.ExceptionHandling = cppExceptionHandlingYes;
|
|
compiler.RuntimeTypeInfo = this.RTTI;
|
|
|
|
if (confInfo.dll)
|
|
{
|
|
// the singlethreaded dll runtimes are not present
|
|
// always use the multithreaded dll runtime
|
|
compiler.RuntimeLibrary = confInfo.debug ?
|
|
rtMultiThreadedDebugDLL : rtMultiThreadedDLL;
|
|
}
|
|
else
|
|
{
|
|
if (confInfo.mt || NOSTCRT)
|
|
// use multithreaded runtimes
|
|
compiler.RuntimeLibrary = confInfo.debug ?
|
|
rtMultiThreadedDebug : rtMultiThreaded;
|
|
else
|
|
// use singlethreaded runtimes
|
|
compiler.RuntimeLibrary = confInfo.debug ?
|
|
rtSingleThreadedDebug : rtSingleThreaded;
|
|
}
|
|
|
|
compiler.UsePrecompiledHeader = pchNone;
|
|
|
|
if (VC7xWknd)
|
|
compiler.ObjectFile = "$(IntDir)/" + FixedPrjName + dotObj;
|
|
}
|
|
|
|
var linker = conf.Tools.Item("VCLinkerTool");
|
|
if (null != linker)
|
|
{
|
|
linker.AdditionalOptions = LDFLAGS + " " +
|
|
(null != this.LnkOpts ? this.LnkOpts : "");
|
|
|
|
if (null != this.Libs)
|
|
linker.AdditionalDependencies = this.Libs;
|
|
|
|
linker.LinkIncremental = linkIncrementalNo;
|
|
linker.SuppressStartupBanner = true;
|
|
linker.GenerateDebugInformation = true;
|
|
linker.ProgramDatabaseFile = changeFileExt(OutFile, "pdb");
|
|
linker.IgnoreDefaultLibraryNames = IngoreLibs;
|
|
linker.SubSystem = this.SubSystem;
|
|
|
|
if (confInfo.debug)
|
|
{
|
|
linker.OptimizeReferences = optReferencesDefault;
|
|
linker.EnableCOMDATFolding = optFoldingDefault;
|
|
}
|
|
else
|
|
{
|
|
linker.OptimizeReferences = optReferences;
|
|
linker.EnableCOMDATFolding = optFolding;
|
|
}
|
|
|
|
linker.OutputFile = OutFile;
|
|
|
|
if (this.Type != typeApplication)
|
|
linker.ImportLibrary = changeFileExt(linker.OutputFile, "lib");
|
|
}
|
|
|
|
var librarian = conf.Tools.Item("VCLibrarianTool");
|
|
if (null != librarian)
|
|
{
|
|
if (null != this.LibOpts)
|
|
linker.AdditionalOptions = this.LibOpts;
|
|
|
|
librarian.SuppressStartupBanner = true;
|
|
librarian.IgnoreDefaultLibraryNames = IngoreLibs;
|
|
librarian.OutputFile = OutFile;
|
|
}
|
|
|
|
if (null != this.PreLinkCmd)
|
|
{
|
|
var tool = conf.Tools.Item("VCPreLinkEventTool");
|
|
tool.CommandLine = ReplaceMacros(this.PreLinkCmd, allMacros);
|
|
if (null != this.PreLinkDesc)
|
|
tool.Description = ReplaceMacros(this.PreLinkDesc, allMacros);
|
|
}
|
|
|
|
if (null != this.PreBuildCmd)
|
|
{
|
|
var tool = conf.Tools.Item("VCPreBuildEventTool");
|
|
tool.CommandLine = ReplaceMacros(this.PreBuildCmd, allMacros);
|
|
if (null != this.PreBuildDesc)
|
|
tool.Description = ReplaceMacros(this.PreBuildDesc, allMacros);
|
|
}
|
|
|
|
if (null != PostBuildCmd)
|
|
{
|
|
var tool = conf.Tools.Item("VCPostBuildEventTool");
|
|
tool.CommandLine = ReplaceMacros(PostBuildCmd, allMacros);
|
|
if (null != this.PostBuildDesc)
|
|
tool.Description = ReplaceMacros(this.PostBuildDesc, allMacros);
|
|
}
|
|
|
|
if (null != this.CustomBuildCmd)
|
|
{
|
|
var tool = (null == VCCustomFile) ? conf.Tools.Item("VCCustomBuildTool") :
|
|
VCCustomFile.FileConfigurations.Item(conf.ConfigurationName).Tool;
|
|
|
|
var cmd = ReplaceMacros(this.CustomBuildCmd, allMacros);
|
|
if (null != VCCustomFile)
|
|
cmd = cmd.replace(/(%CUSTOMFILE%)/g, VCCustomFile.FullPath);
|
|
tool.CommandLine = cmd;
|
|
tool.Outputs = null != this.CustomBuildOut ?
|
|
ReplaceMacros(this.CustomBuildOut, allMacros) : "";
|
|
if (null != this.PostBuildDesc)
|
|
tool.Description = ReplaceMacros(this.CustomBuildDesc, allMacros);
|
|
if (null != this.CustomBuildDeps)
|
|
tool.AdditionalDependencies = ReplaceMacros(this.CustomBuildDeps, allMacros);
|
|
}
|
|
}
|
|
|
|
if (!fso.FolderExists(PrjDir))
|
|
fso.CreateFolder(PrjDir);
|
|
|
|
VCProject.Save();
|
|
|
|
this.VSProject = VCProject;
|
|
}
|
|
|
|
// create array of ProjectDef objects (one object for each file)
|
|
// startDir - start folder
|
|
// inclFiles - regular expression to define include files
|
|
// exclDirs - regular expression to define exclude folder
|
|
// exclFiles - regular expression to define exclude files
|
|
// shiftOutDir - if true then add subfolder name to the OutDir path
|
|
function projectCreateProjectDefsFromFolder(startDir,
|
|
inclFiles, exclDirs, exclFiles, shiftOutDir)
|
|
{
|
|
var projectDefs = new Array();
|
|
|
|
var folder = fso.GetFolder(ReplaceMacros(startDir, cmnMacros));
|
|
|
|
var enumSubFolders = new Enumerator(folder.SubFolders);
|
|
for (; !enumSubFolders.atEnd(); enumSubFolders.moveNext())
|
|
{
|
|
var subFolder = enumSubFolders.item();
|
|
if (exclDirs.test(subFolder.Name))
|
|
{
|
|
// skip excluded folder
|
|
continue;
|
|
}
|
|
|
|
var newDefs = this.createProjectDefsFromFolder(subFolder.Path,
|
|
inclFiles, exclDirs, exclFiles, shiftOutDir);
|
|
|
|
if (shiftOutDir)
|
|
{
|
|
for (var i = 0; i < newDefs.length; ++i)
|
|
newDefs[i].OutDir += "\\" + subFolder.Name;
|
|
}
|
|
|
|
projectDefs = projectDefs.concat(newDefs);
|
|
}
|
|
|
|
var enumFiles = new Enumerator(folder.Files);
|
|
for (; !enumFiles.atEnd(); enumFiles.moveNext())
|
|
{
|
|
var file = enumFiles.item();
|
|
if (inclFiles.test(file.Name))
|
|
{
|
|
if (exclFiles.test(file.Name)) // we should exclude this file
|
|
continue;
|
|
|
|
var lastPoint = file.Name.lastIndexOf(".");
|
|
var prjName = file.Name.substr(0, lastPoint);
|
|
|
|
var projectDef = this.clone();
|
|
projectDef.Name = prjName;
|
|
projectDef.FilterDefs.push(
|
|
new FilterDef(sourceFilterName, sourceFilterUuid,
|
|
"cpp;c;cxx;s;cc", eFileTypeCppCode, false).
|
|
addFiles(null, new Array(file.Path)));
|
|
|
|
projectDefs.push(projectDef);
|
|
}
|
|
}
|
|
|
|
return projectDefs;
|
|
}
|
|
|
|
//------------------------------------------------
|
|
// Locale class
|
|
//------------------------------------------------
|
|
|
|
// Locale .ctor
|
|
function Locale(name, cmname, srcname)
|
|
{
|
|
this.Name = name;
|
|
this.cmName = cmname;
|
|
this.srcName = srcname;
|
|
}
|
|
|
|
// returns array of Locale objects parsing the gen_list file
|
|
// nlsDir - folder containing file "gen_list"
|
|
function initLocalesList(nlsDir)
|
|
{
|
|
var listFileName = nlsDir + "\\gen_list";
|
|
if (!fso.FileExists(listFileName))
|
|
{
|
|
WScript.StdErr.WriteLine("Generate: Fatal error: "
|
|
+ "File "+ listFileName + " does not exist");
|
|
WScript.Quit(3);
|
|
}
|
|
|
|
var ForReading = 1;
|
|
var stream = fso.OpenTextFile(listFileName, ForReading);
|
|
if (!stream)
|
|
{
|
|
WScript.StdErr.WriteLine("Generate: Fatal error: "
|
|
+ "Cannot open file "+ listFileName);
|
|
WScript.Quit(3);
|
|
}
|
|
|
|
var arrLocales = new Array();
|
|
|
|
while (!stream.AtEndOfStream)
|
|
{
|
|
var line = stream.ReadLine();
|
|
|
|
var name = line.replace(new RegExp("^\([^ ]*\) *\([^ ]*\)"),
|
|
"$1\.$2")
|
|
.replace(new RegExp("\([^.]*\)\(.euro\)\([^ ]*\)"),
|
|
"$1$3@euro")
|
|
.replace(new RegExp("\([^.]*\)\(.cyrillic\)\([^ ]*\)"),
|
|
"$1$3@cyrillic");
|
|
var pos = name.indexOf(" ");
|
|
if (0 <= pos)
|
|
name = name.substr(0, pos);
|
|
|
|
var srcname = name.replace(new RegExp("\([^.]*\)\.\([^@]*\)\(.*\)"),
|
|
"$1$3")
|
|
.replace("@", ".");
|
|
|
|
var cmname = name.replace(new RegExp("\([^.]*\)\.\([^@]*\)\(.*\)"),
|
|
"$2");
|
|
|
|
arrLocales.push(new Locale(name, cmname, srcname));
|
|
}
|
|
|
|
return arrLocales;
|
|
}
|
|
|
|
// create array of ProjectDef objects for build locales
|
|
// (one object for each locale)
|
|
// nlsDir - folder containing locale source files
|
|
function projectCreateLocaleDefs(nlsDir)
|
|
{
|
|
nlsDir = ReplaceMacros(nlsDir, cmnMacros);
|
|
|
|
if (typeof(this.arrLocales) == "undefined")
|
|
ProjectDef.prototype.arrLocales = initLocalesList(nlsDir);
|
|
|
|
var projectDefs = new Array();
|
|
|
|
for (var i = 0; i < this.arrLocales.length; ++i)
|
|
{
|
|
var locale = this.arrLocales[i];
|
|
|
|
srcFileName = nlsDir + "\\src\\" + locale.srcName;
|
|
cmFileName = nlsDir + "\\charmaps\\" + locale.cmName;
|
|
|
|
var cmFile;
|
|
var srcFile;
|
|
|
|
try
|
|
{
|
|
cmFile = fso.GetFile(cmFileName);
|
|
}
|
|
catch (e)
|
|
{
|
|
WScript.StdErr.WriteLine("Generate: Fatal error: File " +
|
|
cmFileName + " not found");
|
|
WScript.Quit(3);
|
|
}
|
|
|
|
try
|
|
{
|
|
srcFile = fso.GetFile(srcFileName);
|
|
}
|
|
catch (e)
|
|
{
|
|
WScript.StdErr.WriteLine("Generate: Fatal error: File " +
|
|
srcFileName + " not found");
|
|
WScript.Quit(3);
|
|
}
|
|
|
|
var projectDef = this.clone();
|
|
projectDef.Name = locale.Name;
|
|
projectDef.FilterDefs.push(
|
|
new FilterDef("Charmap", null, "cm", eFileTypeText, false).
|
|
addFiles(null, new Array(cmFile.Path)));
|
|
projectDef.FilterDefs.push(
|
|
new FilterDef("Src", null, "", eFileTypeText, false).
|
|
addFiles(null, new Array(srcFile.Path)));
|
|
projectDef.CustomBuildCmd =
|
|
"set PATH=$(SolutionDir)%CONFIG%\\lib;%PATH%\r\n" +
|
|
"\"$(SolutionDir)%CONFIG%\\bin\\localedef.exe\" -w -c" +
|
|
" -f \"" + cmFileName + "\"" + " -i \"" + srcFileName + "\"" +
|
|
" \"$(OutDir)\\" + locale.Name + "\"";
|
|
projectDef.CustomBuildOut = "$(OutDir)\\" + locale.Name;
|
|
|
|
projectDefs.push(projectDef);
|
|
}
|
|
|
|
return projectDefs;
|
|
}
|
|
|
|
// create array of ProjectDef objects for test locales
|
|
// (one object for each locale)
|
|
// nlsDir - folder containing locale source files
|
|
function projectCreateTestLocaleDefs(nlsDir)
|
|
{
|
|
nlsDir = ReplaceMacros(nlsDir, cmnMacros);
|
|
|
|
if (typeof(this.arrLocales) == "undefined")
|
|
ProjectDef.prototype.arrLocales = initLocalesList(nlsDir);
|
|
|
|
var projectDefs = new Array();
|
|
|
|
var srcdir = "%SRCDIR%\\etc\\config\\windows";
|
|
var bindir = "$(SolutionDir)%CONFIG%\\bin";
|
|
var exec = bindir + "\\exec.exe";
|
|
var test = bindir + "\\sanity_test";
|
|
|
|
var setPath = "set PATH=$(SolutionDir)%CONFIG%\\lib;%PATH%";
|
|
|
|
// create test_locale_sanity project
|
|
var sanityDef = this.clone();
|
|
sanityDef.Name = "test_locale_sanity";
|
|
if (null == sanityDef.PreBuildCmd)
|
|
sanityDef.PreBuildCmd = "";
|
|
else
|
|
sanityDef.PreBuildCmd += "\r\n";
|
|
sanityDef.PreBuildCmd +=
|
|
"echo cscript /nologo \"" + srcdir + "\\run_locale_utils.wsf\"" +
|
|
" /s /b:\"" + bindir + "\" > \"" + test + ".bat\"";
|
|
sanityDef.CustomBuildCmd = setPath + "\r\n\"" + exec + "\" -t " + EXEC_TIMEOUT + " \"" + test + ".bat\"";
|
|
sanityDef.CustomBuildOut = test + ".out";
|
|
projectDefs.push(sanityDef);
|
|
|
|
for (var i = 0; i < this.arrLocales.length; ++i)
|
|
{
|
|
var locale = this.arrLocales[i];
|
|
srcFileName = nlsDir + "\\src\\" + locale.srcName;
|
|
cmFileName = nlsDir + "\\charmaps\\" + locale.cmName;
|
|
|
|
var cmFile;
|
|
var srcFile;
|
|
|
|
try
|
|
{
|
|
cmFile = fso.GetFile(cmFileName);
|
|
}
|
|
catch (e)
|
|
{
|
|
WScript.StdErr.WriteLine("Generate: Fatal error: File " +
|
|
cmFileName + " not found");
|
|
WScript.Quit(3);
|
|
}
|
|
|
|
try
|
|
{
|
|
srcFile = fso.GetFile(srcFileName);
|
|
}
|
|
catch (e)
|
|
{
|
|
WScript.StdErr.WriteLine("Generate: Fatal error: File " +
|
|
srcFileName + " not found");
|
|
WScript.Quit(3);
|
|
}
|
|
|
|
test = bindir + "\\" + locale.Name;
|
|
|
|
var projectDef = this.clone();
|
|
projectDef.Name = "test_" + locale.Name;
|
|
projectDef.FilterDefs.push(
|
|
new FilterDef("Charmap", null, "cm", eFileTypeText, false).
|
|
addFiles(null, new Array(cmFile.Path)));
|
|
projectDef.FilterDefs.push(
|
|
new FilterDef("Src", null, "", eFileTypeText, false).
|
|
addFiles(null, new Array(srcFile.Path)));
|
|
if (null == projectDef.PreBuildCmd)
|
|
projectDef.PreBuildCmd = "";
|
|
else
|
|
projectDef.PreBuildCmd += "\r\n";
|
|
projectDef.PreBuildCmd +=
|
|
"echo cscript /nologo \"" + srcdir + "\\run_locale_utils.wsf\"" +
|
|
" /f /b:\"" + bindir + "\" /i:\"" + nlsDir + "\"" +
|
|
" /l:" + locale.Name + " > \"" + test + ".bat\"";
|
|
projectDef.CustomBuildCmd = setPath + "\r\n\"" + exec + "\" -t " + EXEC_TIMEOUT + " \"" + test + ".bat\"";
|
|
projectDef.CustomBuildOut = test + ".out";
|
|
projectDef.PrjDeps.push(sanityDef);
|
|
|
|
projectDefs.push(projectDef);
|
|
}
|
|
|
|
return projectDefs;
|
|
}
|
|
|
|
// create ProjectDef object for test all locales
|
|
// nlsDir - folder containing locale source files
|
|
function projectCreateTestLocalesDef(nlsDir)
|
|
{
|
|
nlsDir = ReplaceMacros(nlsDir, cmnMacros);
|
|
|
|
if (typeof(this.arrLocales) == "undefined")
|
|
ProjectDef.prototype.arrLocales = initLocalesList(nlsDir);
|
|
|
|
var bindir = "$(SolutionDir)%CONFIG%\\bin";
|
|
var test = "sanity_test";
|
|
|
|
// create test_locale_sanity project
|
|
var projectDef = this.clone();
|
|
if (null == projectDef.PreBuildCmd)
|
|
{
|
|
projectDef.PreBuildCmd =
|
|
"set soldir=%BUILDDIR%\r\n" +
|
|
"set bindir=%soldir%\\%CONFIG%\\bin";
|
|
}
|
|
|
|
projectDef.PreBuildCmd += "\r\n" +
|
|
"set etcdir=%SRCDIR%\\etc\r\n" +
|
|
"set util=\"%etcdir%\\config\\windows\\run_locale_utils.wsf\"\r\n";
|
|
|
|
projectDef.PreBuildCmd +=
|
|
"echo cscript /nologo %util% /s /b:\"%bindir%\" > \"%bindir%\\" + test + ".bat\"";
|
|
|
|
var arrLocs = new Array();
|
|
var locales = "";
|
|
|
|
for (var i = 0; i < this.arrLocales.length; ++i)
|
|
{
|
|
var locale = this.arrLocales[i];
|
|
srcFileName = nlsDir + "\\src\\" + locale.srcName;
|
|
cmFileName = nlsDir + "\\charmaps\\" + locale.cmName;
|
|
|
|
var cmFile;
|
|
var srcFile;
|
|
|
|
try
|
|
{
|
|
cmFile = fso.GetFile(cmFileName);
|
|
}
|
|
catch (e)
|
|
{
|
|
WScript.StdErr.WriteLine("Generate: Fatal error: File " +
|
|
cmFileName + " not found");
|
|
WScript.Quit(3);
|
|
}
|
|
|
|
try
|
|
{
|
|
srcFile = fso.GetFile(srcFileName);
|
|
}
|
|
catch (e)
|
|
{
|
|
WScript.StdErr.WriteLine("Generate: Fatal error: File " +
|
|
srcFileName + " not found");
|
|
WScript.Quit(3);
|
|
}
|
|
|
|
if (locales.length + locale.Name.length > 1012)
|
|
{
|
|
arrLocs.push(locales);
|
|
locales = "";
|
|
}
|
|
else
|
|
{
|
|
if (0 < locales.length)
|
|
locales += " ";
|
|
locales += locale.Name;
|
|
}
|
|
}
|
|
|
|
if (0 < locales.length)
|
|
arrLocs.push(locales);
|
|
|
|
for (var i = 0; i < arrLocs.length; ++i)
|
|
{
|
|
projectDef.PreBuildCmd += "\r\nset locales=" + arrLocs[i] + "\r\n" +
|
|
"for %%l in (%locales%) do " +
|
|
"echo cscript /nologo %util% /f /b:\"%bindir%\" " +
|
|
"/i:\"%etcdir%\\nls\" /l:%%l > \"%bindir%\\%%l.bat\"";
|
|
}
|
|
|
|
return projectDef;
|
|
}
|