public bool SourceRemove(CodeSource aSource) { CodeSourceManager manager = iManager.Plugin.SourceManager; bool removed = manager.Remove(aSource); return(removed); }
private void Skip(CodeSource aSource) { System.Diagnostics.Debug.Assert(aSource.TimeToRead == CodeSource.TTimeToRead.EReadWhenNeeded); bool primeCompleted = base.AddToCompleted(aSource); CheckForCompletion(primeCompleted); }
private void Source_EventHandler(CodeSource.TEvent aEvent, CodeSource aSource, object aData) { bool primeCompleted = false; // Map source event onto a primer event if (aEvent == CodeSource.TEvent.EReadingProgress) { base.SaveLatestProgress(aSource, (int)aData); } // If all sources are complete, then are we also done? if (aEvent == CodeSource.TEvent.EReadingComplete) { // We don't need to listen to this source anymore aSource.EventHandler -= new CodeSource.EventHandlerFunction(Source_EventHandler); // Source is 100% complete now. base.SaveLatestProgress(aSource, 100); // It's complete, so record as such so that we can tell when all the sources // are now ready. primeCompleted = base.AddToCompleted(aSource); } CheckForCompletion(primeCompleted); }
private ParsingError GenerateError(string data, string codeFileName, int line, int column, string rest, bool isWarning = false) { ParsingError error; TextSpan textSpan; if (_grammarCodeMapping.TryGetValue(codeFileName, out List <TextSpanMapping> textSpanMappings)) { string grammarFileName = GetGrammarFromCodeFileName(_currentRuntimeInfo, codeFileName); textSpan = TextHelpers.GetSourceTextSpanForLine(textSpanMappings, line, grammarFileName); error = new ParsingError(textSpan, $"{grammarFileName}:{textSpan.GetLineColumn().BeginLine}:{rest}", WorkflowStage.ParserCompiled, isWarning); } else { Dictionary <string, CodeSource> grammarFilesData = _result.ParserGeneratedState.GrammarCheckedState.GrammarFilesData; CodeSource codeSource = grammarFilesData.FirstOrDefault(file => file.Key.EndsWith(codeFileName, StringComparison.OrdinalIgnoreCase)).Value; textSpan = codeSource != null ? new LineColumnTextSpan(line, column, codeSource).GetTextSpan() : TextSpan.Empty; error = new ParsingError(textSpan, data, WorkflowStage.ParserCompiled, isWarning); } return(error); }
public bool SourceAdd(CodeSource aSource) { CodeSourceManager manager = iManager.Plugin.SourceManager; bool added = manager.Add(aSource); return(added); }
public void ParserGeneratedStageErrors() { var grammarText = $@"grammar {TestGrammarName}; start: rule1+; rule: DIGIT; CHAR: [a-z]+; DIGIT: [0-9]+; WS: [ \r\n\t]+ -> skip;"; var workflow = new Workflow(GrammarFactory.CreateDefaultCombinedAndFill(grammarText, TestGrammarName, ".")); var state = workflow.Process(); Assert.AreEqual(WorkflowStage.ParserGenerated, state.Stage, state.Exception?.ToString()); var grammarSource = new CodeSource(TestGrammarName + ".g4", File.ReadAllText(TestGrammarName + ".g4")); char separator = Path.DirectorySeparatorChar; string testGrammarFullName = $"{Environment.CurrentDirectory}{separator}.{separator}{TestGrammarName}.g4"; ParserGeneratedState parserGeneratedState = state as ParserGeneratedState; string str = new ParsingError(2, 24, $"error(56): {testGrammarFullName}:2:24: reference to undefined rule: rule1", grammarSource, WorkflowStage.ParserGenerated).ToString(); CollectionAssert.AreEquivalent( new [] { new ParsingError(2, 24, $"error(56): {testGrammarFullName}:2:24: reference to undefined rule: rule1", grammarSource, WorkflowStage.ParserGenerated), }, parserGeneratedState.Errors); }
private void GetGeneratedFileNames(GrammarCheckedState grammarCheckedState, string generatedGrammarName, string workingDirectory, List <string> generatedFiles, bool lexer) { string grammarNameExt; if (_grammar.Type == GrammarType.Combined) { grammarNameExt = _grammar.Files.FirstOrDefault(file => Path.GetExtension(file) .Equals(Grammar.AntlrDotExt, StringComparison.OrdinalIgnoreCase)); } else { string postfix = lexer ? Grammar.LexerPostfix : Grammar.ParserPostfix; grammarNameExt = _grammar.Files.FirstOrDefault(file => file.Contains(postfix) && Path.GetExtension(file).Equals(Grammar.AntlrDotExt, StringComparison.OrdinalIgnoreCase)); } string shortGeneratedFile = generatedGrammarName + (lexer ? _currentRuntimeInfo.LexerPostfix : _currentRuntimeInfo.ParserPostfix) + "." + _currentRuntimeInfo.Extensions[0]; string generatedFileDir = workingDirectory; Runtime runtime = _currentRuntimeInfo.Runtime; if ((runtime == Runtime.Java || runtime == Runtime.Go) && !string.IsNullOrWhiteSpace(_result.ParserGeneratedState.PackageName)) { generatedFileDir = Path.Combine(generatedFileDir, _result.ParserGeneratedState.PackageName); } string generatedFile = Path.Combine(generatedFileDir, shortGeneratedFile); generatedFiles.Add(generatedFile); CodeSource codeSource = new CodeSource(generatedFile, File.ReadAllText(generatedFile)); _grammarCodeMapping[shortGeneratedFile] = TextHelpers.Map(grammarCheckedState.GrammarActionsTextSpan[grammarNameExt], codeSource, lexer); }
public static string GetCodeSourceLocation() { var f = default(FileInfo); try { // Error 40 The call is ambiguous between the following methods or properties: 'ScriptCoreLibJava.Extensions.BCLImplementationExtensions.ToClass(System.Type)' and 'ScriptCoreLibJava.Extensions.BCLImplementationExtensions.ToClass(System.Type)' X:\jsc.svn\core\ScriptCoreLib.Ultra\ScriptCoreLib.Ultra\Java\Interop\CodeSourceLocationProvider.cs 22 27 ScriptCoreLib.Ultra var cls = BCLImplementationExtensions.ToClass(typeof(CodeSourceLocationProvider)); ProtectionDomain pDomain = cls.getProtectionDomain(); CodeSource cSource = pDomain.getCodeSource(); URL loc = cSource.getLocation(); var ff = loc.getFile(); var prefix = "file:/"; if (prefix == ff.Substring(0, prefix.Length)) { ff = ff.Substring(prefix.Length); } f = new FileInfo(ff); } catch { throw new NotSupportedException(); } return(f.FullName); }
private static void EnsureCodeSource(CodeSource cSource) { if (cSource == null) { throw new InvalidOperationException(); } }
/* * Defines a Class using the class bytes obtained from the specified * Resource. The resulting Class must be resolved before it can be * used. */ //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private Class defineClass(String name, sun.misc.Resource res) throws java.io.IOException private Class DefineClass(String name, Resource res) { long t0 = System.nanoTime(); int i = name.LastIndexOf('.'); URL url = res.CodeSourceURL; if (i != -1) { String pkgname = name.Substring(0, i); // Check if package already loaded. Manifest man = res.Manifest; DefinePackageInternal(pkgname, man, url); } // Now read the class bytes and define the class java.nio.ByteBuffer bb = res.ByteBuffer; if (bb != null) { // Use (direct) ByteBuffer: CodeSigner[] signers = res.CodeSigners; CodeSource cs = new CodeSource(url, signers); sun.misc.PerfCounter.ReadClassBytesTime.addElapsedTimeFrom(t0); return(DefineClass(name, bb, cs)); } else { sbyte[] b = res.Bytes; // must read certificates AFTER reading bytes. CodeSigner[] signers = res.CodeSigners; CodeSource cs = new CodeSource(url, signers); sun.misc.PerfCounter.ReadClassBytesTime.addElapsedTimeFrom(t0); return(DefineClass(name, b, 0, b.Length, cs)); } }
public void SeparatedLexerAndParserErrors() { var lexerText = $@"lexer grammar {TestGrammarName}; CHAR: a-z]+; DIGIT: [0-9]+; WS: [ \r\n\t]+ -> skip;"; var parserText = $@"parser grammar {TestGrammarName}; start: DIGIT+; #"; var workflow = new Workflow(GrammarFactory.CreateDefaultSeparatedAndFill(lexerText, parserText, TestGrammarName, ".")); var state = workflow.Process(); Assert.AreEqual(WorkflowStage.GrammarChecked, state.Stage, state.Exception?.ToString()); var testLexerSource = new CodeSource(TestGrammarName + "Lexer.g4", File.ReadAllText(TestGrammarName + "Lexer.g4")); var testParserSource = new CodeSource(TestGrammarName + "Parser.g4", File.ReadAllText(TestGrammarName + "Parser.g4")); GrammarCheckedState grammarCheckedState = state as GrammarCheckedState; CollectionAssert.AreEquivalent( new [] { new ParsingError(2, 25, $"error: {TestGrammarName}Lexer.g4:2:25: token recognition error at: '-z'", testLexerSource, WorkflowStage.GrammarChecked), new ParsingError(2, 27, $"error: {TestGrammarName}Lexer.g4:2:27: token recognition error at: ']'", testLexerSource, WorkflowStage.GrammarChecked), new ParsingError(2, 28, $"error: {TestGrammarName}Lexer.g4:2:28: mismatched input '+' expecting {{ASSIGN, PLUS_ASSIGN}}", testLexerSource, WorkflowStage.GrammarChecked), new ParsingError(3, 16, $"error: {TestGrammarName}Parser.g4:3:16: extraneous input '#' expecting {{<EOF>, 'mode'}}", testParserSource, WorkflowStage.GrammarChecked) }, grammarCheckedState.Errors); }
private void AddCSharpError(string data) { if (data.Contains(": error CS")) { var errorString = Helpers.FixEncoding(data); ParsingError error; CodeSource grammarSource = CodeSource.Empty; try { // Format: // Lexer.cs(106,11): error CS0103: The name 'a' does not exist in the current context var strs = errorString.Split(':'); int leftParenInd = strs[0].IndexOf('('); string codeFileName = strs[0].Remove(leftParenInd); string grammarFileName = GetGrammarFromCodeFileName(_currentRuntimeInfo, codeFileName); string lineColumnString = strs[0].Substring(leftParenInd); lineColumnString = lineColumnString.Substring(1, lineColumnString.Length - 2); // Remove parenthesis. var strs2 = lineColumnString.Split(','); int line = int.Parse(strs2[0]); int column = int.Parse(strs2[1]); string rest = string.Join(":", strs.Skip(1)); error = GenerateError(data, codeFileName, line, column, rest); } catch { error = new ParsingError(errorString, grammarSource, WorkflowStage.ParserCompiled); } AddError(error); } }
public void TestConstructor() { var source = new CodeSource(); Assert.AreNotEqual(string.Empty, source.CodePK); Assert.DoesNotThrow(() => new Guid(source.CodePK)); }
public static void Main(string[] args) { if (args.Length < 2) { Console.WriteLine("wtf dude give some files: <output> <file.lah...>"); } var outname = args[0]; var sources = new string[] { "stdlib/mem.lah", "stdlib/collections.lah", "stdlib/math.lah" }.Concat(args.Skip(1)); foreach (var file in args.Skip(1)) { Console.WriteLine($"Compiling {file}"); } var multiSource = new MultiCodeSource(sources.Select(x => CodeSource.FromFile(x)).ToArray()); Console.WriteLine(multiSource.Content); var parser = new LahdaParser(new LahdaLexer(new CompilationConfiguration(multiSource))); var output = new StringBuilderOutput(); var codeGen = new CodeGenerator(output, parser.Root()); codeGen.Build(); if (File.Exists(outname)) { File.Delete(outname); } File.WriteAllText(outname, output.ToString()); }
void UpdateIndex(string fullPath, PendingRetrySource pendingRetrySource = null) { if (IsFile(fullPath)) { var fileInfo = new FileInfo(fullPath); try { Thread.Sleep(WaitMilliseconds); // Wait to let file finished write to disk if (fileInfo.Exists) { var content = FilesContentHelper.ReadAllText(fullPath); var document = CodeIndexBuilder.GetDocumentFromSource(CodeSource.GetCodeSource(fileInfo, content)); CodeIndexBuilder.UpdateIndex(config.LuceneIndexForCode, GetNoneTokenizeFieldTerm(nameof(CodeSource.FilePath), fullPath), document); WordsHintBuilder.UpdateWordsHint(config, WordSegmenter.GetWords(content), log); pendingChanges++; } } catch (IOException) { AddFileChangesToRetrySouce(fullPath, WatcherChangeTypes.Changed, pendingRetrySource); } catch (Exception ex) { log?.Error(ex.ToString()); } } }
/* * Create a unique mapping from codeSigner cache entries to CodeSource. * In theory, multiple URLs origins could map to a single locally cached * and shared JAR file although in practice there will be a single URL in use. */ private CodeSource MapSignersToCodeSource(URL url, CodeSigner[] signers) { lock (this) { Map <CodeSigner[], CodeSource> map; if (url == LastURL) { map = LastURLMap; } else { map = UrlToCodeSourceMap.Get(url); if (map == null) { map = new HashMap <>(); UrlToCodeSourceMap.Put(url, map); } LastURLMap = map; LastURL = url; } CodeSource cs = map.Get(signers); if (cs == null) { cs = new VerifierCodeSource(Csdomain, url, signers); SignerToCodeSource.Put(signers, cs); } return(cs); } }
protected OptionMatcher(CodeSource codeSource, GrammarType grammarType, Action <ParsingError> errorEvent) { Regex = new Regex($@"({Name})\s*=\s*(\w+);", RegexOptions.IgnoreCase | RegexOptions.Compiled); CodeSource = codeSource ?? throw new ArgumentNullException(nameof(codeSource)); GrammarType = grammarType; ErrorAction = errorEvent ?? throw new ArgumentNullException(nameof(errorEvent)); }
public void Parse(CodeSource source, string fileName, IEnumerable <string> parentFiles, bool visible) { if (source == null) { throw new ArgumentNullException("source"); } _source = source; _code = new CodeParser(_source.Text); _fileName = fileName; _parentFiles = parentFiles.ToArray(); FunctionFileScanning.FFUtil.FileNameIsClass(_fileName, out _className); var scope = new Scope(this, 0, ScopeHint.None, visible, _model.DefinitionProvider); scope.ClassName = _className; Scope = scope; while (_code.SkipWhiteSpace()) { var stmt = StatementToken.TryParse(scope); if (stmt != null) { AddToken(stmt); } } Span = new Span(0, _code.Length); }
public void TestGetDocumentFromSource() { var codeSource = new CodeSource { FileName = "Dummy File 2", FileExtension = "cs", FilePath = @"C:\Dummy File 2.cs", Content = "Test Content" + Environment.NewLine + "A New Line For Test" }; var document = IndexBuilderHelper.GetDocumentFromSource(codeSource); Assert.AreEqual(9, document.Fields.Count); Assert.NotNull(document.Get(nameof(CodeSource.FilePath) + Constants.NoneTokenizeFieldSuffix)); Assert.NotNull(document.Get(nameof(CodeSource.Content) + Constants.CaseSensitive)); var convertBack = document.GetObject <CodeSource>(); Assert.AreEqual(codeSource.FilePath, convertBack.FilePath); Assert.AreEqual(codeSource.Content, convertBack.Content); Assert.AreEqual(codeSource.IndexDate, convertBack.IndexDate); Assert.AreEqual(codeSource.LastWriteTimeUtc, convertBack.LastWriteTimeUtc); Assert.AreEqual(codeSource.CodePK, convertBack.CodePK); Assert.AreEqual(codeSource.FileName, convertBack.FileName); Assert.AreEqual(codeSource.FileExtension, convertBack.FileExtension); Assert.AreEqual(codeSource.Info, convertBack.Info); }
public List <FileInfo> BuildIndexByBatch(IEnumerable <FileInfo> fileInfos, bool needCommit, bool triggerMerge, bool applyAllDeletes, CancellationToken cancellationToken, bool brandNewBuild, int batchSize = 10000) { cancellationToken.ThrowIfCancellationRequested(); fileInfos.RequireNotNull(nameof(fileInfos)); batchSize.RequireRange(nameof(batchSize), int.MaxValue, 50); var codeDocuments = new List <Document>(); var wholeWords = new HashSet <string>(); var newHintWords = new HashSet <string>(); var failedIndexFiles = new List <FileInfo>(); try { foreach (var fileInfo in fileInfos) { cancellationToken.ThrowIfCancellationRequested(); try { if (fileInfo.Exists) { var source = CodeSource.GetCodeSource(fileInfo, FilesContentHelper.ReadAllText(fileInfo.FullName)); AddHintWords(newHintWords, wholeWords, source.Content); var doc = IndexBuilderHelper.GetDocumentFromSource(source); codeDocuments.Add(doc); Log.LogInformation($"{Name}: Add index for {source.FilePath}"); } } catch (Exception ex) { failedIndexFiles.Add(fileInfo); Log.LogError($"{Name}: Add index for {fileInfo.FullName} failed, exception: " + ex); } if (codeDocuments.Count >= batchSize) { BuildIndex(needCommit, triggerMerge, applyAllDeletes, codeDocuments, newHintWords, cancellationToken, brandNewBuild); codeDocuments.Clear(); newHintWords.Clear(); } } if (codeDocuments.Count > 0) { BuildIndex(needCommit, triggerMerge, applyAllDeletes, codeDocuments, newHintWords, cancellationToken, brandNewBuild); } return(failedIndexFiles); } finally { wholeWords.Clear(); newHintWords.Clear(); codeDocuments.Clear(); } }
public void CanCreateWithContents() { var contents = Guid.NewGuid().ToString(); var actual = new CodeSource(contents); actual.Contents.Should().Be(contents); actual.FilePath.Should().BeEmpty(); }
public ShowMeTheCodeVm GetShowMeTheCode() { codeSource = new CodeSource(); return(new ShowMeTheCodeVm() { URLGitHub = codeSource.URLGitHub }); }
protected void ReportWarning(string message, IToken token, Group group, CodeSource codeSource) { var warningTextSpan = new TextSpan(token.StartIndex + group.Index, group.Length, codeSource); var lineColumn = codeSource.ToLineColumn(warningTextSpan); var error = new ParsingError(warningTextSpan, Helpers.FormatErrorMessage(codeSource, lineColumn.BeginLine, lineColumn.BeginColumn, message, true), WorkflowStage.GrammarChecked, true); ErrorAction(error); }
public static void BuildIndexByBatch(CodeIndexConfiguration config, bool triggerMerge, bool applyAllDeletes, bool needFlush, IEnumerable <FileInfo> fileInfos, bool deleteExistIndex, ILog log, out List <FileInfo> failedIndexFiles, int batchSize = 1000, bool needHint = true) { config.RequireNotNull(nameof(config)); fileInfos.RequireNotNull(nameof(fileInfos)); batchSize.RequireRange(nameof(batchSize), int.MaxValue, 50); var needDeleteExistIndex = deleteExistIndex && IndexExists(config.LuceneIndexForCode); var documents = new List <Document>(); failedIndexFiles = new List <FileInfo>(); foreach (var fileInfo in fileInfos) { try { if (fileInfo.Exists) { var source = CodeSource.GetCodeSource(fileInfo, FilesContentHelper.ReadAllText(fileInfo.FullName)); if (needDeleteExistIndex) { DeleteIndex(config.LuceneIndexForCode, new Term(nameof(CodeSource.FilePath) + Constants.NoneTokenizeFieldSuffix, source.FilePath)); } if (needHint) { WordsHintBuilder.AddWords(WordSegmenter.GetWords(source.Content)); } var doc = GetDocumentFromSource(source); documents.Add(doc); log?.Info($"Add index For {source.FilePath}"); } } catch (Exception ex) { failedIndexFiles.Add(fileInfo); log?.Error($"Add index for {fileInfo.FullName} failed, exception: " + ex.ToString()); } if (documents.Count >= batchSize) { BuildIndex(config, triggerMerge, applyAllDeletes, documents, needFlush, log); documents.Clear(); } } if (documents.Count > 0) { BuildIndex(config, triggerMerge, applyAllDeletes, documents, needFlush, log); } }
private void Compile_Click(object sender, EventArgs e) { Save(); Jun.Tokenizer tokenizer = new Jun.Tokenizer(Context); Jun.Parser parser = new Jun.Parser(Context); try { tokenizer.Tokenize(Source.Source.Split('\n')); } catch (JunException ex) { MessageBox.Show(ex.Message, "Tokenizing Error", MessageBoxButtons.OK, MessageBoxIcon.Error); CodeSource.Focus(); CodeSource.Selection = new Range(CodeSource, tokenizer.Column - 1, tokenizer.Line - 1, tokenizer.Column, tokenizer.Line - 1); return; } try { parser.Parse(tokenizer.Tokens); } catch (JunException ex) { // delete temporary foreach (CompiledScript scr in parser.TemporaryScripts) { Context.Djn.Remove(scr.Resource.ID); } MessageBox.Show(ex.Message, "Parsing Error", MessageBoxButtons.OK, MessageBoxIcon.Error); CodeSource.Focus(); CodeSource.Selection.Start = new Place(0, parser.LineNumber); CodeSource.SelectNext(@"\w+"); return; } // copy all compiled scripts into the container foreach (Jun.Script js in parser.Scripts) { short id = parser.Constants[js.Name]; CompiledScript scr = Context.Djn[id] as CompiledScript; scr.Resource.Flags = js.Public ? ResourceFlags.None : ResourceFlags.Private; scr.Resource.OnlyDesign = false; scr.Bytecode = js.Code.ToArray(); } Context.UnsavedChanges = true; MessageBox.Show("Compiled!"); }
public static Document GetDocumentFromSource(CodeSource source) { return(new Document { new TextField(nameof(source.FileName), source.FileName.ToStringSafe(), Field.Store.YES), // StringField indexes but doesn't tokenize new StringField(nameof(source.FileExtension), source.FileExtension.ToStringSafe(), Field.Store.YES), new StringField(nameof(source.FilePath) + Constants.NoneTokenizeFieldSuffix, source.FilePath.ToStringSafe(), Field.Store.YES), new TextField(nameof(source.FilePath), source.FilePath.ToStringSafe(), Field.Store.YES), new TextField(nameof(source.Content), source.Content.ToStringSafe(), Field.Store.YES), new Int64Field(nameof(source.IndexDate), source.IndexDate.Ticks, Field.Store.YES), new Int64Field(nameof(source.LastWriteTimeUtc), source.LastWriteTimeUtc.Ticks, Field.Store.YES), new StringField(nameof(source.CodePK), source.CodePK.ToString(), Field.Store.YES) }); }
public void CodeGenerator_should_generate_godlike_code(string content, int i) { var codeSource = CodeSource.FromMemory(content); var parser = new LahdaParser(new LahdaLexer(new CompilationConfiguration(codeSource))); var output = new StringBuilderOutput(); var codeGen = new CodeGenerator(output, parser.Root()); codeGen.Build(); var path = $"test_{i}.s"; if (File.Exists(path)) { File.Delete(path); } File.WriteAllText(path, output.ToString()); }
public void TestGetCodeSource() { var dateTime = DateTime.UtcNow; var fileInfo = new FileInfo("AAA.txt"); var source = CodeSource.GetCodeSource(fileInfo, "ABCD"); Assert.AreEqual("AAA.txt", source.FileName); Assert.AreEqual("ABCD", source.Content); Assert.AreEqual("txt", source.FileExtension); Assert.AreEqual(fileInfo.FullName, source.FilePath); Assert.AreEqual(fileInfo.LastWriteTimeUtc, source.LastWriteTimeUtc); Assert.LessOrEqual(dateTime, source.IndexDate); Assert.AreNotEqual(string.Empty, source.CodePK); Assert.DoesNotThrow(() => new Guid(source.CodePK)); Assert.AreEqual($"FileName: {source.FileName}{Environment.NewLine}FilePath: {source.FilePath}{Environment.NewLine}Index Date: {source.IndexDate.ToLocalTime()}{Environment.NewLine}Last Modify Date:{source.LastWriteTimeUtc.ToLocalTime()}", source.Info); }
/// <summary> /// Try to load jar from relative ../lib/ directory for cases when we do not have jars in a class path. </summary> /// <param name="jar"> - path to a jar file to load. </param> /// <returns> loaded jar file </returns> /// <exception cref="EmbeddedJarNotFoundException"> if jar not exist or file name can't be represented as URI. </exception> private File LoadJarFromRelativePath(string jar) { try { CodeSource codeSource = this.GetType().ProtectionDomain.CodeSource; URI uri = codeSource.Location.toURI(); File jarFile = new File(Path.GetDirectoryName(uri), jar); if (!jarFile.exists()) { throw new EmbeddedJarNotFoundException("Jar file '" + jar + "' not found."); } return(jarFile); } catch (URISyntaxException) { throw new EmbeddedJarNotFoundException("Jar file '" + jar + "' not found."); } }
public Expression(string sourceCode, CodeSource format, Module module) { error = module.Error; if (format == CodeSource.FILE) { lex = new FileLex(sourceCode, error); } else { lex = new StringLex(sourceCode, error); } this.module = module; gen = new CodeGeneration(module); vtab = new SymbolTable(Constant.MAX_SYMBOL_TABLE_SIZE, error); }
/** * Answers a PermissionCollection object containing the set of permissions * granted to the specified CodeSource. * * The default implementation of this method returns * Policy.UNSUPPORTED_EMPTY_COLLECTION object. This method can be overridden * if the policy implementation can return a set of permissions granted to a * CodeSource. * * @param codesource - * the CodeSource to which the returned PermissionCollection has * been granted. * @return a set of permissions granted to the specified CodeSource. If this * operation is supported, the returned set of permissions must be a * new mutable instance and it must support heterogeneous Permission * types. If this operation is not supported, * Policy.UNSUPPORTED_EMPTY_COLLECTION is returned. */ protected internal PermissionCollection engineGetPermissions(CodeSource codesource) { return Policy.UNSUPPORTED_EMPTY_COLLECTION; }