public static void Main(string[] args) { if (args.Length > 0) { string inputFileName = args[0]; if (!Path.IsPathRooted(inputFileName)) { inputFileName = Path.Combine(Environment.CurrentDirectory, inputFileName); } ICharStream input = new ANTLRFileStream(inputFileName); CLexer lex = new CLexer(input); CommonTokenStream tokens = new CommonTokenStream(lex); CParser parser = new CParser(tokens); try { parser.translation_unit(); } catch (RecognitionException re) { Console.Out.WriteLine(re.StackTrace); } } else { Console.Error.WriteLine("Usage: cparse <input-file>"); } }
ICommandOutput SetupEnvironmentForAdd() { var directory = HostEnvironment.CurrentDirectory; var fromDirectory = string.IsNullOrEmpty(From) ? null : FileSystem.GetDirectory(From); if (fromDirectory != null && fromDirectory.Exists) { if (SysPath.GetExtension(Name).EqualsNoCase(".wrap") && SysPath.IsPathRooted(Name) && FileSystem.GetDirectory(SysPath.GetDirectoryName(Name)) != fromDirectory) { return(new Error("You provided both -From and -Name, but -Name is a path. Try removing the -From parameter.")); } directory = fromDirectory; _userSpecifiedRepository = new FolderRepository(directory, FolderRepositoryOptions.Default); } if (SysPath.GetExtension(Name).EqualsNoCase(".wrap") && directory.GetFile(SysPath.GetFileName(Name)).Exists) { var originalName = Name; Name = PackageNameUtility.GetName(SysPath.GetFileNameWithoutExtension(Name)); Version = PackageNameUtility.GetVersion(SysPath.GetFileNameWithoutExtension(originalName)).ToString(); return(new Warning("The requested package contained '.wrap' in the name. Assuming you pointed to a file name and meant a package named '{0}' with version qualifier '{1}'.", Name, Version)); } return(null); }
public static void Main(string[] args) { if (args.Length == 1) { string fullpath; if (Path.IsPathRooted(args[0])) { fullpath = args[0]; } else { fullpath = Path.Combine(Environment.CurrentDirectory, args[0]); } Console.Out.WriteLine("Processing file: {0}", fullpath); ICharStream input = new ANTLRFileStream(fullpath); LangLexer lex = new LangLexer(input); CommonTokenStream tokens = new CommonTokenStream(lex); LangParser parser = new LangParser(tokens); //LangParser.decl_return r = parser.decl(); LangParser.start_return r = parser.start(); Console.Out.WriteLine("tree: " + ((ITree)r.Tree).ToStringTree()); CommonTree r0 = ((CommonTree)r.Tree); CommonTreeNodeStream nodes = new CommonTreeNodeStream(r0); nodes.TokenStream = tokens; LangDumpDecl walker = new LangDumpDecl(nodes); walker.decl(); } else { Console.Error.WriteLine("Usage: TreeParser <input-file>"); } }
public static void Main(string[] args) { try { if (args.Length > 0) { // for each directory/file specified on the command line for (int i = 0; i < args.Length; i++) { string fullpath; if (Path.IsPathRooted(args[i])) { fullpath = args[i]; } else { fullpath = Path.Combine(Environment.CurrentDirectory, args[i]); } ProcessFileOrDirectory(new FileInfo(fullpath)); // parse it } } else { Console.Error.WriteLine("Usage: Import <directory or file name>"); } } catch (Exception e) { Console.Error.WriteLine("exception: " + e); Console.Error.WriteLine(e.StackTrace); // so we can get stack trace } }
public static void Main(string[] args) { // Use a try/catch block for parser exceptions try { // if we have at least one command-line argument if (args.Length > 0) { Console.Error.WriteLine("Parsing..."); // for each directory/file specified on the command line for (int i = 0; i < args.Length; i++) { string fullpath; if (Path.IsPathRooted(args[i])) { fullpath = args[i]; } else { fullpath = Path.Combine(Environment.CurrentDirectory, args[i]); } ProcessFileOrDirectory(new FileInfo(fullpath)); // parse it } } else { Console.Error.WriteLine("Usage: JavaParser <list-of-directory-or-filename>"); } } catch (System.Exception e) { Console.Error.WriteLine("exception: " + e); Console.Error.WriteLine(e.StackTrace); // so we can get stack trace } }
private void StartComputingBtn_Click(object sender, RoutedEventArgs e) { if (!Path.IsPathRooted(FileTb.Text)) { MessageBox.Show("File path is not valid"); return; } if (PhaseFirstTimeCb.SelectedItem == null || PhaseSecTimeCb.SelectedItem == null || PhaseFirstUnitCb.SelectedItem == null || PhaseSecUnitCb.SelectedItem == null) { MessageBox.Show("Phases' durations are not filled correctly"); return; } if (HowManyTasksCb.SelectedItem == null) { MessageBox.Show("There is not specified how many tasks perform computing"); return; } if ((!((bool)TlpRb.IsChecked) && !((bool)ThreadPoolRb.IsChecked))) { MessageBox.Show("There is not specified which mechanism should be used to compute "); return; } RunComputing(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Cleans the name of the project given the project type. (e.g. For an XML type, this /// will ensure that the name is rooted and ends with the correct extension) /// </summary> /// <param name="type">The type of the project.</param> /// <param name="name">The name of the project.</param> /// <returns>The cleaned up name with the appropriate extension</returns> /// ------------------------------------------------------------------------------------ private static string CleanUpNameForType(BackendProviderType type, string name) { if (string.IsNullOrEmpty(name)) { return(null); } string ext; switch (type) { case BackendProviderType.kXML: ext = LcmFileHelper.ksFwDataXmlFileExtension; break; default: return(name); } if (!SysPath.IsPathRooted(name)) { string sProjName = (SysPath.GetExtension(name) == ext) ? SysPath.GetFileNameWithoutExtension(name) : name; name = SysPath.Combine(SysPath.Combine(FwDirectoryFinder.ProjectsDirectory, sProjName), name); } // If the file doesn't have the expected extension and exists with the extension or // does not exist without it, we add the expected extension. if (SysPath.GetExtension(name) != ext && (FileUtils.SimilarFileExists(name + ext) || !FileUtils.SimilarFileExists(name))) { name += ext; } return(name); }
public static void Main(string[] args) { if (args.Length > 0) { try { string inputFileName = args[0]; if (!Path.IsPathRooted(inputFileName)) { inputFileName = Path.Combine(Environment.CurrentDirectory, inputFileName); } ICharStream input = new ANTLRFileStream(inputFileName); XML lexer = new XML(input); while (lexer.NextToken() != Token.EOF_TOKEN) { ; } } catch (Exception ex) { Console.Out.WriteLine("exception: " + ex); Console.Out.WriteLine(ex.StackTrace); } } else { Console.Error.WriteLine("Usage: xmlLexer <input-file>"); } }
/** Load a template from dir or group file. Group file is given * precedence over dir with same name. */ protected override CompiledTemplate Load(string name) { string parent = Utility.GetPrefix(name); if (Path.IsPathRooted(parent)) { throw new ArgumentException(); } Uri groupFileURL = null; try { // see if parent of template name is a group file groupFileURL = new Uri(Path.Combine(root.LocalPath, parent) + ".stg"); } catch (UriFormatException e) { ErrorManager.InternalError(null, "bad URL: " + Path.Combine(root.LocalPath, parent) + ".stg", e); return(null); } if (!File.Exists(groupFileURL.LocalPath)) { return(LoadTemplateFile(parent, name + ".st")); } #if false InputStream @is = null; try { @is = groupFileURL.openStream(); } catch (FileNotFoundException fnfe) { // must not be in a group file return(loadTemplateFile(parent, name + ".st")); // load t.st file } catch (IOException ioe) { errMgr.internalError(null, "can't load template file " + name, ioe); } try { // clean up if (@is != null) { @is.close(); } } catch (IOException ioe) { errMgr.internalError(null, "can't close template file stream " + name, ioe); } #endif LoadGroupFile(parent, Path.Combine(root.LocalPath, parent) + ".stg"); return(RawGetTemplate(name)); }
/// <summary> /// Generates the doctests given the extracted doctests from the input file. /// </summary> /// <param name="doctests">Extracted doctests from the input file</param> /// <param name="relativeInputPath">Relative path to the input file</param> /// <param name="outputPath">Absolute path to the output doctest file</param> /// <returns>true if there is at least one generated doctest</returns> /// <exception cref="ArgumentException"></exception> public static bool Generate( List <Extraction.Doctest> doctests, string relativeInputPath, string outputPath) { // Pre-condition(s) if (!Path.IsPathRooted(outputPath)) { throw new ArgumentException($"Expected a rooted outputPath, but got: {outputPath}"); } // Implementation if (doctests.Count == 0) { return(false); } System.IO.Directory.CreateDirectory(Path.GetDirectoryName(outputPath)); string identifier = Identifier(relativeInputPath); using var streamWriter = new System.IO.StreamWriter(outputPath); Generation.Generate(doctests, identifier, streamWriter); return(true); }
/** * Return the location where ANTLR will generate output files for a given * file. This is a base directory and output files will be relative to * here in some cases such as when -o option is used and input files are * given relative to the input directory. * * @param fileNameWithPath path to input source */ public virtual string GetOutputDirectory(string fileNameWithPath) { string outputDir; string fileDirectory; // Some files are given to us without a PATH but should should // still be written to the output directory in the relative path of // the output directory. The file directory is either the set of sub directories // or just or the relative path recorded for the parent grammar. This means // that when we write the tokens files, or the .java files for imported grammars // taht we will write them in the correct place. if (fileNameWithPath.LastIndexOfAny(new[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar }) == -1) { // No path is included in the file name, so make the file // directory the same as the parent grammar (which might sitll be just "" // but when it is not, we will write the file in the correct place. fileDirectory = "."; } else { fileDirectory = fileNameWithPath.Substring(0, fileNameWithPath.LastIndexOfAny(new[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar })); } if (haveOutputDir) { // -o /tmp /var/lib/t.g4 => /tmp/T.java // -o subdir/output /usr/lib/t.g4 => subdir/output/T.java // -o . /usr/lib/t.g4 => ./T.java if (fileDirectory != null && (Path.IsPathRooted(fileDirectory) || fileDirectory.StartsWith("~"))) { // isAbsolute doesn't count this :( // somebody set the dir, it takes precedence; write new file there outputDir = outputDirectory; } else { // -o /tmp subdir/t.g4 => /tmp/subdir/t.g4 if (fileDirectory != null) { outputDir = Path.Combine(outputDirectory, fileDirectory); } else { outputDir = outputDirectory; } } } else { // they didn't specify a -o dir so just write to location // where grammar is, absolute or relative, this will only happen // with command line invocation as build tools will always // supply an output directory. outputDir = fileDirectory; } return outputDir; }
/// <summary> /// Gets a value indicating whether the specified path string contains a root. /// </summary> /// <param name="path">The path to test.</param> /// <returns> /// <see langword="true"/> if <paramref name="path"/> contains a root; otherwise, /// <see langword="false"/>. /// </returns> public static bool IsPathRooted(string path) { #if PORTABLE throw Portable.NotImplementedException; #else return(BclPath.IsPathRooted(path)); #endif }
/// <summary> /// Gets a value indicating whether the specified path string contains a root. /// </summary> /// <param name="path">The path to test.</param> /// <returns> /// <see langword="true"/> if <paramref name="path"/> contains a root; otherwise, /// <see langword="false"/>. /// </returns> public static bool IsPathRooted(string path) { throw Portable.NotImplementedException; #else return BclPath.IsPathRooted(path); }
public static string InputPath(string relativePath, DirectoryInfo input) { if (Path.IsPathRooted(relativePath)) { throw new ArgumentException($"Expected a relative path, but got a rooted one: {relativePath}"); } return(Path.Join(input.FullName, relativePath)); }
private static int Handle(string[] inputs, FileInfo schema) { string schemaText = System.IO.File.ReadAllText(schema.FullName); var jSchema = Newtonsoft.Json.Schema.JSchema.Parse(schemaText); string cwd = System.IO.Directory.GetCurrentDirectory(); bool failed = false; foreach (string pattern in inputs) { IEnumerable <string> paths; if (Path.IsPathRooted(pattern)) { var root = Path.GetPathRoot(pattern); if (root == null) { throw new ArgumentException( $"Root could not be retrieved from rooted pattern: {pattern}"); } var relPattern = Path.GetRelativePath(root, pattern); paths = GlobExpressions.Glob.Files(root, relPattern) .Select((path) => Path.Join(root, relPattern)); } else { paths = GlobExpressions.Glob.Files(cwd, pattern) .Select((path) => Path.Join(cwd, path)); } foreach (string path in paths) { string text = System.IO.File.ReadAllText(path); var jObject = Newtonsoft.Json.Linq.JObject.Parse(text); bool valid = jObject.IsValid(jSchema, out IList <string> messages); if (!valid) { Console.Error.WriteLine($"FAIL: {path}"); foreach (string message in messages) { Console.Error.WriteLine(message); } failed = true; } else { Console.WriteLine($"OK: {path}"); } } } return((failed) ? 1 : 0); }
FileTarget(Graph graph, string path) : base(graph) { Guard.Required(path, nameof(path)); if (!IOPath.IsPathRooted(path)) { throw new ArgumentException("Not an absolute path", nameof(path)); } Path = IOPath.GetFullPath(path); }
private void NavigateFile(string file) { if (!Path.IsPathRooted(file)) { file = Path.GetFullPath(Path.Combine(App.CurrentRootPath, this.ViewModel.Profile.ProjectName, "Config", file)); } Helpers.NavigateFile(file); }
private static Tuple <string, TempDirectoryHelper> BuildXnb(IServiceLocator services, string applicationName, string fileName, bool createModelNode, bool recreateModelAndMaterialFiles) { Debug.Assert(services != null); Debug.Assert(applicationName != null); Debug.Assert(applicationName.Length > 0); Debug.Assert(fileName != null); Debug.Assert(fileName.Length > 0); var tempDirectoryHelper = new TempDirectoryHelper(applicationName, "ModelDocument"); try { var contentBuilder = new GameContentBuilder(services) { IntermediateFolder = tempDirectoryHelper.TempDirectoryName + "\\obj", OutputFolder = tempDirectoryHelper.TempDirectoryName + "\\bin", }; string processorName; var processorParams = new OpaqueDataDictionary(); if (createModelNode) { processorName = "GameModelProcessor"; processorParams.Add("RecreateModelDescriptionFile", recreateModelAndMaterialFiles); processorParams.Add("RecreateMaterialDefinitionFiles", recreateModelAndMaterialFiles); } else { processorName = "ModelProcessor"; } string errorMessage; bool success = contentBuilder.Build(Path.GetFullPath(fileName), null, processorName, processorParams, out errorMessage); if (!success) { throw new EditorException(Invariant($"Could not process 3d model: {fileName}.\n See output window for details.")); } // Return output folder into which we built the XNB. var outputFolder = contentBuilder.OutputFolder; if (!Path.IsPathRooted(outputFolder)) { outputFolder = Path.GetFullPath(Path.Combine(contentBuilder.ExecutableFolder, contentBuilder.OutputFolder)); } return(Tuple.Create(outputFolder, tempDirectoryHelper)); } catch { tempDirectoryHelper.Dispose(); throw; } }
/** Load full path name .st file relative to root by prefix */ public virtual CompiledTemplate LoadTemplateFile(string prefix, string fileName) { if (Path.IsPathRooted(fileName)) { throw new ArgumentException(); } //System.out.println("load "+fileName+" from "+root+" prefix="+prefix); string templateName = Path.ChangeExtension(fileName, null); Uri f = null; try { f = new Uri(Path.Combine(root.LocalPath, fileName)); } catch (UriFormatException me) { ErrorManager.RuntimeError(null, 0, ErrorType.INVALID_TEMPLATE_NAME, me, Path.Combine(root.LocalPath, fileName)); return(null); } ANTLRReaderStream fs = null; try { fs = new ANTLRReaderStream(new StreamReader(f.LocalPath, Encoding ?? Encoding.UTF8)); } catch (IOException) { // doesn't exist; just return null to say not found return(null); } GroupLexer lexer = new GroupLexer(fs); fs.name = fileName; CommonTokenStream tokens = new CommonTokenStream(lexer); GroupParser parser = new GroupParser(tokens); parser.Group = this; lexer.group = this; try { parser.templateDef(prefix); } catch (RecognitionException re) { ErrorManager.GroupSyntaxError(ErrorType.SYNTAX_ERROR, Path.GetFileName(f.LocalPath), re, re.Message); } return(RawGetTemplate(templateName)); }
public static string OutputPath(string relativePath, DirectoryInfo output) { if (Path.IsPathRooted(relativePath)) { throw new ArgumentException($"Expected a relative path, but got a rooted one: {relativePath}"); } string doctestRelativePath = Path.Join( Path.GetDirectoryName(relativePath), "DocTest" + Path.GetFileName(relativePath)); return(Path.Join(output.FullName, doctestRelativePath)); }
private static void ReadConfigFile() { configDoc = new XmlDocument(); string configFileName = Path.Combine(applDir, applName + ".xml"); configDoc.Load(configFileName); string logFileName0 = GetConfigParm("logFile"); logFileName = Path.IsPathRooted(logFileName0) ? logFileName0 : Path.Combine(applDir, logFileName0); logLevel = GetConfigParmInt("logLevel"); ReadGatewayConfigs(); configDoc = null; }
public override bool Execute() { AppDomain domain = null; bool success; if (!Path.IsPathRooted(ToolPath)) { ToolPath = Path.Combine(Path.GetDirectoryName(BuildEngine.ProjectFileOfTaskNode), ToolPath); } if (!Path.IsPathRooted(BuildTaskPath)) { BuildTaskPath = Path.Combine(Path.GetDirectoryName(BuildEngine.ProjectFileOfTaskNode), BuildTaskPath); } try { domain = GetAntlrTaskAppDomain(); AntlrClassGenerationTaskInternal wrapper = CreateBuildTaskWrapper(domain); success = wrapper.Execute(); if (success) { _generatedCodeFiles.AddRange(wrapper.GeneratedCodeFiles.Select(file => (ITaskItem) new TaskItem(file))); } foreach (BuildMessage message in wrapper.BuildMessages) { ProcessBuildMessage(message); } } catch (Exception exception) { if (IsFatalException(exception)) { throw; } ProcessExceptionAsBuildMessage(exception); success = false; } finally { if (domain != null && domain != _sharedAppDomain) { AppDomain.Unload(domain); } } return(success); }
public override bool Execute() { bool success; if (!Path.IsPathRooted(AntlrToolPath)) { AntlrToolPath = Path.Combine(Path.GetDirectoryName(BuildEngine.ProjectFileOfTaskNode), AntlrToolPath); } if (!Path.IsPathRooted(BuildTaskPath)) { BuildTaskPath = Path.Combine(Path.GetDirectoryName(BuildEngine.ProjectFileOfTaskNode), BuildTaskPath); } try { AntlrClassGenerationTaskInternal wrapper = CreateBuildTaskWrapper(); _lock.Wait(); try { success = wrapper.Execute(); } finally { _lock.Release(); } if (success) { _generatedCodeFiles.AddRange(wrapper.GeneratedCodeFiles.Select(file => (ITaskItem) new TaskItem(file))); } foreach (BuildMessage message in wrapper.BuildMessages) { ProcessBuildMessage(message); } } catch (Exception exception) { if (IsFatalException(exception)) { throw; } ProcessExceptionAsBuildMessage(exception); success = false; } return(success); }
/** * Convert an object of type T to JSON representation, and output to a file. * If filename is not an absolute path, it will be relative to the * Application's dataPath. */ public void Persist(string filename, T settings) { string dstFilePath = filename; if (!Path.IsPathRooted(dstFilePath)) // If relative path, base at dataPath. { dstFilePath = Path.Combine(Application.dataPath, dstFilePath); } if (!Directory.Exists(Path.GetDirectoryName(dstFilePath))) // If directory doesnt exist create it. { Directory.CreateDirectory(Path.GetDirectoryName(dstFilePath)); } File.WriteAllText(dstFilePath, JsonUtility.ToJson(settings)); }
/// <summary> /// Infers the identifier for the test suite based on the relative path to the input file. /// </summary> /// <param name="relativeInputPath">path to the input file, relative</param> /// <returns>Valid C# class identifier</returns> public static string Identifier(string relativeInputPath) { if (relativeInputPath.Length == 0) { throw new ArgumentException($"Unexpected empty {nameof(relativeInputPath)}"); } if (Path.IsPathRooted(relativeInputPath)) { throw new ArgumentException( $"Unexpected rooted {nameof(relativeInputPath)}: {relativeInputPath}"); } return($"DocTest_{nonidentifierCharRe.Replace(relativeInputPath, "_")}"); }
private static string GetRootedPath(string rootPath, string?inputPath) { if (!string.IsNullOrEmpty(inputPath)) { if (Path.IsPathRooted(inputPath)) { rootPath = inputPath; } else { rootPath = Path.GetFullPath(inputPath, rootPath); } } return(rootPath); }
/// <summary> /// Check if the given path is a well-formed absolute path. /// If not, throw and <see cref="AxeWindowsAutomationException"/>. /// </summary> /// <param name="path"></param> /// <exception cref="AxeWindowsAutomationException"/> private void VerifyPathOrThrow(string path) { try { // the following throws various exceptions if the given path is invalid Path.GetFullPath(path); if (!Path.IsPathRooted(path)) { throw new Exception(DisplayStrings.ErrorIsNotFullPath); } } catch (Exception ex) { throw new AxeWindowsAutomationException(string.Format(CultureInfo.InvariantCulture, DisplayStrings.ErrorDirectoryInvalid, path), ex); } }
/** * Read the contents of a file and parse it as a JSON object of type T. * If filename is not an absolute path, it will be relative to the * Application's dataPath. */ public T Load(string filename) { string srcFilePath = filename; if (!Path.IsPathRooted(srcFilePath)) // If relative path, base at dataPath. { srcFilePath = Path.Combine(Application.dataPath, srcFilePath); } if (!File.Exists(srcFilePath)) // If file doesn't exist throw an error. { Debug.Log("Error loading setting file. File " + srcFilePath + " does not exist."); throw new Exception("No file " + srcFilePath); } T settings = JsonUtility.FromJson <T>(File.ReadAllText(srcFilePath)); return(settings); }
public static void writeFile(string dir, string fileName, string content) { if (Path.IsPathRooted(fileName)) { throw new ArgumentException(); } string fullPath = Path.GetFullPath(Path.Combine(dir, fileName)); dir = Path.GetDirectoryName(fullPath); if (!Directory.Exists(dir)) { Directory.CreateDirectory(dir); } File.WriteAllText(fullPath, content); }
/** Load full path name .st file relative to root by prefix */ public virtual CompiledTemplate LoadTemplateFile(string prefix, string unqualifiedFileName) { if (Path.IsPathRooted(unqualifiedFileName)) { throw new ArgumentException(); } if (Verbose) { Console.WriteLine("loadTemplateFile({0}) in groupdir from {1} prefix={2}", unqualifiedFileName, root, prefix); } string templateName = Path.ChangeExtension(unqualifiedFileName, null); Uri f; try { f = new Uri(root.LocalPath + prefix + unqualifiedFileName); } catch (UriFormatException me) { ErrorManager.RuntimeError(null, ErrorType.INVALID_TEMPLATE_NAME, me, Path.Combine(root.LocalPath, unqualifiedFileName)); return(null); } ANTLRReaderStream fs = null; try { fs = new ANTLRReaderStream(new StreamReader(File.OpenRead(f.LocalPath), Encoding)); fs.name = unqualifiedFileName; } catch (IOException) { if (Verbose) { Console.WriteLine("{0}/{1} doesn't exist", root, unqualifiedFileName); } //errMgr.IOError(null, ErrorType.NO_SUCH_TEMPLATE, ioe, unqualifiedFileName); return(null); } return(LoadTemplateFile(prefix, unqualifiedFileName, fs)); }