public void TestParseExpression() { const string code = @"3 + 2 * 5"; Expression e = BooParser.ParseExpression("test", code); Assert.AreEqual("3 + (2 * 5)", e.ToString()); }
public void RunStringTestCase(string message, string expected, string actual) { CompileUnit cu = RunCompiler(new StringInput("<actual>", actual)); cu.Modules[0].Name = BooParser.CreateModuleName("<expected>"); AssertEquals(message, ParseString("<expected>", expected), cu); }
public ScanningLexer(int tabSize, string source) { source += " "; // No idea why but without this extra space the lexer sometimes throws an exception Func <BooLexer, antlr.TokenStream> makeFilter = lexer => { lexer.WantAllWhitespace = true; return(new WhitespacePreservingTokenStreamFilter(lexer, BooParserBase.EOL, BooParserBase.END, BooParserBase.ID)); }; lexer = BooParser.CreateFilteredBooLexer(tabSize, "Line Scanner", new StringReader(source), makeFilter); var sourcePos = 0; var mappedPos = 0; var positionList = new List <int>(); foreach (var c in source) { if (c == '\t') { while (mappedPos % tabSize < tabSize - 1) { positionList.Add(sourcePos); mappedPos++; } } positionList.Add(sourcePos++); mappedPos++; } positionList.Add(sourcePos); // to map the <EOL> token positionMap = positionList.ToArray(); }
public void RunTestCase(string expectedFile, string actualFile) { CompileUnit cu = RunCompiler(new FileInput(GetTestCasePath(actualFile))); cu.Modules[0].Name = BooParser.CreateModuleName(expectedFile); AssertEquals("[required]", ParseTestCase(expectedFile), cu); }
public static Boo.Lang.Ast.Module ParseTestCase(string sample) { using (StreamReader reader = File.OpenText(GetTestCasePath(sample))) { return(BooParser.ParseModule(sample, reader, new ParserErrorHandler(OnError))); } }
public override string GetNamespace(string fileName, string definedSymbols) { try { return(BooParser.ParseFile(fileName).Modules.First().Namespace.Name); } catch {} return(base.GetNamespace(fileName, definedSymbols)); }
void EnsureClosureEndSourceLocation(string code, int line, int column) { CompileUnit cu = BooParser.ParseString("closures", code); Expression e = ((ExpressionStatement)cu.Modules[0].Globals.Statements[0]).Expression; BlockExpression cbe = (BlockExpression)((BinaryExpression)e).Right; SourceLocation esl = cbe.Body.EndSourceLocation; Assert.AreEqual(line, esl.Line); Assert.AreEqual(column, esl.Column); }
public override string GetNamespace(string fileName) { try { return(((IEnumerable <Module>)BooParser.ParseFile(fileName).get_Modules()).First <Module>().get_Namespace().get_Name()); } catch { } return(base.GetNamespace(fileName)); }
public override string GetNamespace(string fileName) { try { return(BooParser.ParseFile(fileName).Modules.First <Module>().Namespace.Name); } catch { } return(base.GetNamespace(fileName)); }
void Register(string prog) { DefaultProjectContent pc = new DefaultProjectContent(); lastPC = pc; HostCallback.GetCurrentProjectContent = delegate { return(pc); }; pc.ReferencedContents.Add(AssemblyParserService.DefaultProjectContentRegistry.Mscorlib); pc.ReferencedContents.Add(AssemblyParserService.DefaultProjectContentRegistry.GetProjectContentForReference("System.Windows.Forms", typeof(System.Windows.Forms.Form).Module.FullyQualifiedName)); pc.ReferencedContents.Add(booLangPC); ICompilationUnit cu = new BooParser().Parse(pc, fileName, new StringTextBuffer(prog)); ParserService.RegisterParseInformation(fileName, cu); cu.Classes.ForEach(pc.AddClassToNamespaceList); }
public override string GetNamespace(string fileName, string definedSymbols) { string result; try { result = BooParser.ParseFile(fileName).get_Modules().First <Module>().get_Namespace().get_Name(); return(result); } catch { } result = base.GetNamespace(fileName, definedSymbols); return(result); }
private void MapTokens(int tabSize, string source) { var endLine = 0; var endIndex = 0; var tokens = BooParser.CreateBooLexer(tabSize, "code stream", new StringReader(source)); antlr.IToken token; while ((token = NextToken(tokens)).Type != BooLexer.EOF) { Tuple <int, int> endPoint; switch (token.Type) { case BooLexer.INDENT: case BooLexer.DEDENT: case BooLexer.EOL: case BooLexer.ESEPARATOR: continue; case BooLexer.SINGLE_QUOTED_STRING: case BooLexer.DOUBLE_QUOTED_STRING: endPoint = CalculateEndpoint(token, endLine, endIndex, 1); break; case BooLexer.TRIPLE_QUOTED_STRING: endPoint = CalculateEndpoint(token, endLine, endIndex, 3); break; default: endPoint = CalculateEndpoint(token, endLine, endIndex, 0); break; } endLine = endPoint.Item1; endIndex = endPoint.Item2; } var sIndex = positionMap[token.getLine() - 1][token.getColumn() - 1]; var sLine = token.getLine() - 1; if (sLine > endLine || sLine == endLine && sIndex > endIndex) { whitespaces.Add(new TextSpan { iStartLine = endLine, iStartIndex = endIndex, iEndLine = sLine, iEndIndex = sIndex }); } }
static Module Parse(string fileName, string fileContent) { BooParsingStep step = new BooParsingStep(); StringBuilder errors = new StringBuilder(); Module module = BooParser.ParseModule(4, new CompileUnit(), fileName, new StringReader(fileContent), delegate(antlr.RecognitionException e) { errors.AppendLine(e.ToString()); }); if (errors.Length > 0) { throw new FormsDesignerLoadException("Syntax errors in " + fileName + ":\r\n" + errors.ToString()); } return(module); }
public void TestSimpleClasses() { string fname = GetTestCasePath("simple_classes.boo"); Boo.Lang.Compiler.Ast.Module module = BooParser.ParseFile(fname).Modules[0]; Assert.AreEqual("Foo.Bar", module.Namespace.Name); Assert.IsNotNull(module.Members); Assert.AreEqual(2, module.Members.Count); TypeMember cd = module.Members[0]; Assert.IsTrue(cd is ClassDefinition); Assert.AreEqual("Customer", cd.Name); Assert.AreEqual("Foo.Bar.Customer", cd.FullName); Assert.AreSame(module.Namespace, cd.EnclosingNamespace); cd = module.Members[1]; Assert.AreEqual("Person", cd.Name); }
public void TestSimple() { string fname = GetTestCasePath("simple.boo"); CompileUnit cu = BooParser.ParseFile(fname); Assert.IsNotNull(cu); Boo.Lang.Compiler.Ast.Module module = cu.Modules[0]; Assert.IsNotNull(module); Assert.AreEqual("simple", module.Name); Assert.AreEqual("module doc string", module.Documentation); Assert.AreEqual("Empty.simple", module.FullName); Assert.AreEqual(fname, module.LexicalInfo.FileName); Assert.IsNotNull(module.Namespace); Assert.AreEqual("Empty", module.Namespace.Name); Assert.AreEqual(4, module.Namespace.LexicalInfo.Line); Assert.AreEqual(1, module.Namespace.LexicalInfo.Column); Assert.AreEqual(fname, module.Namespace.LexicalInfo.FileName); }
public ScanningLexer(int tabSize, string source) { source += " "; // No idea why but without this extra space the lexer sometimes throws an exception lexer = BooParser.CreateBooLexer(tabSize, "Line Scanner", new StringReader(source)); var sourcePos = 0; var mappedPos = 0; var positionList = new List <int>(); foreach (var c in source) { if (c == '\t') { while (mappedPos % tabSize < tabSize - 1) { positionList.Add(sourcePos); mappedPos++; } } positionList.Add(sourcePos++); mappedPos++; } positionList.Add(sourcePos); // to map the <EOL> token positionMap = positionList.ToArray(); }
static string GetExpectedOutput(string path) { return(BooParser.ParseFile(path).Modules [0].Documentation); }
private Assembly compile(string code) { return(Compilation.compile(BooParser.ParseString("code", code), GetType().Assembly)); }
CompileUnit ParseTestCase(string fname) { return(BooParser.ParseFile(GetTestCasePath(fname))); }
CompileUnit ParseString(string name, string text) { return(BooParser.ParseReader(name, new StringReader(text))); }
private void MapTokens(int tabSize, string source) { var endLine = 0; var endIndex = 0; var tokens = BooParser.CreateBooLexer(tabSize, "code stream", new StringReader(source)); antlr.IToken token; while ((token = NextToken(tokens)).Type != BooLexer.EOF) { int length; switch (token.Type) { case BooLexer.INDENT: case BooLexer.DEDENT: case BooLexer.EOL: continue; case BooLexer.SINGLE_QUOTED_STRING: case BooLexer.DOUBLE_QUOTED_STRING: length = token.getText().Length + 2; break; case BooLexer.TRIPLE_QUOTED_STRING: length = token.getText().Length + 6; break; default: length = token.getText().Length; break; } var startIndex = positionMap[token.getLine() - 1][token.getColumn() - 1]; var startLine = token.getLine() - 1; if (startLine > endLine || startLine == endLine && startIndex > endIndex) { whitespaces.Add(new TextSpan { iStartLine = endLine, iStartIndex = endIndex, iEndLine = startLine, iEndIndex = startIndex }); } endIndex = positionMap[token.getLine() - 1][token.getColumn() - 1 + length]; endLine = startLine; var cluster = new MappedToken( startLine * lineSize + startIndex, endIndex - startIndex); if (tokenMap.Count > 0 && tokenMap[tokenMap.Count() - 1].Index >= cluster.Index) { throw new ArgumentException("Token Mapping order"); } tokenMap.Add(cluster); } var sIndex = positionMap[token.getLine() - 1][token.getColumn() - 1]; var sLine = token.getLine() - 1; if (sLine > endLine || sLine == endLine && sIndex > endIndex) { whitespaces.Add(new TextSpan { iStartLine = endLine, iStartIndex = endIndex, iEndLine = sLine, iEndIndex = sIndex }); } }
protected virtual Boo.Lang.Compiler.Ast.Module ParseTestCase(string fname) { return(BooParser.ParseFile(GetTestCasePath(fname)).Modules[0]); }
private static CompileUnit Parse(string fileName, string code) { return(BooParser.ParseString(fileName, code.ReIndent())); }