/// <summary> /// Checks for changes in the dependency file. /// </summary> /// <returns><c>true</c> if a file has been updated, <c>false</c> otherwise</returns> public bool CheckForChanges() { // No files? Then it is considered as changed. if (Count == 0) { return(true); } foreach (var fileItem in this) { if (!File.Exists(fileItem.Key)) { return(true); } var fileTime = NativeFile.GetLastWriteTime(fileItem.Key); if (fileItem.Value != fileTime) { return(true); } } return(false); }
public void DeleteBundles(Func <string, bool> bundleFileDeletePredicate) { var bundleFiles = VirtualFileSystem.ListFiles(vfsBundleDirectory, "*" + BundleExtension, VirtualSearchOption.TopDirectoryOnly).Result; // Group incremental bundles together var bundleFilesGroups = bundleFiles.GroupBy(bundleUrl => { // Remove incremental ID from bundle url ObjectId incrementalId; var filename = VirtualFileSystem.GetFileName(bundleUrl); var bundleExtensionLength = filename.EndsWith(BundleExtension) ? BundleExtension.Length : 0; if (filename.Length - bundleExtensionLength >= ObjectId.HashStringLength + 1 && filename[filename.Length - bundleExtensionLength - ObjectId.HashStringLength - 1] == '.' && ObjectId.TryParse(filename.Substring(filename.Length - bundleExtensionLength - ObjectId.HashStringLength, ObjectId.HashStringLength), out incrementalId)) { bundleUrl = bundleUrl.Remove(bundleUrl.Length - bundleExtensionLength - ObjectId.HashStringLength - 1, 1 + ObjectId.HashStringLength); } return(bundleUrl); }); foreach (var bundleFilesInGroup in bundleFilesGroups) { var bundleMainFile = VirtualFileSystem.GetAbsolutePath(bundleFilesInGroup.Key); if (bundleFileDeletePredicate(bundleMainFile)) { foreach (var bundleRealFile in bundleFilesInGroup) { NativeFile.FileDelete(VirtualFileSystem.GetAbsolutePath(bundleRealFile)); } } } }
/// <inheritdoc/> public override void Initialize(EffectContext effectContext, TransformGraph transformGraph) { var path = Windows.ApplicationModel.Package.Current.InstalledLocation.Path; effectContext.LoadPixelShader(GUID_RipplePixelShader, NativeFile.ReadAllBytes(path + "\\Ripple.cso")); transformGraph.SetSingleTransformNode(this); }
public void InitializeView() { if (!NativeFile.Exists(this.Filename)) { MessageBox.Show( String.Format("{0:s} is not present on the disk", this.Filename), "Invalid PE", MessageBoxButton.OK ); return; } this.Pe = (Application.Current as App).LoadBinary(this.Filename); if (this.Pe == null || !this.Pe.LoadSuccessful) { MessageBox.Show( String.Format("{0:s} is not a valid PE-COFF file", this.Filename), "Invalid PE", MessageBoxButton.OK ); return; } this.SymPrv = new PhSymbolProvider(); this.RootFolder = Path.GetDirectoryName(this.Filename); this.SxsEntriesCache = SxsManifest.GetSxsEntries(this.Pe); this.ProcessedModulesCache = new ModulesCache(); this.ApiSetmapCache = Phlib.GetApiSetSchema(); this._SelectedModule = null; this._DisplayWarning = false; // TODO : Find a way to properly bind commands instead of using this hack this.ModulesList.Items.Clear(); this.ModulesList.DoFindModuleInTreeCommand = DoFindModuleInTree; this.ModulesList.ConfigureSearchOrderCommand = ConfigureSearchOrderCommand; var RootFilename = Path.GetFileName(this.Filename); var RootModule = new DisplayModuleInfo(RootFilename, this.Pe, ModuleSearchStrategy.ROOT); this.ProcessedModulesCache.Add(new ModuleCacheKey(RootFilename, this.Filename), RootModule); ModuleTreeViewItem treeNode = new ModuleTreeViewItem(); DependencyNodeContext childTreeInfoContext = new DependencyNodeContext() { ModuleInfo = new WeakReference(RootModule), IsDummy = false }; treeNode.DataContext = childTreeInfoContext; treeNode.Header = treeNode.GetTreeNodeHeaderName(Dependencies.Properties.Settings.Default.FullPath); treeNode.IsExpanded = true; this.DllTreeView.Items.Clear(); this.DllTreeView.Items.Add(treeNode); // Recursively construct tree of dll imports ConstructDependencyTree(treeNode, this.Pe); }
public void AddDependencyPath(string filePath) { if (!ContainsKey(filePath)) { Add(filePath, NativeFile.GetLastWriteTime(filePath)); } }
static void Main(string[] args) { bool is_verbose = false; bool show_help = false; CLRPH_DEMANGLER demangler_name = CLRPH_DEMANGLER.Default; OptionSet opts = new OptionSet() { { "v|verbose", "redirect debug traces to console", v => is_verbose = v != null }, { "h|help", "show this message and exit", v => show_help = v != null }, { "d=|demangler=", "Choose demangler name", v => demangler_name = ParseDemanglerName(v) }, }; List <string> eps = opts.Parse(args); if (show_help) { ShowHelp(opts); return; } if (is_verbose) { // Redirect debug log to the console Debug.Listeners.Add(new TextWriterTraceListener(Console.Out)); Debug.AutoFlush = true; } // always the first call to make Phlib.InitializePhLib(); Demangler demangler; switch (args.Length) { case 0: demangler = new Demangler(CLRPH_DEMANGLER.Microsoft); TestKnownInputs(demangler); break; default: case 1: demangler = new Demangler(demangler_name); string Filepath = args[1]; if (NativeFile.Exists(Filepath)) { TestFilepath(Filepath, demangler); } else { string undecoratedName = demangler.UndecorateName(args[1]).Item2; Console.WriteLine(undecoratedName); } break; } // Force flushing out buffer Console.Out.Flush(); }
public IList <DirectoryEntry> GetDirectoryEntries(FullPath path) { var list = NativeFile.GetDirectoryEntries(path.Value); // Skip any entry that is longer than MAX_PATH. // Fix this once we fully support the long path syntax ("\\?\" prefix) if (list.Any(entry => PathHelpers.IsPathTooLong(path.Value, entry.Name))) { return(list.Where(entry => { if (PathHelpers.IsPathTooLong(path.Value, entry.Name)) { // Note: The condition is unsafe from a pure concurrency point of view, // but is ok in this case because the field is incrementally increasing. // This is just an optimization to avoid an Interlocked call. if (_pathTooLongErrorCount <= MaxPathTooLogLogCount) { var logCount = Interlocked.Increment(ref _pathTooLongErrorCount); if (logCount <= MaxPathTooLogLogCount) { Logger.LogInfo("Skipping directory entry because path is too long: \"{0}\"", path.Combine(new RelativePath(entry.Name))); } if (logCount == MaxPathTooLogLogCount) { Logger.LogInfo(" (Note: No more message abount path too long will be logged, because the maximum number of occurrences has been reached)"); } } return false; } return true; }).ToList()); } return(list); }
public static void Main(string[] args) { string inputFile = "http://www.dev-c.com/nativedb/natives.json"; string outputFile = "NativeHashes.txt"; bool withUnnamedHashes = false; if (args.Length == 1) { outputFile = args[0]; } if (args.Length == 2) { inputFile = args[0]; outputFile = args[1]; } using (var wc = new WebClient()) { ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12; Console.WriteLine("Downloading natives.json"); wc.Headers.Add("Accept-Encoding: gzip, deflate, sdch"); string nativeFileRaw = Decompress(wc.DownloadData(inputFile)); string nativeTemplate = File.ReadAllText(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "NativeTemplate.txt")); NativeFile nativeFile = JsonConvert.DeserializeObject <NativeFile>(nativeFileRaw); StringBuilder resultBuilder = new StringBuilder(); foreach (string nativeNamespaceKey in nativeFile.Keys) { Console.WriteLine("Processing " + nativeNamespaceKey); NativeNamespace nativeNamespace = nativeFile[nativeNamespaceKey]; resultBuilder.AppendLine(" /*"); resultBuilder.AppendLine(" "+ nativeNamespaceKey); resultBuilder.AppendLine(" */"); foreach (string nativeFuncKey in nativeNamespace.Keys) { NativeFunction nativeFunction = nativeNamespace[nativeFuncKey]; if (!string.IsNullOrEmpty(nativeFunction.Name)) { resultBuilder.AppendLine(" "+ nativeFunction.Name + " = " + nativeFuncKey + ", // " + nativeFunction.JHash); } else if (withUnnamedHashes) { resultBuilder.AppendLine(" _"+ nativeFuncKey + " = " + nativeFuncKey + ", // " + nativeFunction.JHash); } } } File.WriteAllText(outputFile, string.Format(nativeTemplate, resultBuilder)); Console.WriteLine("Finished generating native hash enum"); } }
public PE GetBinary(string PePath) { Debug.WriteLine(String.Format("Attempt to load : {0:s}", PePath), "BinaryCache"); if (!NativeFile.Exists(PePath)) { Debug.WriteLine(String.Format("File not present on the filesystem : {0:s} ", PePath), "BinaryCache"); return(null); } string Fullpath = Path.GetFullPath(PePath); if (FilepathDatabase.ContainsKey(Fullpath)) { // TODO : update LRU cache PE sShadowBinary = FilepathDatabase[Fullpath]; sShadowBinary.Filepath = Fullpath; return(sShadowBinary); } string PeHash = GetBinaryHash(PePath); Debug.WriteLine(String.Format("File {0:s} hash : {1:s} ", PePath, PeHash), "BinaryCache"); // A sync lock is mandatory here in order not to load twice the // same binary from two differents workers lock (BinaryDatabaseLock) { bool hit = BinaryDatabase.ContainsKey(PeHash); // Cache "miss" if (!hit) { string DestFilePath = Path.Combine(BinaryCacheFolderPath, PeHash); if (!File.Exists(DestFilePath) && (DestFilePath != PePath)) { Debug.WriteLine(String.Format("FileCopy from {0:s} to {1:s}", PePath, DestFilePath), "BinaryCache"); NativeFile.Copy(PePath, DestFilePath); } PE NewShadowBinary = new PE(DestFilePath); NewShadowBinary.Load(); LruCache.Add(PeHash); BinaryDatabase.Add(PeHash, NewShadowBinary); FilepathDatabase.Add(Fullpath, NewShadowBinary); } } // Cache "Hit" UpdateLru(PeHash); PE ShadowBinary = BinaryDatabase[PeHash]; ShadowBinary.Filepath = Path.GetFullPath(PePath); // convert any paths to an absolute one. Debug.WriteLine(String.Format("File {0:s} loaded from {1:s}", PePath, Path.Combine(BinaryCacheFolderPath, PeHash)), "BinaryCache"); return(ShadowBinary); }
public static bool IsChromiumSourceDirectory(FullPathName path, IPathPatternsFile chromiumEnlistmentPatterns) { // We need to ensure that all pattern lines are covered by at least one file/directory of |path|. IList <string> directories; IList <string> files; NativeFile.GetDirectoryEntries(path.FullName, out directories, out files); return(chromiumEnlistmentPatterns.GetPathMatcherLines() .All(item => MatchFileOrDirectory(item, directories, files))); }
public void CheckFileExists() { var testFile = "test.txt"; File.Delete(testFile); Assert.False(NativeFile.Exists(testFile)); File.WriteAllText(testFile, string.Empty); Assert.True(NativeFile.Exists(testFile)); File.Delete(testFile); }
public void TestLoadVtfImage() { //var file = new NativeFile(@"D:\Github\Chisel\_Resources\VTF\mudground001_height-ssbump.vtf"); //var file = new NativeFile(@"D:\Github\Chisel\_Resources\VTF\dirtroad001a.vtf"); //var file = new NativeFile(@"D:\Github\Chisel\_Resources\VTF\rockground001.vtf"); //var file = new NativeFile(@"D:\Github\Chisel\_Resources\VTF\class_demo_dudv.vtf"); var file = new NativeFile(@"D:\Github\Chisel\_Resources\VTF\cubemap_gold001.hdr.vtf"); //var file = new NativeFile(@"D:\Github\Chisel\_Resources\VTF\800corner.vtf"); var image = VtfProvider.GetImage(file); image.Save(@"D:\Github\Chisel\_Resources\VTF\_test2.png"); }
public Stream Open(IncludeType type, string fileName, Stream parentStream) { Debug.WriteLine(fileName); // Include dynamic (:D) constants if (fileName.ToLower().Equals("raymarchengine")) { return(GetShaderConstantsStream()); } string currentDirectory = CurrentDirectory.Peek(); if (currentDirectory == null) { #if NETFX_CORE currentDirectory = Windows.ApplicationModel.Package.Current.InstalledLocation.Path; #else currentDirectory = Environment.CurrentDirectory; #endif } string filePath = fileName; if (!Path.IsPathRooted(filePath)) { var directoryToSearch = new List <string> { currentDirectory }; directoryToSearch.AddRange(IncludeDirectories); foreach (string dirPath in directoryToSearch) { string selectedFile = Path.GetFullPath(Path.Combine(dirPath, fileName)); if (NativeFile.Exists(selectedFile)) { filePath = selectedFile; break; } } } if (filePath == null || !NativeFile.Exists(filePath)) { throw new FileNotFoundException(String.Format("Unable to find file [{0}]", filePath ?? fileName)); } NativeFileStream fs = new NativeFileStream(filePath, NativeFileMode.Open, NativeFileAccess.Read); CurrentDirectory.Push(Path.GetDirectoryName(filePath)); return(fs); }
public static void Start() { MapProvider.Register(new RmfProvider()); MapProvider.Register(new VmfProvider()); GameDataProvider.Register(new FgdProvider()); TextureProvider.Register(new WadProvider()); // var editor = new Editor.Editor(); // editor.Load += (sender, e) => PostStart(sender as Editor.Editor); // Application.Run(editor); // var settings = Context.DBContext.GetAllSettings().ToDictionary(x => x.Key, x => x.Value); // Serialise.DeserialiseSettings(settings); // var settingsform = new Editor.Settings.SettingsForm(); // Application.Run(settingsform); // var map = MapProvider.GetMapFromFile(MapFile); // Document.Game = Game; // Document.Map = map; // Document.GameData = GameDataProvider.GetGameDataFromFiles(Game.Fgds.Select(f => f.Path)); // var entity = new EntityEditor(); // entity.Objects.AddRange(map.WorldSpawn.Children.OfType<Entity>().Take(1)); // Application.Run(entity); /* * var nat = new NativeFile(new DirectoryInfo(@"F:\Steam\steamapps\common\Half-Life")); * var gcf1 = new GcfFile(@"F:\Steam\steamapps\half-life.gcf"); * var gcf2 = new GcfFile(@"F:\Steam\steamapps\half-life engine.gcf"); * //var gcf3 = new GcfFile(@"F:\Steam\steamapps\half-life base content.gcf"); * var gcf4 = new GcfFile(@"F:\Steam\steamapps\platform.gcf"); * var com = new CompositeFile(null, new IFile[] { nat, gcf1, gcf2, gcf4 }); */ var nat = new NativeFile(new DirectoryInfo(@"F:\Half-Life WON")); var com = new CompositeFile(null, new[] { new NativeFile(new DirectoryInfo(@"F:\Half-Life WON\valve")), new NativeFile(new DirectoryInfo(@"F:\Half-Life WON\tfc")), }); //var pak = new PakFile(@"F:\Half-Life WON\valve\pak0.pak"); // var vir = new VirtualFile(null, "valve", new[] {pak}); //var com = new CompositeFile(null, new IFile[] { nat, vir }); var fsb = new FileSystemBrowserControl { Dock = DockStyle.Fill, File = com }; //, FilterText = "WAD Files", Filter = "*.wad"}; var form = new Form { Controls = { fsb }, Width = 500, Height = 500 }; Application.Run(form); }
private void OnTreeViewSelectedItemChanged(object sender, RoutedPropertyChangedEventArgs <object> e) { if (this.DllTreeView.SelectedItem == null) { UpdateImportExportLists(null, null); return; } DependencyNodeContext childTreeContext = ((DependencyNodeContext)(this.DllTreeView.SelectedItem as ModuleTreeViewItem).DataContext); DisplayModuleInfo SelectedModule = childTreeContext.ModuleInfo.Target as DisplayModuleInfo; if (SelectedModule == null) { return; } // Selected Pe has not been found on disk : unvalidate current module SelectedModule.HasErrors = !NativeFile.Exists(SelectedModule.Filepath); if (SelectedModule.HasErrors) { // TODO : do a proper refresh instead of asking the user to do it System.Windows.MessageBox.Show(String.Format("We could not find {0:s} file on the disk anymore, please fix this problem and refresh the window via F5", SelectedModule.Filepath)); } // Root Item : no parent ModuleTreeViewItem TreeRootItem = this.DllTreeView.Items[0] as ModuleTreeViewItem; ModuleTreeViewItem SelectedItem = this.DllTreeView.SelectedItem as ModuleTreeViewItem; if (SelectedItem == TreeRootItem) { // Selected Pe has not been found on disk : unvalidate current module if (SelectedModule.HasErrors) { UpdateImportExportLists(null, null); } else { SelectedModule.HasErrors = false; UpdateImportExportLists(SelectedModule, null); } return; } // Tree Item DisplayModuleInfo parentModule = SelectedItem.ParentModule.ModuleInfo; UpdateImportExportLists(SelectedModule, parentModule); }
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) { string Filepath = (string)value; Icon icon = ShellIcon.GetSmallIcon(Filepath); if (NativeFile.Exists(Filepath) && (icon != null)) { return(System.Windows.Interop.Imaging.CreateBitmapSourceFromHIcon( icon.Handle, new Int32Rect(0, 0, icon.Width, icon.Height), BitmapSizeOptions.FromEmptyOptions())); } return("Images/Question.png"); }
protected string GetBinaryHash(string PePath) { // Compute checksum only on first 1 KB of file data // in order not to spend too much CPU cycles here. // Hopefully there is enough entropy in PE headers // not to trigger too many collisions. //using (FileStream stream = File.OpenRead(PePath)) //{ // var sha = new SHA256Managed(); // byte[] buffer = new byte[1024]; // stream.Read(buffer, 0, buffer.Length); // byte[] checksum = sha.ComputeHash(buffer, 0, buffer.Length); // return BitConverter.ToString(checksum).Replace("-", String.Empty); //} return(NativeFile.GetPartialHashFile(PePath, 1024)); }
protected virtual void Initialize() { const string filePath = Global.DataPath + "System.yaml"; const string references = "EngineReferences"; if (!NativeFile.Exists(filePath)) { throw new InvalidOperationException(string.Format("Odyssey System Data not found: check if {0} exists", filePath)); } contentManager.LoadAssetList(filePath); var refData = contentManager.Load <EngineReferenceCollection>(references); services.AddService(typeof(IReferenceService), refData); SetupDeviceEvents(); }
public Stream Resolve(string assetName) { try { var assetPath = GetAssetPath(assetName); if (!NativeFile.Exists(assetPath)) { assetPath = GetAssetPath(assetName, true); } return(new NativeFileStream(assetPath, NativeFileMode.Open, NativeFileAccess.Read)); } catch { return(null); } }
private void InitTextWindow() { UIScrollWindow textWindow = new UIScrollWindow(); textWindow.Position = new Vector2(300, 300); textWindow.ScrollPanel.Restriction = ScrollRestriction.Vertical; textWindow.Size = new Vector2(0, 180); textWindow.AddConstraint(Edge.Bottom, null, Edge.Bottom, 5); textWindow.AddConstraint(Edge.Horizontal, null, Edge.Horizontal, 5); string text = NativeFile.ReadAllText(Path.Combine(Environment.CurrentDirectory, "Lorem Ipsum.txt")); UILabel label = new UILabel(text, true); label.AddConstraint(Edge.TopLeft, textWindow.ScrollPanel, Edge.TopLeft, ConstraintCategory.Initialization); label.AddConstraint(Edge.Right, textWindow.ScrollPanel, Edge.Right, ConstraintCategory.Initialization); textWindow.AddChild(label); uiManager.Add(textWindow); }
//EffectContext _effectContext; public override void Initialize(EffectContext effectContext, TransformGraph transformGraph) { //WARNING : as soon as TransformGraph.SetSingleTransformNode is called it chain calls the //SetDrawInformation via a callbac. Unfortunately this is too early because the code below //within this method is used to populate stateful data needed by the SetDrawInformation call. //transformGraph.SetSingleTransformNode(this); var path = Windows.ApplicationModel.Package.Current.InstalledLocation.Path; byte[] vertexShaderBytecode = NativeFile.ReadAllBytes(path + "\\WaveEffect.cso"); effectContext.LoadVertexShader(GUID_WaveVertexShader, vertexShaderBytecode); // Only generate the vertex buffer if it has not already been initialized. vertexBuffer = effectContext.FindVertexBuffer(GUID_WaveVertexBuffer); if (vertexBuffer == null) { //InitializeVertexBuffer(effectContext); var mesh = GenerateMesh(); // Updating geometry every time the effect is rendered can be costly, so it is // recommended that vertex buffer remain static if possible (which it is in this // sample effect). using (var stream = DataStream.Create(mesh, true, true)) { var vbProp = new VertexBufferProperties(1, VertexUsage.Static, stream); var cvbProp = new CustomVertexBufferProperties(vertexShaderBytecode, new[] { new InputElement("MESH_POSITION", 0, SharpDX.DXGI.Format.R32G32_Float, 0, 0), }, Utilities.SizeOf <Vector2>()); // The GUID is optional, and is provided here to register the geometry globally. // As mentioned above, this avoids duplication if multiple versions of the effect // are created. vertexBuffer = new VertexBuffer(effectContext, GUID_WaveVertexBuffer, vbProp, cvbProp); } } PrepareForRender(ChangeType.Properties | ChangeType.Context); transformGraph.SetSingleTransformNode(this); }
public static void Main(string[] args) { using (WebClient wc = new WebClient()) { Console.WriteLine("Downloading natives.json"); wc.Headers.Add("Accept-Encoding: gzip, deflate, sdch"); string nativeFileRaw = Decompress(wc.DownloadData("http://www.dev-c.com/nativedb/natives.json")); string nativeTemplate = File.ReadAllText(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "NativeTemplate.txt")); NativeFile nativeFile = JsonConvert.DeserializeObject <NativeFile>(nativeFileRaw); StringBuilder resultBuilder = new StringBuilder(); foreach (string nativeNamespaceKey in nativeFile.Keys) { Console.WriteLine("Processing " + nativeNamespaceKey); NativeNamespace nativeNamespace = nativeFile[nativeNamespaceKey]; resultBuilder.AppendLine(" /*"); resultBuilder.AppendLine(" "+ nativeNamespaceKey); resultBuilder.AppendLine(" */"); foreach (string nativeFuncKey in nativeNamespace.Keys) { NativeFunction nativeFunction = nativeNamespace[nativeFuncKey]; if (!string.IsNullOrEmpty(nativeFunction.Name)) { resultBuilder.AppendLine(" "+ nativeFunction.Name + " = " + nativeFuncKey + ", // " + nativeFunction.JHash); } } } string outputFile = args.Length > 0 ? args[0] : "NativeHashes.hpp"; File.WriteAllText(outputFile, string.Format(nativeTemplate, resultBuilder)); Console.WriteLine("Finished generating native hash enum"); } }
public PE GetBinary(string PePath) { if (!NativeFile.Exists(PePath)) { return(null); } string PeHash = GetBinaryHash(PePath); // A sync lock is mandatory here in order not to load twice the // same binary from two differents workers lock (BinaryDatabaseLock) { bool hit = BinaryDatabase.ContainsKey(PeHash); // Cache "miss" if (!hit) { string DestFilePath = Path.Combine(BinaryCacheFolderPath, PeHash); if (!File.Exists(DestFilePath) && (DestFilePath != PePath)) { NativeFile.Copy(PePath, DestFilePath); } PE NewShadowBinary = new PE(DestFilePath); NewShadowBinary.Load(); LruCache.Add(PeHash); BinaryDatabase.Add(PeHash, NewShadowBinary); } } // Cache "Hit" UpdateLru(PeHash); PE ShadowBinary = BinaryDatabase[PeHash]; ShadowBinary.Filepath = Path.GetFullPath(PePath); // convert any paths to an absolute one. return(ShadowBinary); }
public Stream Open(IncludeType type, string fileName, Stream parentStream) { var currentDirectory = CurrentDirectory.Peek(); if (currentDirectory == null) #if NETFX_CORE { currentDirectory = Windows.ApplicationModel.Package.Current.InstalledLocation.Path; } #else { currentDirectory = Environment.CurrentDirectory; } #endif var filePath = fileName; if (!Path.IsPathRooted(filePath)) { var directoryToSearch = new List <string> { currentDirectory }; directoryToSearch.AddRange(IncludeDirectories); foreach (var dirPath in directoryToSearch) { var selectedFile = Path.Combine(dirPath, fileName); if (NativeFile.Exists(selectedFile)) { filePath = selectedFile; break; } } } if (filePath == null || !NativeFile.Exists(filePath)) { throw new FileNotFoundException(String.Format("Unable to find file [{0}]", filePath ?? fileName)); } NativeFileStream fs = new NativeFileStream(filePath, NativeFileMode.Open, NativeFileAccess.Read); CurrentDirectory.Push(Path.GetDirectoryName(filePath)); return(fs); }
static void Main(string[] args) { // always the first call to make Phlib.InitializePhLib(); Demangler demangler; switch (args.Length) { case 0: demangler = new Demangler("Microsoft"); TestKnownInputs(demangler); break; case 1: demangler = new Demangler(); TestFilepath(args[0], demangler); break; default: case 2: string demanglerName = args[0].TrimStart(new char[] { '-' }); string Filepath = args[1]; demangler = new Demangler(demanglerName); if (NativeFile.Exists(Filepath)) { TestFilepath(Filepath, demangler); } else { Console.WriteLine(demangler.UndecorateName(args[1])); } break; } }
public PE LoadBinary(string path) { StatusBarMessage = String.Format("Loading module {0:s} ...", path); if (!NativeFile.Exists(path)) { StatusBarMessage = String.Format("Loading PE file \"{0:s}\" failed : file not present on disk.", path); return(null); } PE pe = BinaryCache.LoadPe(path); if (pe == null || !pe.LoadSuccessful) { StatusBarMessage = String.Format("Loading module {0:s} failed.", path); } else { StatusBarMessage = String.Format("Loading PE file \"{0:s}\" successful.", pe.Filepath); } return(pe); }
private static string GetApplicationCacheDirectory() { #if SILICONSTUDIO_PLATFORM_ANDROID var directory = Path.Combine(PlatformAndroid.Context.FilesDir.AbsolutePath, "cache"); Directory.CreateDirectory(directory); return(directory); #elif SILICONSTUDIO_PLATFORM_WINDOWS_STORE var directory = Path.Combine(Windows.Storage.ApplicationData.Current.LocalFolder.Path, "cache"); NativeFile.DirectoryCreate(directory); return(directory); #elif SILICONSTUDIO_PLATFORM_WINDOWS_PHONE return(Windows.Storage.ApplicationData.Current.LocalCacheFolder.Path); #elif SILICONSTUDIO_PLATFORM_IOS var directory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "..", "Library", "Caches"); Directory.CreateDirectory(directory); return(directory); #else // TODO: Should we add "local" ? var directory = Path.Combine(GetApplicationBinaryDirectory(), "cache"); Directory.CreateDirectory(directory); return(directory); #endif }
protected List <ModelReference> LoadAllModels(IEnumerable <string> modelDirs) { List <ModelReference> models = new List <ModelReference>(); foreach (string dir in modelDirs) { string[] files = Directory.GetFiles(dir); foreach (string modelPath in files) { NativeFile file = null; if (!string.IsNullOrEmpty(modelPath)) { file = new NativeFile(modelPath); } if (file == null || !ModelProvider.CanLoad(file)) { continue; } #if !DEBUG try { #endif var mr = ModelProvider.CreateModelReference(file); models.Add(mr); #if !DEBUG } catch (Exception) { // Couldn't load continue; } #endif } } return(models); }
public void DeleteBundles(Func <string, bool> bundleFileDeletePredicate) { var bundleFiles = VirtualFileSystem.ListFiles(vfsBundleDirectory, "*.bundle", VirtualSearchOption.TopDirectoryOnly).Result; // Obsolete: Android used to have .bundle.mp3 to avoid compression. Still here so that they get deleted on next build. // This can be removed later. bundleFiles = bundleFiles.Union(VirtualFileSystem.ListFiles(vfsBundleDirectory, "*.mp3", VirtualSearchOption.TopDirectoryOnly).Result).ToArray(); foreach (var bundleFile in bundleFiles) { var bundleRealFile = VirtualFileSystem.GetAbsolutePath(bundleFile); // Remove ".mp3" (Android only) if (bundleRealFile.EndsWith(".mp3", StringComparison.CurrentCultureIgnoreCase)) { bundleRealFile = bundleRealFile.Substring(0, bundleRealFile.Length - 4); } if (bundleFileDeletePredicate(bundleRealFile)) { NativeFile.FileDelete(bundleRealFile); } } }
private FileContents ReadFile(FullPathName fullName) { try { var fileInfo = new SlimFileInfo(fullName); const int trailingByteCount = 2; var block = NativeFile.ReadFileNulTerminated(fileInfo, trailingByteCount); var contentsByteCount = (int)block.ByteLength - trailingByteCount; // Padding added by ReadFileNulTerminated var kind = NativeMethods.Text_GetKind(block.Pointer, contentsByteCount); switch (kind) { case NativeMethods.TextKind.Ascii: return(new AsciiFileContents(new FileContentsMemory(block, 0, contentsByteCount), fileInfo.LastWriteTimeUtc)); case NativeMethods.TextKind.AsciiWithUtf8Bom: const int utf8BomSize = 3; return(new AsciiFileContents(new FileContentsMemory(block, utf8BomSize, contentsByteCount - utf8BomSize), fileInfo.LastWriteTimeUtc)); case NativeMethods.TextKind.Utf8WithBom: var utf16Block = Conversion.UTF8ToUnicode(block); block.Dispose(); return(new UTF16FileContents(new FileContentsMemory(utf16Block, 0, utf16Block.ByteLength), fileInfo.LastWriteTimeUtc)); case NativeMethods.TextKind.Unknown: default: // TODO(rpaquay): Figure out a better way to detect encoding. //Logger.Log("Text Encoding of file \"{0}\" is not recognized.", fullName); return(new AsciiFileContents(new FileContentsMemory(block, 0, contentsByteCount), fileInfo.LastWriteTimeUtc)); //throw new NotImplementedException(string.Format("Text Encoding of file \"{0}\" is not recognized.", fullName)); } } catch (Exception e) { Logger.LogException(e, "Error reading content of text file \"{0}\", skipping file.", fullName); return(StringFileContents.Empty); } }
private void DoInterfaces(StringBuilder buffer, NativeFile file) { for (int i = 0; i < file.Interfaces.Count; ++i) { m_interface = file.Interfaces[i]; if (m_interface.Name != "NSOpenGLLayer") // NSOpenGLLayer relies on CAOpenGLLayer whichis in quartz, not appkit... { m_buffer = new StringBuilder(); if (i > 0) DoWrite(); if (m_objects.KnownType(m_interface.Name)) { DoWriteInterfaceHeader(); DoGenerateMethods(); DoWriteInterfaceTrailer(); buffer.Append(m_buffer.ToString()); } else Console.Error.WriteLine("Ignoring {0} ({1} isn't a known type)", m_interface, m_interface.Name); } } }
private void DoEnums(StringBuilder buffer, NativeFile file) { m_buffer = buffer; for (int k = 0; k < file.Enums.Count; ++k) { NativeEnum value = file.Enums[k]; if (value.Name != null) { DoWrite(" /// <exclude/>"); DoWrite(" [Serializable]"); string backing = value.Values.Any(v => v.Contains("1U ")) ? " : uint" : string.Empty; DoWrite(" public enum {0}{1}", value.Name, backing); DoWrite(" {"); for (int i = 0; i < value.Names.Length; ++i) { Blacklist black = m_blacklist.SingleOrDefault(b => b.Enum == value.Names[i]); if (black == null) { if (value.Values[i].Length > 0) DoWrite(" {0} = {1},", value.Names[i], DoMapEnumValue(value.Values[i])); else DoWrite(" {0},", value.Names[i]); } } } else { DoWrite(" /// <exclude/>"); DoWrite(" public partial class Enums"); DoWrite(" {"); int? v = 0; for (int i = 0; i < value.Names.Length; ++i) { Blacklist black = m_blacklist.SingleOrDefault(b => b.Enum == value.Names[i]); if (black == null) { if (value.Values[i].Length > 0) { string vv = DoMapEnumValue(value.Values[i].Trim()); int tmp; if (vv.StartsWith("0x") && vv.Contains("ULL")) { DoWrite(" public const ulong {0} = {1};", value.Names[i], vv); v = null; } else if (vv.StartsWith("0x") && vv.Length >= 10 && vv[2] >= '8') { if (vv.EndsWith("UL")) vv = vv.Substring(0, vv.Length - 2); DoWrite(" public const uint {0} = {1};", value.Names[i], vv); v = null; } else if (vv.Contains("0L") || vv.Contains("1L") || vv.Contains("2L") || vv.Contains("3L") || vv.Contains("4L") || vv.Contains("5L")) { DoWrite(" public const long {0} = {1};", value.Names[i], vv); } else if (vv.Contains("0UL") || vv.Contains("1UL") || vv.Contains("2UL") || vv.Contains("3UL") || vv.Contains("4UL") || vv.Contains("5UL")) { DoWrite(" public const ulong {0} = {1};", value.Names[i], vv); } else if (vv.Contains("0U") || vv.Contains("1U") || vv.Contains("2U") || vv.Contains("3U") || vv.Contains("4U") || vv.Contains("5U")) { DoWrite(" public const uint {0} = {1};", value.Names[i], vv); } else if (vv == "NSIntegerMax") { DoWrite(" public const int {0} = int.MaxValue;", value.Names[i]); v = null; } else if (vv == "NSUIntegerMax") { DoWrite(" public const uint {0} = uint.MaxValue;", value.Names[i]); v = null; } else if (value.Names[i] == "NSXMLNodePreserveAll") { DoWrite(" public const uint {0} = {1};", value.Names[i], vv); v = null; } else { DoWrite(" public const int {0} = {1};", value.Names[i], vv); if (int.TryParse(vv, out tmp)) v = tmp + 1; else v = null; } } else if (v.HasValue) { DoWrite(" public const int {0} = {1};", value.Names[i], v.Value); v = v.Value + 1; } else throw new Exception(string.Format("Couldn't compute a value for {0} in {1}", value.Names[i], m_inPath)); } } } DoWrite(" }"); DoWrite(" "); } }
private void DoAddMethods(NativeFile file) { foreach (NativeInterface ni in file.Interfaces) { NativeInterface ri = ni; if (ni.Category == null) { m_objects.AddMethods(ri, ni.Methods); } else { if (m_objects.KnownType(ni.Name)) { ri = m_objects.FindInterface(ni.Name); m_objects.AddMethods(ri, ni.Methods); } else Console.Error.WriteLine("Ignoring the {0} category for interface {1} (can't find the interface).", ni.Category, ni.Name); } foreach (string p in ni.Protocols) { try { NativeProtocol pp = m_objects.FindProtocol(p); m_objects.AddMethods(ri, pp.Methods); } catch (ArgumentException) { Console.Error.WriteLine("Not adding the {0} protocol methods to {1} (can't find the protocol).", p.Normalize(), ni.Name); } } } }
// Header := S (ForwardReference / Enum / Extern / Inline / Interface / Protocol / Struct / Typedef)*; public void Header(XmlNode node, string path, bool emitting) { m_enums = new List<NativeEnum>(); m_interfaces = new List<NativeInterface>(); foreach (XmlNode child in node.ChildNodes) { // TODO: Would be nice to also handle extern and struct (here and in DoAnalyzeInterface). if ("Enum" == child.Name) { DoAnalyzeEnum(child); } else if ("Interface" == child.Name) { DoAnalyzeInterface(child); } else if ("Preprocessor" == child.Name && child.Attributes["alternative"].Value == "1") { DoAnalyzePreprocessor(child); } else if ("Protocol" == child.Name) { DoAnalyzeProtocol(child); } else if ("Struct" == child.Name) { DoAnalyzeStruct(child); } else if ("Typedef" == child.Name) { DoAnalyzeTypedef(child); } } var file = new NativeFile(path, m_enums, m_interfaces); if (m_knownFiles.Exists(f => f.Path == path)) throw new Exception(path + " has already been parsed."); m_knownFiles.Add(file); if (emitting) m_objects.AddFile(file, m_interfaces); }