public static void WriteLog(String LogDir, SessionLogEntry Entry)
{
var LocalTime = Entry.Time.ToLocalTime();
var Dir = FileNameHandling.GetPath(LogDir, LocalTime.Date.ToString("yyyyMMdd"));
if (Dir != "" && !Directory.Exists(Dir))
{
Directory.CreateDirectory(Dir);
}
var Path = FileNameHandling.GetPath(Dir, String.Format("{0}-{1}.log", Entry.RemoteEndPoint.ToString().Replace(".", "_").Replace(":", "_"), Entry.Token));
var e = Encoding.UTF8;
var Lines = GetLines(Entry);
if (File.Exists(Path))
{
e = Txt.GetEncoding(Path, e);
}
using (var r = new StreamWriter(Path, true, e))
{
foreach (var Line in Lines)
{
r.WriteLine(Line);
}
}
}
public static void GenerateCSharp(String InputDirectory, String OutputDirectory)
{
var Files = new Dictionary <String, FileParserResult>();
foreach (var FilePath in Directory.EnumerateFiles(InputDirectory, "*.tree", SearchOption.AllDirectories))
{
var AbsolutePath = FileNameHandling.GetAbsolutePath(FilePath, System.Environment.CurrentDirectory);
var FileContent = Txt.ReadFile(FilePath);
var Text = TokenParser.BuildText(FileContent, AbsolutePath);
var Result = FileParser.ParseFile(Text);
Files.Add(AbsolutePath, Result);
}
foreach (var p in Files)
{
var RelativePath = FileNameHandling.GetRelativePath(p.Key, FileNameHandling.GetAbsolutePath(InputDirectory, System.Environment.CurrentDirectory));
var FileName = FileNameHandling.GetFileName(p.Key);
var ecsg = new EmbeddedCSharpGenerator();
var Content = String.Join("\r\n", ecsg.Generate(p.Value.File).Select(Line => Line.TrimEnd(' ')));
var OutputPath = FileNameHandling.GetPath(FileNameHandling.GetPath(OutputDirectory, FileNameHandling.GetFileDirectory(RelativePath)), FileNameHandling.GetMainFileName(FileName) + ".cs");
var OutputDir = FileNameHandling.GetFileDirectory(OutputPath);
if (!Directory.Exists(OutputDir))
{
Directory.CreateDirectory(OutputDir);
}
WriteToFileIfChanged(OutputPath, Content);
}
}
public static void ObjectSchemaToJavaBinaryCode(String JavaCodeDirPath, String PackageName)
{
var ObjectSchema = GetObjectSchema();
var CompiledFiles = ObjectSchema.CompileToJavaBinary(PackageName);
foreach (var f in CompiledFiles)
{
var FilePath = FileNameHandling.GetPath(JavaCodeDirPath, f.Key.Replace('/', Path.DirectorySeparatorChar));
var Compiled = f.Value;
if (File.Exists(FilePath))
{
var Original = Txt.ReadFile(FilePath);
if (String.Equals(Compiled, Original, StringComparison.Ordinal))
{
continue;
}
}
var Dir = FileNameHandling.GetFileDirectory(FilePath);
if (Dir != "" && !Directory.Exists(Dir))
{
Directory.CreateDirectory(Dir);
}
Txt.WriteFile(FilePath, Compiled);
}
}
public static void TreeToBinary(String TreePath, String BinaryPath, String MainType)
{
var TypeName = ObjectSchemaExtensions.GetDotNetFullNameFromVersionedName(MainType);
var a = SchemaAssembly();
var t = a.GetType(TypeName);
if (t == null)
{
throw new InvalidOperationException("TypeNotExist: " + TypeName);
}
var tbc = TreeBinaryConverter();
var Data = TreeFile.ReadFile(TreePath);
var b = tbc.TreeToBinary(t, Data);
var Dir = FileNameHandling.GetFileDirectory(BinaryPath);
if (Dir != "" && !Directory.Exists(Dir))
{
Directory.CreateDirectory(Dir);
}
using (var s = Streams.CreateWritable(BinaryPath))
{
s.Write(b);
}
}
public static void BinaryToTree(String BinaryPath, String TreePath, String MainType)
{
var TypeName = ObjectSchemaExtensions.GetDotNetFullNameFromVersionedName(MainType);
var a = SchemaAssembly();
var t = a.GetType(TypeName);
if (t == null)
{
throw new InvalidOperationException("TypeNotExist: " + TypeName);
}
var tbc = TreeBinaryConverter();
Byte[] Data;
using (var s = Streams.OpenReadable(BinaryPath))
{
Data = s.Read((int)(s.Length));
}
var x = tbc.BinaryToTree(t, Data);
var Dir = FileNameHandling.GetFileDirectory(TreePath);
if (Dir != "" && !Directory.Exists(Dir))
{
Directory.CreateDirectory(Dir);
}
TreeFile.WriteFile(TreePath, x);
}
public static void SaveData(Schema s, String MemoryDatabaseFile, RelationVal Value, Firefly.Mapping.Binary.BinarySerializer bs)
{
var rvs = new RelationValueSerializer(s);
var Dir = FileNameHandling.GetFileDirectory(MemoryDatabaseFile);
if (Dir != "" && !Directory.Exists(Dir))
{
Directory.CreateDirectory(Dir);
}
using (var fs = Streams.CreateWritable(MemoryDatabaseFile))
{
fs.WriteSimpleString("KRUSDATA", 8);
fs.WriteUInt64(s.Hash());
var SchemaLengthPosition = fs.Position;
fs.WriteInt64(0);
var SchemaPosition = fs.Position;
bs.Write(fs, s);
var SchemaLength = fs.Position - SchemaPosition;
var DataLengthPosition = fs.Position;
fs.WriteInt64(0);
var DataPosition = fs.Position;
rvs.Write(fs, Value);
var DataLength = fs.Position - DataPosition;
fs.Position = SchemaLengthPosition;
fs.WriteInt64(SchemaLength);
fs.Position = DataLengthPosition;
fs.WriteInt64(DataLength);
}
}
public static void ObjectSchemaToXhtml(String XhtmlDir, String Title, String CopyrightText)
{
var oslr = GetObjectSchemaLoaderResult();
var CompiledFiles = oslr.CompileToXhtml(Title, CopyrightText);
foreach (var f in CompiledFiles)
{
var Compiled = f.Content;
var Path = FileNameHandling.GetPath(XhtmlDir, f.Path);
if (File.Exists(Path))
{
var Original = Txt.ReadFile(Path);
if (String.Equals(Compiled, Original, StringComparison.Ordinal))
{
continue;
}
}
var Dir = FileNameHandling.GetFileDirectory(Path);
if (Dir != "" && !Directory.Exists(Dir))
{
Directory.CreateDirectory(Dir);
}
Txt.WriteFile(Path, TextEncoding.UTF8, Compiled);
}
}
public Writer(RelationSchemaLoaderResult rslr, String Title, String CopyrightText)
{
this.Schema = rslr.Schema;
this.Title = Title;
this.CopyrightText = CopyrightText;
TypeInfoDict = new Dictionary <String, TypeInfo>(StringComparer.OrdinalIgnoreCase);
String Root = "";
if (rslr.Positions.Count > 0)
{
Func <String, String, String> GetCommonHead = (a, b) =>
{
var lc = new List <Char>();
var k = 0;
while (true)
{
if (k >= a.Length || k >= b.Length)
{
break;
}
if (a[k] != b[k])
{
break;
}
lc.Add(a[k]);
k += 1;
}
return(new String(lc.ToArray()));
};
Root = rslr.Positions.Select(p => FileNameHandling.GetDirectoryPathWithTailingSeparator(FileNameHandling.GetFileDirectory(p.Value.Text.Path))).Aggregate((a, b) => GetCommonHead(a, b));
if (Root != FileNameHandling.GetDirectoryPathWithTailingSeparator(Root))
{
Root = FileNameHandling.GetFileDirectory(Root);
}
}
var Map = Schema.GetMap().ToDictionary(p => p.Key, p => p.Value);
foreach (var t in Schema.Types)
{
if (t.OnQueryList)
{
continue;
}
var Name = t.Name();
var Path = "Default.tree";
if (rslr.Positions.ContainsKey(t))
{
Path = FileNameHandling.GetRelativePath(rslr.Positions[t].Text.Path, Root);
}
var PathWithoutExt = FileNameHandling.GetPath(FileNameHandling.GetFileDirectory(Path), FileNameHandling.GetMainFileName(Path));
var DocFilePath = PathWithoutExt.Replace(@"\", @"_").Replace(@"/", @"_").Replace(@".", "_").Replace(@":", @"_").Replace(@"#", @"_") + @".html";
var tli = new TypeInfo {
Def = Map[Name], FriendlyPath = PathWithoutExt.Replace(@"\", @"/"), DocFilePath = DocFilePath, DocPath = String.Format("{0}#{1}", DocFilePath, Name)
};
TypeInfoDict.Add(Name, tli);
}
}
private static Func <String, IDbConnection> GetConnectionFactoryMySQL()
{
var Path = FileNameHandling.GetPath(FileNameHandling.GetFileDirectory(Assembly.GetEntryAssembly().Location), "MySql.Data.dll");
var asm = Assembly.Load(AssemblyName.GetAssemblyName(Path));
var t = asm.GetType("MySql.Data.MySqlClient.MySqlConnection");
return(ConnectionString => (IDbConnection)Activator.CreateInstance(t, ConnectionString));
}
public static void DumpSyntaxResult(String InputDirectory, String OutputDirectory)
{
var Files = new Dictionary <String, FileParserResult>();
foreach (var FilePath in Directory.EnumerateFiles(InputDirectory, "*.tree", SearchOption.AllDirectories))
{
var AbsolutePath = FileNameHandling.GetAbsolutePath(FilePath, System.Environment.CurrentDirectory);
var FileContent = Txt.ReadFile(FilePath);
var Text = TokenParser.BuildText(FileContent, AbsolutePath);
var Result = FileParser.ParseFile(Text);
Files.Add(AbsolutePath, Result);
}
//var arr = AmbiguousRemover.Reduce(Files, new List<String> { }, new TypeProvider());
//if (arr.UnresolvableAmbiguousOrErrors.Count > 0)
//{
// var l = new List<String> { };
// foreach (var p in arr.UnresolvableAmbiguousOrErrors)
// {
// var ErrorMessage = p.Key;
// var ErrorRange = p.Value;
// l.Add(p.Key + ": " + ErrorRange.Text.Path + (ErrorRange.Range.OnSome ? ": " + ErrorRange.Range.Value.ToString() : ""));
// }
// var OutputPath = FileNameHandling.GetPath(OutputDirectory, "Error.txt");
// var OutputDir = FileNameHandling.GetFileDirectory(OutputPath);
// if (!Directory.Exists(OutputDir)) { Directory.CreateDirectory(OutputDir); }
// Txt.WriteFile(OutputPath, String.Join("\r\n", l) + "\r\n");
// return;
//}
//Files = arr.Files;
foreach (var p in Files)
{
var RelativePath = FileNameHandling.GetRelativePath(p.Key, FileNameHandling.GetAbsolutePath(InputDirectory, System.Environment.CurrentDirectory));
var FileName = FileNameHandling.GetFileName(p.Key);
var fd = new FileDumper();
var Comment
= "==========================================================================" + "\r\n"
+ "\r\n"
+ " SourceFile: " + FileName + "\r\n"
+ "\r\n"
+ "==========================================================================";
var f = fd.Dump(p.Value, Comment);
var OutputPath = FileNameHandling.GetPath(FileNameHandling.GetPath(OutputDirectory, FileNameHandling.GetFileDirectory(RelativePath)), FileNameHandling.GetMainFileName(FileName) + ".syn.tree");
var OutputDir = FileNameHandling.GetFileDirectory(OutputPath);
if (!Directory.Exists(OutputDir))
{
Directory.CreateDirectory(OutputDir);
}
TreeFile.WriteRaw(OutputPath, f);
}
}
public ReliableFileWriteStream(String FilePath)
{
AbsoluteFilePath = FileNameHandling.GetAbsolutePath(FilePath, System.Environment.CurrentDirectory);
if (File.Exists(AbsoluteFilePath + ".new"))
{
throw new InvalidOperationException("FileExists: {0}".Formats(AbsoluteFilePath + ".new"));
}
if (File.Exists(AbsoluteFilePath))
{
if (File.Exists(AbsoluteFilePath + ".old"))
{
throw new InvalidOperationException("FileExists: {0}".Formats(AbsoluteFilePath + ".old"));
}
}
FileStream = Streams.CreateResizable(AbsoluteFilePath + ".new");
}
public static void ExpressionSchemaToBinary(List <String> DataDirs, String BinaryPath)
{
var ExpressionSchema = GetExpressionSchema();
var eal = new ExpressionAssemblyLoader(ExpressionSchema);
foreach (var DataDir in DataDirs)
{
foreach (var tf in Directory.EnumerateFiles(DataDir, "*.tree", SearchOption.AllDirectories))
{
eal.LoadAssembly(tf);
}
}
var a = eal.GetResult();
var bs = BinarySerializerWithString.Create();
Byte[] Compiled;
using (var ms = Streams.CreateMemoryStream())
{
bs.Write(a, ms);
ms.Position = 0;
Compiled = ms.Read((int)(ms.Length));
}
if (File.Exists(BinaryPath))
{
Byte[] Original;
using (var fs = Streams.OpenReadable(BinaryPath))
{
Original = fs.Read((int)(fs.Length));
}
if (Compiled.SequenceEqual(Original))
{
return;
}
}
var BinaryDir = FileNameHandling.GetFileDirectory(BinaryPath);
if (BinaryDir != "" && !Directory.Exists(BinaryDir))
{
Directory.CreateDirectory(BinaryDir);
}
using (var fs = Streams.CreateWritable(BinaryPath))
{
fs.Write(Compiled);
}
}
public static void ExportCollection(String ConnectionString, String DataDir, List <String> ExportEntityNames)
{
var bs = Niveum.ObjectSchema.BinarySerializerWithString.Create();
var Pair = LoadData(ConnectionString, bs);
var s = Pair.Key;
var Value = Pair.Value;
var Entities = s.Types.Where(t => t.OnEntity).Select(t => t.Entity).ToList();
HashSet <String> ExportEntityNameSet = null;
if (ExportEntityNames.Count != 0)
{
ExportEntityNameSet = new HashSet <String>(ExportEntityNames.Distinct(StringComparer.OrdinalIgnoreCase), StringComparer.OrdinalIgnoreCase);
}
var Dir = FileNameHandling.GetAbsolutePath(DataDir, Environment.CurrentDirectory);
if (Dir != "" && !Directory.Exists(Dir))
{
Directory.CreateDirectory(Dir);
}
var rvts = new RelationValueTreeSerializer(s);
foreach (var p in Entities.ZipStrict(Value.Tables, (a, b) => new KeyValuePair <EntityDef, TableVal>(a, b)))
{
var e = p.Key;
var tv = p.Value;
if ((ExportEntityNameSet == null) || (ExportEntityNameSet.Contains(e.Name)))
{
var l = rvts.WriteTable(e, tv);
var t = RelationValueSyntaxTreeBuilder.BuildTable(e, l);
var TreeFilePath = FileNameHandling.GetPath(DataDir, e.Name + ".tree");
TreeFile.WriteRaw(TreeFilePath, new Syntax.Forest {
MultiNodesList = new List <Syntax.MultiNodes> {
t
}
});
}
}
}
public static void RelationSchemaToCSharpDatabasePlainCode(String CsCodePath, String EntityNamespaceName, Boolean WithFirefly)
{
var RelationSchema = GetRelationSchema();
var Compiled = RelationSchema.CompileToCSharpPlain(EntityNamespaceName, WithFirefly);
if (File.Exists(CsCodePath))
{
var Original = Txt.ReadFile(CsCodePath);
if (String.Equals(Compiled, Original, StringComparison.Ordinal))
{
return;
}
}
var Dir = FileNameHandling.GetFileDirectory(CsCodePath);
if (Dir != "" && !Directory.Exists(Dir))
{
Directory.CreateDirectory(Dir);
}
Txt.WriteFile(CsCodePath, Compiled);
}
public static void ObjectSchemaToCppBinaryCode(String CppCodePath, String NamespaceName, Boolean WithServer, Boolean WithClient)
{
var ObjectSchema = GetObjectSchema();
var Compiled = ObjectSchema.CompileToCppBinary(NamespaceName, WithServer, WithClient);
if (File.Exists(CppCodePath))
{
var Original = Txt.ReadFile(CppCodePath);
if (String.Equals(Compiled, Original, StringComparison.Ordinal))
{
return;
}
}
var Dir = FileNameHandling.GetFileDirectory(CppCodePath);
if (Dir != "" && !Directory.Exists(Dir))
{
Directory.CreateDirectory(Dir);
}
Txt.WriteFile(CppCodePath, Compiled);
}
public static void ObjectSchemaToCSharpVersionCode(String CsCodePath, String NamespaceName, IEnumerable <String> TypeNames)
{
var ObjectSchema = GetObjectSchema();
var Compiled = ObjectSchema.CompileToCSharpVersion(NamespaceName, TypeNames);
if (File.Exists(CsCodePath))
{
var Original = Txt.ReadFile(CsCodePath);
if (String.Equals(Compiled, Original, StringComparison.Ordinal))
{
return;
}
}
var Dir = FileNameHandling.GetFileDirectory(CsCodePath);
if (Dir != "" && !Directory.Exists(Dir))
{
Directory.CreateDirectory(Dir);
}
Txt.WriteFile(CsCodePath, Compiled);
}
public static void ObjectSchemaToPythonBinaryCode(String PythonCodePath)
{
var ObjectSchema = GetObjectSchema();
var Compiled = ObjectSchema.CompileToPythonBinary();
if (File.Exists(PythonCodePath))
{
var Original = Txt.ReadFile(PythonCodePath);
if (String.Equals(Compiled, Original, StringComparison.Ordinal))
{
return;
}
}
var Dir = FileNameHandling.GetFileDirectory(PythonCodePath);
if (Dir != "" && !Directory.Exists(Dir))
{
Directory.CreateDirectory(Dir);
}
Txt.WriteFile(PythonCodePath, Compiled);
}
public static void GenerateSchemaDiff(String MemoryDatabaseFileOld, String MemoryDatabaseFileNew, String SchemaDiffFile)
{
var bs = Niveum.ObjectSchema.BinarySerializerWithString.Create();
var SchemaOld = LoadSchema(MemoryDatabaseFileOld, bs);
var SchemaNew = LoadSchema(MemoryDatabaseFileNew, bs);
var Dir = FileNameHandling.GetFileDirectory(SchemaDiffFile);
if (Dir != "" && !Directory.Exists(Dir))
{
Directory.CreateDirectory(Dir);
}
var d = RelationSchemaDiffGenerator.Generate(SchemaOld, SchemaNew);
RelationSchemaDiffVerifier.Verifiy(SchemaOld, SchemaNew, d.Mappings);
using (var sw = Txt.CreateTextWriter(SchemaDiffFile))
{
RelationSchemaDiffWriter.Write(sw, d);
}
}
public static void ObjectSchemaToCSharpCompatibleCode(String CsCodePath, String NamespaceName, String ImplementationNamespaceName, String ImplementationClassName)
{
var ObjectSchema = GetObjectSchema();
var Compiled = ObjectSchema.CompileToCSharpCompatible(NamespaceName, ImplementationNamespaceName, ImplementationClassName);
if (File.Exists(CsCodePath))
{
var Original = Txt.ReadFile(CsCodePath);
if (String.Equals(Compiled, Original, StringComparison.Ordinal))
{
return;
}
}
var Dir = FileNameHandling.GetFileDirectory(CsCodePath);
if (Dir != "" && !Directory.Exists(Dir))
{
Directory.CreateDirectory(Dir);
}
Txt.WriteFile(CsCodePath, Compiled);
}
public static void RelationSchemaToMySqlCode(String SqlCodePath, String DatabaseName)
{
var RelationSchema = GetRelationSchema();
var Compiled = RelationSchema.CompileToMySql(DatabaseName, true);
if (File.Exists(SqlCodePath))
{
var Original = Txt.ReadFile(SqlCodePath);
if (String.Equals(Compiled, Original, StringComparison.Ordinal))
{
return;
}
}
var SqlCodeDir = FileNameHandling.GetFileDirectory(SqlCodePath);
if (SqlCodeDir != "" && !Directory.Exists(SqlCodeDir))
{
Directory.CreateDirectory(SqlCodeDir);
}
Txt.WriteFile(SqlCodePath, Compiled);
}
public static void RelationSchemaToCppDatabaseMemoryCode(String CppCodePath, String EntityNamespaceName, String ContextNamespaceName)
{
var RelationSchema = GetRelationSchema();
var Compiled = RelationSchema.CompileToCppMemory(EntityNamespaceName, ContextNamespaceName);
if (File.Exists(CppCodePath))
{
var Original = Txt.ReadFile(CppCodePath);
if (String.Equals(Compiled, Original, StringComparison.Ordinal))
{
return;
}
}
var Dir = FileNameHandling.GetFileDirectory(CppCodePath);
if (Dir != "" && !Directory.Exists(Dir))
{
Directory.CreateDirectory(Dir);
}
Txt.WriteFile(CppCodePath, Compiled);
}
public static void ExpressionSchemaToCppBinaryLoaderCode(String CppCodePath, String NamespaceName)
{
var ExpressionSchema = GetExpressionSchema();
var Compiled = ExpressionSchema.CompileToCppBinaryLoader(NamespaceName);
if (File.Exists(CppCodePath))
{
var Original = Txt.ReadFile(CppCodePath);
if (String.Equals(Compiled, Original, StringComparison.Ordinal))
{
return;
}
}
var Dir = FileNameHandling.GetFileDirectory(CppCodePath);
if (Dir != "" && !Directory.Exists(Dir))
{
Directory.CreateDirectory(Dir);
}
Txt.WriteFile(CppCodePath, Compiled);
}
public InstanceInfo(String ConnectionString, IsolationLevel IsolationLevel, int NumPartition)
{
var Fragments = ConnectionString.Split(';');
foreach (var Fragment in Fragments)
{
var Pairs = Fragment.Split('=');
if (Pairs.Length >= 2)
{
if (Pairs[0].Equals("File", StringComparison.OrdinalIgnoreCase))
{
this.FilePath = FileNameHandling.GetAbsolutePath(Pairs[1], System.Environment.CurrentDirectory);
}
else if (Pairs[0].Equals("BackupDir", StringComparison.OrdinalIgnoreCase))
{
this.BackupDir = FileNameHandling.GetAbsolutePath(Pairs[1], System.Environment.CurrentDirectory);
}
else if (Pairs[0].Equals("MaxBackupCount", StringComparison.OrdinalIgnoreCase))
{
this.MaxBackupCount = int.Parse(Pairs[1]);
}
else if (Pairs[0].Equals("BackupInterval", StringComparison.OrdinalIgnoreCase))
{
this.BackupInterval = int.Parse(Pairs[1]);
}
}
}
if (this.FilePath == "")
{
throw new InvalidOperationException("InvalidConnectionString: {0}".Formats(ConnectionString));
}
Data = new KrustallosData(NumPartition);
sbs = Niveum.ObjectSchema.BinarySerializerWithString.Create();
bs = KrustallosSerializer.Create();
using (var da = new KrustallosDataAccess(Instance, Data, IsolationLevel, (ITransactionLock)(null)))
{
Schema = da.Load(sbs, bs, FilePath);
}
}
public static void WriteLog(String Path, String Text)
{
var Dir = FileNameHandling.GetFileDirectory(Path);
if (Dir != "" && !Directory.Exists(Dir))
{
Directory.CreateDirectory(Dir);
}
String[] Lines;
if (!Text.Contains('\n'))
{
Lines = new String[] { Text };
}
else
{
var l = new List <String>();
l.Add("****************");
foreach (var m in Text.UnifyNewLineToLf().Split('\n'))
{
l.Add(m);
}
l.Add("****************");
Lines = l.ToArray();
}
var e = Encoding.UTF8;
if (File.Exists(Path))
{
e = Txt.GetEncoding(Path, e);
}
using (var r = new StreamWriter(Path, true, e))
{
foreach (var Line in Lines)
{
r.WriteLine(Line);
}
}
}
public void Generate(bool EnableRebuild)
{
var PbxprojPath = Path.Combine(OutputDirectory, Path.Combine(Project.Name + ".xcodeproj", "project.pbxproj"));
var BaseDirPath = Path.GetDirectoryName(Path.GetDirectoryName(Path.GetFullPath(PbxprojPath)));
var p = Plist.FromString(PbxprojTemplateText);
var Objects = p.Dict["objects"].Dict;
var RootObjectKey = p.Dict["rootObject"].String;
var RootObject = Objects[RootObjectKey].Dict;
ObjectReferenceValidityTest(Objects, RootObjectKey);
RemoveFiles(Objects, RootObject["mainGroup"].String);
var Targets = RootObject["targets"].Array;
foreach (var TargetKey in Targets)
{
foreach (var PhaseKey in Objects[TargetKey.String].Dict["buildPhases"].Array)
{
var Phase = Objects[PhaseKey.String].Dict;
var Type = Phase["isa"].String;
if (Type == "PBXSourcesBuildPhase")
{
var Files = Phase["files"];
var ToBeRemoved = new HashSet <String>();
foreach (var FileKey in Files.Array)
{
var File = Objects[FileKey.String].Dict;
var FileType = File["isa"].String;
if (FileType == "PBXBuildFile")
{
var FileRef = File["fileRef"].String;
if (!Objects.ContainsKey(FileRef))
{
ToBeRemoved.Add(FileKey.String);
Objects.Remove(FileKey.String);
}
}
}
if (ToBeRemoved.Count > 0)
{
Files.Array = Files.Array.Where(FileKey => !ToBeRemoved.Contains(FileKey.String)).ToList();
}
}
}
}
ObjectReferenceValidityTest(Objects, RootObjectKey);
var RelativePathToObjects = new Dictionary <String, String>();
foreach (var conf in Project.Configurations)
{
foreach (var f in conf.Files)
{
var PathParts = GetPathParts(FileNameHandling.GetRelativePath(f.Path, InputDirectory).Replace('\\', '/'));
PathParts[0] = Path.Combine(FileNameHandling.GetRelativePath(InputDirectory, OutputDirectory), PathParts[0]).Replace('\\', '/');
var RelativePath = String.Join("/", PathParts);
if (RelativePathToObjects.ContainsKey(RelativePath))
{
continue;
}
var Added = AddFile(Objects, RootObject["mainGroup"].String, new LinkedList <String>(), new LinkedList <String>(PathParts), f, BaseDirPath, RelativePathToObjects);
if (!Added)
{
throw new InvalidOperationException();
}
}
}
foreach (var Project in ProjectReferences)
{
var RelativePath = "Frameworks/" + Project.Name;
AddProjectReference(Objects, RootObject["mainGroup"].String, new LinkedList <String>(), new LinkedList <String>(GetPathParts(RelativePath)), Project, BaseDirPath, RelativePathToObjects);
}
foreach (var TargetKey in Targets)
{
var conf = ConfigurationUtils.GetMergedConfiguration(ToolchainType.Mac_XCode, CompilerType.clang, BuildingOperatingSystem, TargetOperatingSystem, null, null, Project.Configurations);
var Target = Objects[TargetKey.String].Dict;
var TargetName = Target["name"].String;
foreach (var PhaseKey in Target["buildPhases"].Array)
{
var Phase = Objects[PhaseKey.String].Dict;
var Type = Phase["isa"].String;
if (Type == "PBXSourcesBuildPhase")
{
var Files = Phase["files"];
foreach (var f in conf.Files)
{
if ((f.Type == FileType.CSource) || (f.Type == FileType.CppSource) || (f.Type == FileType.ObjectiveCSource) || (f.Type == FileType.ObjectiveCppSource))
{
var PathParts = GetPathParts(FileNameHandling.GetRelativePath(f.Path, InputDirectory).Replace('\\', '/'));
PathParts[0] = Path.Combine(FileNameHandling.GetRelativePath(InputDirectory, OutputDirectory), PathParts[0]).Replace('\\', '/');
var RelativePath = String.Join("/", PathParts);
var File = new Dictionary <String, Value>();
File.Add("fileRef", Value.CreateString(RelativePathToObjects[RelativePath]));
File.Add("isa", Value.CreateString("PBXBuildFile"));
var Hash = GetHashOfPath(TargetName + ":" + RelativePath);
Objects.Add(Hash, Value.CreateDict(File));
Files.Array.Add(Value.CreateString(Hash));
}
}
}
else if (Type == "PBXFrameworksBuildPhase")
{
var Files = Phase["files"];
foreach (var Project in ProjectReferences)
{
var RelativePath = "Frameworks/" + Project.Name;
var File = new Dictionary <String, Value>();
File.Add("fileRef", Value.CreateString(RelativePathToObjects[RelativePath]));
File.Add("isa", Value.CreateString("PBXBuildFile"));
var Hash = GetHashOfPath(TargetName + ":" + RelativePath);
Objects.Add(Hash, Value.CreateDict(File));
Files.Array.Add(Value.CreateString(Hash));
}
}
}
Target["name"] = Value.CreateString(Project.Name);
Target["productName"] = Value.CreateString(Project.Name);
var TargetFile = Objects[Target["productReference"].String];
if (conf.TargetType == TargetType.Executable)
{
if (TargetOperatingSystem == OperatingSystemType.Mac)
{
Target["productType"] = Value.CreateString("com.apple.product-type.tool");
}
else if (TargetOperatingSystem == OperatingSystemType.iOS)
{
Target["productType"] = Value.CreateString("com.apple.product-type.application");
}
else
{
throw new NotSupportedException("NotSupportedTargetOperatingSystem: " + TargetOperatingSystem.ToString());
}
TargetFile.Dict["explicitFileType"] = Value.CreateString("compiled.mach-o.executable");
TargetFile.Dict["path"] = Value.CreateString(Project.Name);
}
else if (conf.TargetType == TargetType.StaticLibrary)
{
Target["productType"] = Value.CreateString("com.apple.product-type.library.static");
TargetFile.Dict["explicitFileType"] = Value.CreateString("archive.ar");
TargetFile.Dict["path"] = Value.CreateString("lib" + Project.Name + ".a");
}
else if (conf.TargetType == TargetType.DynamicLibrary)
{
Target["productType"] = Value.CreateString("com.apple.product-type.library.dynamic");
TargetFile.Dict["explicitFileType"] = Value.CreateString("compiled.mach-o.dylib");
TargetFile.Dict["path"] = Value.CreateString("lib" + Project.Name + ".dylib");
}
else
{
throw new NotSupportedException("NotSupportedTargetType: " + conf.TargetType.ToString());
}
}
foreach (var BuildConfigurationKey in Objects[RootObject["buildConfigurationList"].String].Dict["buildConfigurations"].Array)
{
var BuildConfiguration = Objects[BuildConfigurationKey.String].Dict;
var ConfigurationType = (ConfigurationType)(Enum.Parse(typeof(ConfigurationType), BuildConfiguration["name"].String));
var BuildSettings = BuildConfiguration["buildSettings"].Dict;
var conf = ConfigurationUtils.GetMergedConfiguration(ToolchainType.Mac_XCode, CompilerType.clang, BuildingOperatingSystem, TargetOperatingSystem, ConfigurationType, null, Project.Configurations);
var IncludeDirectories = conf.IncludeDirectories.Select(d => FileNameHandling.GetRelativePath(d, BaseDirPath).Replace('\\', '/')).ToList();
if (IncludeDirectories.Count != 0)
{
BuildSettings.SetItem("HEADER_SEARCH_PATHS", Value.CreateArray(IncludeDirectories.Concat(new List <String> {
"$(inherited)"
}).Select(d => Value.CreateString(d)).ToList()));
}
var Defines = conf.Defines;
if (Defines.Count != 0)
{
BuildSettings.SetItem("GCC_PREPROCESSOR_DEFINITIONS", Value.CreateArray(Defines.Select(d => d.Key + (d.Value == null ? "" : "=" + d.Value)).Concat(new List <String> {
"$(inherited)"
}).Select(d => Value.CreateString(d)).ToList()));
}
var CFlags = conf.CFlags;
if (CFlags.Count != 0)
{
BuildSettings.SetItem("OTHER_CFLAGS", Value.CreateArray(CFlags.Concat(new List <String> {
"$(inherited)"
}).Select(d => Value.CreateString(d)).ToList()));
}
var CppFlags = conf.CFlags.Concat(conf.CppFlags).ToList();
if (CppFlags.Count != 0)
{
BuildSettings.SetItem("OTHER_CPLUSPLUSFLAGS", Value.CreateArray(CppFlags.Concat(new List <String> {
"$(inherited)"
}).Select(d => Value.CreateString(d)).ToList()));
}
if ((conf.TargetType == TargetType.Executable) || (conf.TargetType == TargetType.DynamicLibrary))
{
var LibDirectories = conf.LibDirectories.Select(d => FileNameHandling.GetRelativePath(d, BaseDirPath).Replace('\\', '/')).ToList();
if (LibDirectories.Count != 0)
{
BuildSettings.SetItem("LIBRARY_SEARCH_PATHS", Value.CreateArray(LibDirectories.Concat(new List <String> {
"$(inherited)"
}).Select(d => Value.CreateString(d)).ToList()));
}
var LinkerFlags = conf.Libs.Concat(conf.LinkerFlags).ToList();
if (LinkerFlags.Count != 0)
{
BuildSettings.SetItem("OTHER_LDFLAGS", Value.CreateArray(CppFlags.Concat(new List <String> {
"$(inherited)"
}).Select(d => Value.CreateString(d)).ToList()));
}
}
if (TargetOperatingSystem == OperatingSystemType.Mac)
{
BuildSettings.SetItem("SDKROOT", Value.CreateString("macosx"));
}
else if (TargetOperatingSystem == OperatingSystemType.iOS)
{
BuildSettings.SetItem("SDKROOT", Value.CreateString("iphoneos"));
if (conf.TargetType == TargetType.Executable)
{
BuildSettings.SetItem("INFOPLIST_FILE", Value.CreateString(FileNameHandling.GetRelativePath(Path.Combine(InputDirectory, "Info.plist"), BaseDirPath).Replace('\\', '/')));
BuildSettings.SetItem("PRODUCT_BUNDLE_IDENTIFIER", Value.CreateString(conf.BundleIdentifier));
}
}
else
{
throw new NotSupportedException("NotSupportedTargetOperatingSystem: " + TargetOperatingSystem.ToString());
}
}
ObjectReferenceValidityTest(Objects, RootObjectKey);
TextFile.WriteToFile(PbxprojPath, Plist.ToString(p), new UTF8Encoding(false), !EnableRebuild);
}
public void SaveAll()
{
lock (SaveLockee)
{
var InstancesSnapshot = new List <Lazy <InstanceInfo> >();
lock (Instances)
{
InstancesSnapshot = Instances.Values.ToList();
}
foreach (var p in InstancesSnapshot)
{
var i = p.Value;
DateTime Time;
Version Version;
using (var da = new KrustallosDataAccess(i.Instance, i.Data, IsolationLevel.Snapshot, (ITransactionLock)(null)))
{
Version = da.GetReaderVersion();
Time = DateTime.UtcNow;
var Dir = FileNameHandling.GetFileDirectory(i.FilePath);
if (!Directory.Exists(Dir))
{
Directory.CreateDirectory(Dir);
}
using (var s = new ReliableFileWriteStream(i.FilePath))
{
da.Save(i.sbs, i.bs, s, i.Schema);
}
}
if (i.BackupDir != "")
{
if (!Directory.Exists(i.BackupDir))
{
Directory.CreateDirectory(i.BackupDir);
}
var FileName = FileNameHandling.GetFileName(i.FilePath);
var FilePath = FileNameHandling.GetPath(i.BackupDir, FileNameHandling.GetMainFileName(FileName) + Time.ToString("yyyyMMddHHmmss", System.Globalization.CultureInfo.InvariantCulture) + "-" + Version.ToString() + "." + FileNameHandling.GetExtendedFileName(FileName));
if (!File.Exists(FilePath))
{
File.Copy(i.FilePath, FilePath + ".new", true);
File.Move(FilePath + ".new", FilePath);
}
if (i.MaxBackupCount.OnSome)
{
var MaxBackupCount = i.MaxBackupCount.Value;
var FilesToDelete = new List <String>();
var FilePaths = new SortedSet <String>(StringComparer.OrdinalIgnoreCase);
foreach (var f in Directory.EnumerateFiles(i.BackupDir, "*", SearchOption.TopDirectoryOnly))
{
FilePaths.Add(f);
while (FilePaths.Count > MaxBackupCount)
{
var First = FilePaths.First();
FilePaths.Remove(First);
FilesToDelete.Add(First);
}
}
foreach (var f in FilesToDelete)
{
if (File.Exists(f))
{
try
{
File.Delete(f);
}
catch
{
}
}
}
}
}
}
}
}
private void GenerateVcxproj(bool EnableRebuild)
{
var VcxprojPath = Path.Combine(OutputDirectory, Project.Name + ".vcxproj");
var BaseDirPath = Path.GetDirectoryName(Path.GetFullPath(VcxprojPath));
var xVcxproj = XmlFile.FromString(VcxprojTemplateText);
Trim(xVcxproj);
var xn = xVcxproj.Name.Namespace;
foreach (var ig in xVcxproj.Elements(xn + "ItemGroup").ToArray())
{
if (ig.Attribute("Label") != null)
{
continue;
}
var None = ig.Elements().Where(e => e.Name == xn + "None").ToArray();
var ClInclude = ig.Elements().Where(e => e.Name == xn + "ClInclude").ToArray();
var ClCompile = ig.Elements().Where(e => e.Name == xn + "ClCompile").ToArray();
var ProjectReference = ig.Elements().Where(e => e.Name == xn + "ProjectReference").ToArray();
foreach (var e in None)
{
e.Remove();
}
foreach (var e in ClInclude)
{
e.Remove();
}
foreach (var e in ClCompile)
{
e.Remove();
}
foreach (var e in ProjectReference)
{
e.Remove();
}
if (!ig.HasElements && !ig.HasAttributes)
{
ig.Remove();
}
}
var GlobalsPropertyGroup = xVcxproj.Elements(xn + "PropertyGroup").Where(e => e.Attribute("Label") != null && e.Attribute("Label").Value == "Globals").FirstOrDefault();
if (GlobalsPropertyGroup == null)
{
GlobalsPropertyGroup = new XElement(xn + "PropertyGroup", new XAttribute("Label", "Globals"));
xVcxproj.Add(GlobalsPropertyGroup);
}
var g = "{" + ProjectId.ToUpper() + "}";
GlobalsPropertyGroup.SetElementValue(xn + "ProjectGuid", g);
GlobalsPropertyGroup.SetElementValue(xn + "RootNamespace", Project.Name);
var ExistingConfigurationTypeAndArchitectures = new Dictionary <KeyValuePair <ConfigurationType, ArchitectureType>, String>();
var ProjectConfigurations = xVcxproj.Elements(xn + "ItemGroup").Where(e => (e.Attribute("Label") != null) && (e.Attribute("Label").Value == "ProjectConfigurations")).SelectMany(e => e.Elements(xn + "ProjectConfiguration")).Select(e => e.Element(xn + "Configuration").Value + "|" + e.Element(xn + "Platform").Value).ToDictionary(s => s);
foreach (var Architecture in Enum.GetValues(typeof(ArchitectureType)).Cast <ArchitectureType>())
{
foreach (var ConfigurationType in Enum.GetValues(typeof(ConfigurationType)).Cast <ConfigurationType>())
{
var Name = ConfigurationType.ToString() + "|" + GetArchitectureString(Architecture);
if (ProjectConfigurations.ContainsKey(Name))
{
ExistingConfigurationTypeAndArchitectures.Add(new KeyValuePair <ConfigurationType, ArchitectureType>(ConfigurationType, Architecture), Name);
}
}
}
foreach (var Pair in ExistingConfigurationTypeAndArchitectures)
{
var ConfigurationType = Pair.Key.Key;
var Architecture = Pair.Key.Value;
var Name = Pair.Value;
var conf = ConfigurationUtils.GetMergedConfiguration(ToolchainType.Windows_VisualC, CompilerType.VisualC, BuildingOperatingSystem, TargetOperatingSystem, ConfigurationType, Architecture, Project.Configurations);
var PropertyGroup = xVcxproj.Elements(xn + "PropertyGroup").Where(e => (e.Attribute("Condition") != null) && (e.Attribute("Condition").Value == "'$(Configuration)|$(Platform)'=='" + Name + "'")).LastOrDefault();
if (PropertyGroup == null)
{
PropertyGroup = new XElement(xn + "PropertyGroup", new XAttribute("Condition", "'$(Configuration)|$(Platform)'=='" + Name + "'"));
}
if (conf.TargetType == TargetType.Executable)
{
PropertyGroup.SetElementValue(xn + "ConfigurationType", "Application");
}
else if (conf.TargetType == TargetType.StaticLibrary)
{
PropertyGroup.SetElementValue(xn + "ConfigurationType", "StaticLibrary");
}
else if (conf.TargetType == TargetType.DynamicLibrary)
{
PropertyGroup.SetElementValue(xn + "ConfigurationType", "DynamicLibrary");
}
else
{
throw new NotSupportedException("NotSupportedTargetType: " + conf.TargetType.ToString());
}
var ItemDefinitionGroup = xVcxproj.Elements(xn + "ItemDefinitionGroup").Where(e => (e.Attribute("Condition") != null) && (e.Attribute("Condition").Value == "'$(Configuration)|$(Platform)'=='" + Name + "'")).LastOrDefault();
if (ItemDefinitionGroup == null)
{
ItemDefinitionGroup = new XElement(xn + "ItemDefinitionGroup", new XAttribute("Condition", "'$(Configuration)|$(Platform)'=='" + Name + "'"));
xVcxproj.Add(ItemDefinitionGroup);
}
var ClCompile = ItemDefinitionGroup.Element(xn + "ClCompile");
if (ClCompile == null)
{
ClCompile = new XElement(xn + "ClCompile");
ItemDefinitionGroup.Add(ClCompile);
}
var IncludeDirectories = conf.IncludeDirectories.Select(d => FileNameHandling.GetRelativePath(d, BaseDirPath)).ToList();
if (IncludeDirectories.Count != 0)
{
ClCompile.SetElementValue(xn + "AdditionalIncludeDirectories", String.Join(";", IncludeDirectories) + ";%(AdditionalIncludeDirectories)");
}
var Defines = conf.Defines;
if (Defines.Count != 0)
{
ClCompile.SetElementValue(xn + "PreprocessorDefinitions", String.Join(";", Defines.Select(d => d.Key + (d.Value == null ? "" : "=" + (Regex.IsMatch(d.Value, @"^[0-9]+$") ? d.Value : "\"" + d.Value.Replace("\"", "\"\"") + "\"")))) + ";%(PreprocessorDefinitions)");
}
var CompilerFlags = conf.CFlags.Concat(conf.CppFlags).ToList();
if (CompilerFlags.Count != 0)
{
ClCompile.SetElementValue(xn + "AdditionalOptions", "%(AdditionalOptions) " + String.Join(" ", CompilerFlags.Select(f => (f == null ? "" : Regex.IsMatch(f, @"^[0-9]+$") ? f : "\"" + f.Replace("\"", "\"\"") + "\""))));
}
if ((conf.TargetType == TargetType.Executable) || (conf.TargetType == TargetType.DynamicLibrary))
{
var Link = ItemDefinitionGroup.Element(xn + "Link");
if (Link == null)
{
Link = new XElement(xn + "Link");
ItemDefinitionGroup.Add(ClCompile);
}
var LibDirectories = conf.LibDirectories.Select(d => FileNameHandling.GetRelativePath(d, BaseDirPath)).ToList();
if (LibDirectories.Count != 0)
{
Link.SetElementValue(xn + "AdditionalLibraryDirectories", String.Join(";", LibDirectories) + ";%(AdditionalLibraryDirectories)");
}
var Libs = conf.Libs.Concat(ProjectReferences.Select(p => p.Name + ".lib")).ToList();
if (Libs.Count != 0)
{
Link.SetElementValue(xn + "AdditionalDependencies", String.Join(";", Libs) + ";%(AdditionalDependencies)");
}
var LinkerFlags = conf.LinkerFlags.ToList();
if (LinkerFlags.Count != 0)
{
ClCompile.SetElementValue(xn + "AdditionalOptions", "%(AdditionalOptions) " + String.Join(" ", LinkerFlags.Select(f => (f == null ? "" : Regex.IsMatch(f, @"^[0-9]+$") ? f : "\"" + f.Replace("\"", "\"\"") + "\""))));
}
}
}
var Import = xVcxproj.Elements(xn + "Import").LastOrDefault();
foreach (var conf in Project.Configurations)
{
var FileItemGroup = new XElement(xn + "ItemGroup");
if (Import != null)
{
Import.AddBeforeSelf(FileItemGroup);
}
else
{
xVcxproj.Add(FileItemGroup);
}
if ((conf.ConfigurationType != null) || (conf.Architecture != null))
{
var Keys = new List <String> {
};
var Values = new List <String> {
};
if (conf.ConfigurationType != null)
{
Keys.Add("$(Configuration)");
Values.Add(conf.ConfigurationType.ToString());
}
if (conf.Architecture != null)
{
Keys.Add("$(Platform)");
Values.Add(GetArchitectureString(conf.Architecture.Value));
}
var Condition = "'" + String.Join("|", Keys) + "' == '" + String.Join("|", Values) + "'";
FileItemGroup.Add(new XAttribute("Condition", Condition));
}
foreach (var f in conf.Files)
{
var RelativePath = FileNameHandling.GetRelativePath(f.Path, BaseDirPath);
XElement x;
if (f.Type == FileType.Header)
{
x = new XElement(xn + "ClInclude", new XAttribute("Include", RelativePath));
}
else if (f.Type == FileType.CSource)
{
x = new XElement(xn + "ClCompile", new XAttribute("Include", RelativePath));
}
else if (f.Type == FileType.CppSource)
{
x = new XElement(xn + "ClCompile", new XAttribute("Include", RelativePath));
x.Add(new XElement(xn + "ObjectFileName", "$(IntDir)" + RelativePath.Replace("..", "__") + ".obj"));
}
else
{
x = new XElement(xn + "None", new XAttribute("Include", RelativePath));
}
FileItemGroup.Add(x);
}
if (!FileItemGroup.HasElements)
{
FileItemGroup.Remove();
}
}
var ProjectItemGroup = new XElement(xn + "ItemGroup");
if (Import != null)
{
Import.AddBeforeSelf(ProjectItemGroup);
}
else
{
xVcxproj.Add(ProjectItemGroup);
}
foreach (var p in ProjectReferences)
{
var RelativePath = FileNameHandling.GetRelativePath(p.FilePath, BaseDirPath);
var x = new XElement(xn + "ProjectReference", new XAttribute("Include", RelativePath));
x.Add(new XElement(xn + "Project", "{" + p.Id.ToUpper() + "}"));
x.Add(new XElement(xn + "Name", "{" + p.Name + "}"));
ProjectItemGroup.Add(x);
}
if (!ProjectItemGroup.HasElements)
{
ProjectItemGroup.Remove();
}
var sVcxproj = XmlFile.ToString(xVcxproj);
TextFile.WriteToFile(VcxprojPath, sVcxproj, Encoding.UTF8, !EnableRebuild);
}
private void GenerateVcxprojFilters(bool EnableRebuild)
{
var FilterPath = Path.Combine(OutputDirectory, Project.Name + ".vcxproj") + ".filters";
var BaseDirPath = Path.GetDirectoryName(Path.GetFullPath(FilterPath));
var xFilter = XmlFile.FromString(VcxprojFilterTemplateText);
Trim(xFilter);
var xn = xFilter.Name.Namespace;
foreach (var ig in xFilter.Elements(xn + "ItemGroup").ToArray())
{
if (ig.Attribute("Label") != null)
{
continue;
}
var None = ig.Elements().Where(e => e.Name == xn + "None").ToArray();
var ClInclude = ig.Elements().Where(e => e.Name == xn + "ClInclude").ToArray();
var ClCompile = ig.Elements().Where(e => e.Name == xn + "ClCompile").ToArray();
var Filter = ig.Elements().Where(e => e.Name == xn + "Filter").ToArray();
foreach (var e in None)
{
e.Remove();
}
foreach (var e in ClInclude)
{
e.Remove();
}
foreach (var e in ClCompile)
{
e.Remove();
}
foreach (var e in Filter)
{
e.Remove();
}
if (!ig.HasElements && !ig.HasAttributes)
{
ig.Remove();
}
}
var FilterItemGroup = new XElement(xn + "ItemGroup");
var FileItemGroup = new XElement(xn + "ItemGroup");
xFilter.Add(FilterItemGroup);
xFilter.Add(FileItemGroup);
var Files = new HashSet <String>(StringComparer.OrdinalIgnoreCase);
var Filters = new HashSet <String>(StringComparer.OrdinalIgnoreCase);
foreach (var conf in Project.Configurations)
{
foreach (var f in conf.Files)
{
if (Files.Contains(f.Path))
{
continue;
}
Files.Add(f.Path);
var RelativePath = FileNameHandling.GetRelativePath(f.Path, BaseDirPath);
var Dir = Path.GetDirectoryName(FileNameHandling.GetRelativePath(f.Path, InputDirectory)).Replace('/', '\\');
while (Dir.StartsWith(@"..\"))
{
Dir = Dir.Substring(3);
}
if (!Filters.Contains(Dir))
{
var CurrentDir = Dir;
while (CurrentDir != "" && !Filters.Contains(CurrentDir))
{
Filters.Add(CurrentDir);
CurrentDir = Path.GetDirectoryName(CurrentDir);
}
}
XElement x;
if (f.Type == FileType.Header)
{
x = new XElement(xn + "ClInclude", new XAttribute("Include", RelativePath));
}
else if (f.Type == FileType.CSource)
{
x = new XElement(xn + "ClCompile", new XAttribute("Include", RelativePath));
}
else if (f.Type == FileType.CppSource)
{
x = new XElement(xn + "ClCompile", new XAttribute("Include", RelativePath));
}
else
{
x = new XElement(xn + "None", new XAttribute("Include", RelativePath));
}
x.Add(new XElement(xn + "Filter", Dir));
FileItemGroup.Add(x);
}
}
foreach (var f in Filters.OrderBy(ff => ff, StringComparer.OrdinalIgnoreCase))
{
if (f == "")
{
continue;
}
var g = "{" + Guid.NewGuid().ToString().ToUpper() + "}";
FilterItemGroup.Add(new XElement(xn + "Filter", new XAttribute("Include", f), new XElement(xn + "UniqueIdentifier", g)));
}
if (!FilterItemGroup.HasElements)
{
FilterItemGroup.Remove();
}
if (!FileItemGroup.HasElements)
{
FileItemGroup.Remove();
}
var sFilter = XmlFile.ToString(xFilter);
TextFile.WriteToFile(FilterPath, sFilter, Encoding.UTF8, !EnableRebuild);
}
private IEnumerable <String> GenerateLines(String CMakeListsPath, String BaseDirPath)
{
var conf = ConfigurationUtils.GetMergedConfiguration(Toolchain, Compiler, BuildingOperatingSystem, TargetOperatingSystem, null, null, Project.Configurations);
yield return(@"cmake_minimum_required(VERSION 3.0.2)");
yield return($@"project({Project.Name})");
if ((conf.TargetType == TargetType.Executable) || (conf.TargetType == TargetType.DynamicLibrary))
{
var LibDirectories = conf.LibDirectories.Select(d => FileNameHandling.GetRelativePath(d, BaseDirPath).Replace('\\', '/')).ToList();
if (LibDirectories.Count != 0)
{
yield return(@"link_directories(");
foreach (var d in LibDirectories)
{
yield return(" " + (d.Contains(" ") ? "\"" + d + "\"" : d));
}
yield return(@")");
}
}
if (conf.TargetType == TargetType.Executable)
{
yield return(@"add_executable(${PROJECT_NAME} """")");
}
else if (conf.TargetType == TargetType.StaticLibrary)
{
yield return(@"add_library(${PROJECT_NAME} STATIC """")");
}
else if (conf.TargetType == TargetType.DynamicLibrary)
{
yield return(@"add_library(${PROJECT_NAME} SHARED """")");
}
else
{
throw new NotSupportedException("NotSupportedTargetType: " + conf.TargetType.ToString());
}
yield return(@"target_sources(${PROJECT_NAME} PRIVATE");
foreach (var f in conf.Files)
{
if ((f.Type == FileType.CSource) || (f.Type == FileType.CppSource) || (f.Type == FileType.ObjectiveCSource) || (f.Type == FileType.ObjectiveCppSource))
{
yield return(" " + FileNameHandling.GetRelativePath(f.Path, BaseDirPath).Replace('\\', '/'));
}
}
yield return(@")");
foreach (var g in conf.Files.GroupBy(f => Path.GetDirectoryName(f.Path)))
{
var Name = FileNameHandling.GetRelativePath(g.Key, InputDirectory);
yield return($@"source_group({Name.Replace('\\', '/').Replace("/", @"\\")} FILES");
foreach (var f in g)
{
yield return(" " + FileNameHandling.GetRelativePath(f.Path, BaseDirPath).Replace('\\', '/'));
}
yield return(@")");
}
var IncludeDirectories = conf.IncludeDirectories.Select(d => FileNameHandling.GetRelativePath(d, BaseDirPath).Replace('\\', '/')).ToList();
if (IncludeDirectories.Count != 0)
{
yield return(@"target_include_directories(${PROJECT_NAME} PRIVATE");
foreach (var d in IncludeDirectories)
{
yield return(" " + (d.Contains(" ") ? "\"" + d + "\"" : d));
}
yield return(@")");
}
var Defines = conf.Defines;
if (Defines.Count != 0)
{
yield return(@"target_compile_definitions(${PROJECT_NAME} PRIVATE");
foreach (var d in Defines)
{
yield return(@" -D" + d.Key + (d.Value == null ? "" : "=" + (Regex.IsMatch(d.Value, @"["" ^|]") ? "\"" + d.Value.Replace("\"", "\"\"") + "\"" : d.Value)));
}
yield return(@")");
}
var CFlags = conf.CFlags;
var CppFlags = conf.CppFlags;
var CFlagStr = String.Join("", CFlags.Select(f => (f == null ? "" : Regex.IsMatch(f, @"[ ""^|]") ? "\"" + f.Replace("\"", "\"\"") + "\"" : f)));
var CppFlagStr = String.Join("", CppFlags.Select(f => (f == null ? "" : Regex.IsMatch(f, @"[ ""^|]") ? "\"" + f.Replace("\"", "\"\"") + "\"" : f)));
if (CFlags.Count + CppFlags.Count != 0)
{
yield return(@"target_compile_options(${PROJECT_NAME} PRIVATE " + CFlagStr + (CppFlags.Count > 0 ? "$<$<COMPILE_LANGUAGE:CXX>:" + CppFlagStr + ">" : "") + ")");
}
if ((conf.TargetType == TargetType.Executable) || (conf.TargetType == TargetType.DynamicLibrary))
{
var LinkerFlags = conf.LinkerFlags;
if (LinkerFlags.Count != 0)
{
var LinkerFlagStr = String.Join("", CFlags.Select(f => (f == null ? "" : Regex.IsMatch(f, @"[ ""^|]") ? "\"" + f.Replace("\"", "\"\"") + "\"" : f)));
yield return(@"set_target_properties(${PROJECT_NAME} PROPERTIES LINK_FLAGS " + LinkerFlagStr + ")");
}
if (ProjectReferences.Count + conf.Libs.Count > 0)
{
yield return(@"target_link_libraries(${PROJECT_NAME} PRIVATE");
foreach (var p in ProjectReferences)
{
yield return(" " + p.Name);
}
foreach (var lib in conf.Libs)
{
yield return(" " + lib);
}
yield return(@")");
}
}
yield return("");
}
public void Start()
{
var Root = FileNameHandling.GetDirectoryPathWithTailingSeparator(FileNameHandling.GetAbsolutePath(PhysicalPath, Environment.CurrentDirectory));
var Indices = this.Indices;
var MimeTypes = new Dictionary <String, String>(StringComparer.OrdinalIgnoreCase);
MimeTypes.Add("htm", "text/html");
MimeTypes.Add("html", "text/html");
MimeTypes.Add("shtml", "text/html");
MimeTypes.Add("xml", "text/xml");
MimeTypes.Add("css", "text/css");
MimeTypes.Add("js", "application/x-javascript");
MimeTypes.Add("txt", "text/plain");
MimeTypes.Add("gif", "image/gif");
MimeTypes.Add("jpg", "image/jpeg");
MimeTypes.Add("jpeg", "image/jpeg");
MimeTypes.Add("png", "image/png");
MimeTypes.Add("tif", "image/tiff");
MimeTypes.Add("tiff", "image/tiff");
MimeTypes.Add("ico", "image/x-icon");
MimeTypes.Add("mp3", "audio/mpeg");
MimeTypes.Add("wav", "audio/wav");
MimeTypes.Add("mid", "audio/midi");
MimeTypes.Add("midi", "audio/midi");
Func <String, String> GetMimeType = Extension =>
{
if (MimeTypes.ContainsKey(Extension))
{
return(MimeTypes[Extension]);
}
return("application/octet-stream");
};
Func <String, Int64, Optional <KeyValuePair <Int64, Int64> > > TryGetRange = (RangeStrs, FileLength) =>
{
// http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
Int64 Start = 0;
Int64 Length = FileLength;
var RangeStrsTrimmed = RangeStrs.Trim(' ');
if (RangeStrsTrimmed.StartsWith("bytes="))
{
RangeStrsTrimmed = RangeStrsTrimmed.Substring("bytes=".Length);
}
else
{
return(Optional <KeyValuePair <Int64, Int64> > .Empty);
}
var RangeStrsSplitted = RangeStrsTrimmed.Split(',');
if (RangeStrsSplitted.Length != 1)
{
return(Optional <KeyValuePair <Int64, Int64> > .Empty);
}
var Parts = RangeStrsSplitted.Single().Trim(' ').Split('-').Select(p => p.Trim(' ')).ToArray();
if (Parts.Length != 2)
{
return(Optional <KeyValuePair <Int64, Int64> > .Empty);
}
if (Parts[0] == "")
{
// 不支持suffix-byte-range-spec = "-" suffix-length
return(Optional <KeyValuePair <Int64, Int64> > .Empty);
}
if (!Int64.TryParse(Parts[0], out Start))
{
return(Optional <KeyValuePair <Int64, Int64> > .Empty);
}
if ((Start < 0) || (Start > FileLength))
{
return(Optional <KeyValuePair <Int64, Int64> > .Empty);
}
if (Parts[1] == "")
{
Length = FileLength - Start;
}
else
{
Int64 End;
if (!Int64.TryParse(Parts[1], out End))
{
return(Optional <KeyValuePair <Int64, Int64> > .Empty);
}
if (End < Start)
{
return(Optional <KeyValuePair <Int64, Int64> > .Empty);
}
Length = Math.Min(End + 1 - Start, FileLength - Start);
}
return(new KeyValuePair <Int64, Int64>(Start, Length));
};
Action <String, HttpListenerContext, IPEndPoint, Action, Action <Exception> > RequestHandler = (RelativePath, a, e, OnSuccess, OnFailure) =>
{
if (a.Request.ContentLength64 > 0)
{
a.Response.StatusCode = 400;
OnSuccess();
return;
}
if (RelativePathTranslator != null)
{
var oRelativePath = RelativePathTranslator(RelativePath);
if (oRelativePath.OnNone)
{
a.Response.StatusCode = 404;
OnSuccess();
return;
}
RelativePath = oRelativePath.Value;
}
var Path = FileNameHandling.GetAbsolutePath(RelativePath, Root);
if ((RelativePath != "") && !Path.StartsWith(Root))
{
a.Response.StatusCode = 400;
OnSuccess();
return;
}
if (!File.Exists(Path))
{
var Found = false;
var UnescapedPath = Uri.UnescapeDataString(Path);
if (File.Exists(UnescapedPath))
{
Path = UnescapedPath;
Found = true;
}
if (!Found)
{
foreach (var Index in Indices)
{
var IndexPath = FileNameHandling.GetPath(Path, Index);
if (File.Exists(IndexPath))
{
Path = IndexPath;
Found = true;
break;
}
}
foreach (var Index in Indices)
{
var IndexPath = FileNameHandling.GetPath(UnescapedPath, Index);
if (File.Exists(IndexPath))
{
Path = IndexPath;
Found = true;
break;
}
}
}
if (!Found)
{
a.Response.StatusCode = 404;
OnSuccess();
return;
}
}
if (!Path.StartsWith(Root))
{
a.Response.StatusCode = 400;
OnSuccess();
return;
}
var Buffer = new Byte[512 * 1024];
using (var fs = Streams.OpenReadable(Path))
{
var LastWriteTime = File.GetLastWriteTimeUtc(Path);
var LastWriteTimeStr = LastWriteTime.ToString("R");
var ETag = "\"" + Times.DateTimeUtcToString(LastWriteTime) + "\"";
var IfModifiedSinceStr = a.Request.Headers["If-Modified-Since"];
if ((IfModifiedSinceStr != null) && (LastWriteTimeStr == IfModifiedSinceStr))
{
a.Response.StatusCode = 304;
OnSuccess();
return;
}
var oRange = Optional <KeyValuePair <Int64, Int64> > .Empty;
var IfRangeStr = a.Request.Headers["If-Range"];
if ((IfRangeStr == null) || (ETag == IfRangeStr) || (LastWriteTimeStr == IfRangeStr))
{
var RangeStrs = a.Request.Headers["Range"];
if (RangeStrs != null)
{
oRange = TryGetRange(RangeStrs, fs.Length);
}
}
Int64 Start;
Int64 Length;
if (oRange.OnSome)
{
var Range = oRange.Value;
Start = Range.Key;
Length = Range.Value;
a.Response.StatusCode = 206;
a.Response.Headers.Add("Content-Range", "bytes {0}-{1}/{2}".Formats(Range.Key, Range.Key + Range.Value - 1, fs.Length));
}
else
{
Start = 0;
Length = fs.Length;
a.Response.StatusCode = 200;
}
a.Response.ContentLength64 = Length;
a.Response.ContentType = GetMimeType(FileNameHandling.GetExtendedFileName(Path));
a.Response.Headers.Add("Accept-Ranges", "bytes");
a.Response.Headers.Add("Last-Modified", LastWriteTimeStr);
a.Response.Headers.Add("ETag", ETag);
try
{
using (var ros = a.Response.OutputStream)
{
var Count = (Length + Buffer.Length - 1) / Buffer.Length;
fs.Position = Start;
for (int k = 0; k < Count; k += 1)
{
var ChunkSize = (int)(Math.Min(Buffer.Length, Length - Buffer.Length * k));
fs.Read(Buffer, 0, ChunkSize);
ros.Write(Buffer, 0, ChunkSize);
}
}
}
catch (System.Net.HttpListenerException)
{
}
}
OnSuccess();
};
Inner = new ExternalHttpServer(ServerContext, RequestHandler, QueueUserWorkItem, 8 * 1024);
Inner.Bindings = Bindings;
Inner.SessionIdleTimeout = SessionIdleTimeout;
Inner.MaxConnections = MaxConnections;
Inner.MaxConnectionsPerIP = MaxConnectionsPerIP;
Inner.MaxBadCommands = MaxBadCommands;
Inner.MaxUnauthenticatedPerIP = MaxUnauthenticatedPerIP;
Inner.ServiceVirtualPath = ServiceVirtualPath;
Inner.Start();
}
