Example #1
0
        public object Build(
            QtCommon.ThirdPartyModule moduleToBuild,
            out bool success)
        {
            var node = moduleToBuild.OwningNode;
            var data = new QMakeData(node);

            var moduleType = moduleToBuild.GetType();
            var className = moduleType.FullName.Replace(moduleType.Namespace, string.Empty).Trim('.').ToLower();
            data.QtModules.Add(className);

            success = true;
            return data;
        }
Example #2
0
        public object Build(
            QtCommon.MocFile moduleToBuild,
            out System.Boolean success)
        {
            var sourceFilePath = moduleToBuild.SourceFileLocation.GetSinglePath();
            var node = moduleToBuild.OwningNode;

            var data = new QMakeData(node);
            data.PriPaths.Add(this.EmptyConfigPriPath);
            data.Headers.Add(sourceFilePath);
            data.Output = QMakeData.OutputType.MocFile;
            data.MocDir = moduleToBuild.Locations[QtCommon.MocFile.OutputDir];

            success = true;
            return data;
        }
Example #3
0
        public object Build(
            QtCommon.MocFileCollection moduleToBuild,
            out bool success)
        {
            var node = moduleToBuild.OwningNode;
            var data = new QMakeData(node);
            foreach (var child in node.Children)
            {
                var childData = child.Data as QMakeData;
                if (null != childData)
                {
                    data.Merge(childData);
                }
            }

            success = true;
            return data;
        }
Example #4
0
        Merge(
            QMakeData data,
            OutputType excludeType)
        {
            if (0 != (data.Output & excludeType))
            {
                return;
            }

            var baseTargetLHS = (Bam.Core.BaseTarget)(this.OwningNode.Target);
            var baseTargetRHS = (Bam.Core.BaseTarget)(data.OwningNode.Target);

            if (baseTargetLHS != baseTargetRHS)
            {
                throw new Bam.Core.Exception("Cannot merge data from different Bam.Core.BaseTargets: {0} vs {1}", baseTargetLHS.ToString(), baseTargetRHS.ToString());
            }

            this.CCFlags.AddRangeUnique(data.CCFlags);
            foreach (var customPath in data.CustomPathVariables)
            {
                if (this.CustomPathVariables.ContainsKey(customPath.Key))
                {
                    this.CustomPathVariables[customPath.Key].AddRangeUnique(customPath.Value);
                }
                else
                {
                    this.CustomPathVariables[customPath.Key] = new Bam.Core.StringArray(customPath.Value);
                }
            }
            if (null != data.CustomRules)
            {
                if (null == this.CustomRules)
                {
                    this.CustomRules = new Bam.Core.StringArray();
                }
                this.CustomRules.AddRangeUnique(data.CustomRules);
            }
            this.CXXFlags.AddRangeUnique(data.CXXFlags);
            this.Defines.AddRangeUnique(data.Defines);
            if ((null != data.DestDir) && data.DestDir.IsValid)
            {
                this.DestDir = data.DestDir;
            }
            this.Headers.AddRangeUnique(data.Headers);
            this.IncludePaths.AddRangeUnique(data.IncludePaths);
            this.Libraries.AddRangeUnique(data.Libraries);
            if ((null != data.MocDir) && data.MocDir.IsValid)
            {
                this.MocDir = data.MocDir;
            }
            if ((null != data.ObjectsDir) && data.ObjectsDir.IsValid)
            {
                this.ObjectsDir = data.ObjectsDir;
            }
            this.PostLink.AddRangeUnique(data.PostLink);
            this.PriPaths.AddRangeUnique(data.PriPaths);
            this.RPathDir.AddRangeUnique(data.RPathDir);
            this.QtModules.AddRangeUnique(data.QtModules);
            this.Sources.AddRangeUnique(data.Sources);
            this.ObjectiveSources.AddRangeUnique(data.ObjectiveSources);
            if (data.Output != OutputType.Undefined)
            {
                this.Output = data.Output;
            }
            if (this.Target.Length == 0)
            {
                this.Target = data.Target;
            }
            this.WinRCFiles.AddRangeUnique(data.WinRCFiles);

            data.Merged = true;
        }
Example #5
0
 Merge(
     QMakeData data)
 {
     this.Merge(data, OutputType.None);
 }
Example #6
0
        Bam.Core.IBuilderPostExecute.PostExecute(
            Bam.Core.DependencyNodeCollection executedNodes)
        {
            Bam.Core.Log.DebugMessage("PostExecute for QMakeBuilder");

            if (0 == executedNodes.Count)
            {
                Bam.Core.Log.Info("No QMake pro file written as there were no targets generated");
                return;
            }

            // find all nodes with the same unique name
            var similarNodes = new System.Collections.Generic.Dictionary <string, Bam.Core.Array <QMakeData> >();

            foreach (var node in executedNodes)
            {
                if (null == node.Data)
                {
                    Bam.Core.Log.DebugMessage("*** Null data for node {0}", node.UniqueModuleName);
                    continue;
                }

                if (similarNodes.ContainsKey(node.UniqueModuleName))
                {
                    similarNodes[node.UniqueModuleName].Add(node.Data as QMakeData);
                }
                else
                {
                    similarNodes[node.UniqueModuleName] = new Bam.Core.Array <QMakeData>(node.Data as QMakeData);
                }
            }

            foreach (var keyPair in similarNodes)
            {
                Bam.Core.Log.DebugMessage("{0} : {1} nodes", keyPair.Key, keyPair.Value.Count);
                QMakeData.Write(keyPair.Value);
            }

#if false
            var mainPackage   = Bam.Core.State.PackageInfo[0];
            var proFileName   = mainPackage + ".pro";
            var rootDirectory = Bam.Core.State.BuildRoot;
            var proFilePath   = System.IO.Path.Combine(rootDirectory, proFileName);

            // relative paths need a trailing slash to work
            rootDirectory += System.IO.Path.DirectorySeparatorChar;

            using (var proWriter = new System.IO.StreamWriter(proFilePath))
            {
                proWriter.WriteLine("# -- Generated by BuildAMation --");
                proWriter.WriteLine("TEMPLATE = subdirs");
                proWriter.WriteLine("CONFIG += ordered");
                proWriter.WriteLine("SUBDIRS += \\");

                foreach (var collection in similarNodes.Values)
                {
                    var data = collection[0];
                    if (data.ProFilePath != null)
                    {
                        var subDirProjectDir = System.IO.Path.GetDirectoryName(data.ProFilePath) + System.IO.Path.DirectorySeparatorChar;
                        var relativeDir      = Bam.Core.RelativePathUtilities.GetPath(subDirProjectDir, rootDirectory);
                        relativeDir = relativeDir.TrimEnd(System.IO.Path.DirectorySeparatorChar);
                        proWriter.WriteLine("\t{0}\\", relativeDir.Replace('\\', '/'));
                    }
                }
            }

            Bam.Core.Log.Info("Successfully created QMake .pro file for package '{0}'\n\t{1}", Bam.Core.State.PackageInfo[0].Name, proFilePath);
#endif
        }