//
// $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;
}