static void Main(string[] args) { CompiledGrammar grammar = CompiledGrammar.Load(typeof(Token), "minim0.2.cgt"); SemanticTypeActions<Token> actions = new SemanticTypeActions<Token>(grammar); CodeGenerator.Init("test.exe"); TypeChecker.Init(); try { actions.Initialize(true); } catch (InvalidOperationException ex) { Console.Write(ex.Message); Console.ReadKey(true); return; } SemanticProcessor<Token> processor = new SemanticProcessor<Token>(new StreamReader(args[0]), actions); ParseMessage parseMessage = processor.ParseAll(); if (parseMessage == ParseMessage.Accept) { Console.WriteLine("Parsed successfully."); Program p = (Program)processor.CurrentToken; CodeGenerator.Complete(); } else { IToken token = processor.CurrentToken; Console.WriteLine("Error on line " + token.Position.Line + ".\n" + token.Position.ToString()); Console.WriteLine(string.Format("{0} {1}", "^".PadLeft((int)(token.Position.Index + 1)), parseMessage)); } }
public void GenericParse() { SemanticTypeActions<MockGenericTokenBase> actions = new SemanticTypeActions<MockGenericTokenBase>(grammar); actions.Initialize(); SemanticProcessor<MockGenericTokenBase> processor = new SemanticProcessor<MockGenericTokenBase>(new StringReader("-1+2+3*4-8"), actions); Assert.Equal(ParseMessage.Accept, processor.ParseAll()); Assert.IsAssignableFrom<MockGenericTokenBase>(processor.CurrentToken); }
private static void Main(string[] args) { Console.WriteLine("Language Scrappy Compiler 1.0"); if (args.Length == 0) { Console.WriteLine("usage: Scrappy <file.sp>"); return; } var grammar = CompiledGrammar.Load(typeof(Program), "Scrappy.egt"); var actions = new SemanticTypeActions <BaseToken>(grammar); try { actions.Initialize(true); } catch (InvalidOperationException ex) { Console.Write("Error: " + ex.Message); return; } try { var path = args[0]; var outputName = Path.GetFileNameWithoutExtension(path) + ".xml"; using (var reader = File.OpenText(path)) { var processor = new SemanticProcessor <BaseToken>(reader, actions); ParseMessage parseMessage = processor.ParseAll(); if (parseMessage == ParseMessage.Accept) { Console.WriteLine("Parsing done."); var compilationModel = new CompilationModel(File.ReadAllLines(path)); var start = (Start)processor.CurrentToken; start.Compile(compilationModel); // first classes, fields and methods needs to be compiled compilationModel.Compile(); // after that compile method body Console.WriteLine("Compiling done."); using (var outfile = new StreamWriter(outputName)) { outfile.Write(compilationModel.ToXml()); } // PrintAst(start); // only for debugging } else { IToken token = processor.CurrentToken; Console.WriteLine(token.Symbol); Console.WriteLine("Error: Line: {0} Column: {1} Error: {2}", token.Position.Line, token.Position.Column, parseMessage); } } } catch (Exception e) { Console.WriteLine("Error" + e.Message); } }
private static void Main(string[] args) { Console.WriteLine("Language Scrappy Compiler 1.0"); if (args.Length == 0) { Console.WriteLine("usage: Scrappy <file.sp>"); return; } var grammar = CompiledGrammar.Load(typeof(Program), "Scrappy.egt"); var actions = new SemanticTypeActions<BaseToken>(grammar); try { actions.Initialize(true); } catch (InvalidOperationException ex) { Console.Write("Error: " + ex.Message); return; } try { var path = args[0]; var outputName = Path.GetFileNameWithoutExtension(path) + ".xml"; using (var reader = File.OpenText(path)) { var processor = new SemanticProcessor<BaseToken>(reader, actions); ParseMessage parseMessage = processor.ParseAll(); if (parseMessage == ParseMessage.Accept) { Console.WriteLine("Parsing done."); var compilationModel = new CompilationModel(File.ReadAllLines(path)); var start = (Start)processor.CurrentToken; start.Compile(compilationModel); // first classes, fields and methods needs to be compiled compilationModel.Compile(); // after that compile method body Console.WriteLine("Compiling done."); using (var outfile = new StreamWriter(outputName)) { outfile.Write(compilationModel.ToXml()); } // PrintAst(start); // only for debugging } else { IToken token = processor.CurrentToken; Console.WriteLine(token.Symbol); Console.WriteLine("Error: Line: {0} Column: {1} Error: {2}", token.Position.Line, token.Position.Column, parseMessage); } } } catch (Exception e) { Console.WriteLine("Error" + e.Message); } }
internal static SemanticTypeActions<CliToken> GetSemanticActions() { lock (sync) { if (semanticActions == null) { semanticActions = new SemanticTypeActions<CliToken>(CompiledGrammar.Load(typeof(CliToken), "CommandLine.egt")); semanticActions.Initialize(); } return semanticActions; } }
public void BaseTest() { SemanticTypeActions<MockTokenBase> actionsA = new SemanticTypeActions<MockTokenBase>(grammar); Assert.Throws<InvalidOperationException>(() => actionsA.Initialize(true, true)); SemanticTypeActions<MockTokenBase> actionsB = new SemanticTypeActions<MockTokenBase>(grammar); Assert.DoesNotThrow(() => actionsB.Initialize(true, false)); //default should be false SemanticTypeActions<MockTokenBase> actionsC = new SemanticTypeActions<MockTokenBase>(grammar); Assert.DoesNotThrow(() => actionsC.Initialize(true)); }
public static SemanticTypeActions<SqlToken> GetSemanticActions() { lock (sync) { if (semanticActions == null) { semanticActions = new SemanticTypeActions<SqlToken>(GetGrammar()); semanticActions.Initialize(); } return semanticActions; } }
public static bool Parse(Stream stream) { CompiledGrammar grammar = CompiledGrammar.Load(typeof(TestUnicode), "TestUnicode.egt"); // embedded resource SemanticTypeActions<TestToken> actions = new SemanticTypeActions<TestToken>(grammar); actions.Initialize(true); using (StreamReader reader = new StreamReader(stream)) // defaults to UTF-8 { SemanticProcessor<TestToken> processor = new SemanticProcessor<TestToken>(reader, actions); ParseMessage parseMessage = processor.ParseAll(); return (parseMessage == ParseMessage.Accept); } }
public FormulaInterpreter(System.IO.BinaryReader reader) { grammar = CompiledGrammar.Load(reader); actions = new SemanticTypeActions <GCToken>(grammar); try { actions.Initialize(true); } catch { } }
public void DynamicFactory() { SemanticTypeActions<DynamicMockTokenBase> actions = new SemanticTypeActions<DynamicMockTokenBase>(grammar); // ReSharper disable AccessToModifiedClosure Assert.Throws<InvalidOperationException>(() => actions.Initialize()); // ReSharper restore AccessToModifiedClosure actions = new SemanticTypeActions<DynamicMockTokenBase>(grammar); try { actions.Initialize(); } catch (InvalidOperationException exception) { Assert.True(Regex.IsMatch(exception.Message, "Rule .* is assigned to a non-static method, which is not allowed.")); } }
public FormulaInterpreter(System.IO.BinaryReader reader) { grammar = CompiledGrammar.Load(reader); actions = new SemanticTypeActions <GCToken>(grammar); try { actions.Initialize(true); } catch (System.Exception e) { Core.ApplicationData.Instance.Logger.AddLog(this, e); } }
public FormulaInterpreter(System.IO.BinaryReader reader) { grammar = CompiledGrammar.Load(reader); actions = new SemanticTypeActions<GCToken>(grammar); try { actions.Initialize(true); } catch (System.Exception e) { Core.ApplicationData.Instance.Logger.AddLog(this, e); } }
public FormulaInterpreter(System.IO.BinaryReader reader) { grammar = CompiledGrammar.Load(reader); actions = new SemanticTypeActions<GCToken>(grammar); try { actions.Initialize(true); } catch (InvalidOperationException ex) { System.Diagnostics.Debug.Write(ex.Message); } }
public FormulaInterpreter(System.IO.BinaryReader reader) { grammar = CompiledGrammar.Load(reader); actions = new SemanticTypeActions <GCToken>(grammar); try { actions.Initialize(true); } catch (InvalidOperationException ex) { System.Diagnostics.Debug.Write(ex.Message); } }
public void load() { log.Debug("Loading grammar..."); grammar = CompiledGrammar.Load(typeof(MathToken), "math-grammar.cgt"); log.Debug("Loading actions..."); actions = new SemanticTypeActions<MathToken>(grammar); try { actions.Initialize(true); } catch (InvalidOperationException e) { log.Error("Error initializing actions", e); return; } log.Info("Plugin successfully loaded."); }
private static void init() { Stream resourceStream = typeof(ScriptEngine).Assembly.GetManifestResourceStream("BlockApp.Grammar.src.BlockAppGrammar.egt"); CompiledGrammar grammar = CompiledGrammar.Load(resourceStream); grammarActions = new SemanticTypeActions<Token>(grammar); try { grammarActions.Initialize(true); } catch (InvalidOperationException ex) { throw ex; } }
public void load() { log.Debug("Loading grammar..."); grammar = CompiledGrammar.Load(typeof(MathToken), "math-grammar.cgt"); log.Debug("Loading actions..."); actions = new SemanticTypeActions <MathToken>(grammar); try { actions.Initialize(true); } catch (InvalidOperationException e) { log.Error("Error initializing actions", e); return; } log.Info("Plugin successfully loaded."); }
private static void Main(string[] args) { SemanticTypeActions<QueryToken> queryActions = new SemanticTypeActions<QueryToken>(CompiledGrammar.Load(typeof(QueryToken), "Query.cgt")); queryActions.Initialize(true); SemanticTypeActions<ExpressionToken> expressionActions = new SemanticTypeActions<ExpressionToken>(CompiledGrammar.Load(typeof(ExpressionToken), "Expression.cgt")); expressionActions.Initialize(true); string input = "VIEW a WHERE x = 20 ORDER BY y"; using (StringReader reader = new StringReader(input)) { QueryProcessor processor = new QueryProcessor(new QueryTokenizer(reader, queryActions, expressionActions)); ParseMessage message = processor.ParseAll(); Console.WriteLine("Parsing result: "+message); if (message != ParseMessage.Accept) { Console.WriteLine(input); Console.Write(new string(' ', (int)((IToken)processor.CurrentToken).Position.Index)); Console.WriteLine('^'); } } Console.ReadKey(false); }
private static void Main(string[] args) { Console.WriteLine("*** CALCULATOR SAMPLE *** (input formula, empty line terminates)"); CompiledGrammar grammar = CompiledGrammar.Load(typeof(CalculatorToken), "Calculator.cgt"); SemanticTypeActions<CalculatorToken> actions = new SemanticTypeActions<CalculatorToken>(grammar); try { actions.Initialize(true); } catch (InvalidOperationException ex) { Console.Write(ex.Message); Console.ReadKey(true); return; } for (string formula = Console.ReadLine(); !string.IsNullOrEmpty(formula); formula = Console.ReadLine()) { SemanticProcessor<CalculatorToken> processor = new SemanticProcessor<CalculatorToken>(new StringReader(formula), actions); ParseMessage parseMessage = processor.ParseAll(); if (parseMessage == ParseMessage.Accept) { Console.WriteLine(string.Format(NumberFormatInfo.InvariantInfo, "Result: {0}", ((Computable)processor.CurrentToken).GetValue())); } else { IToken token = processor.CurrentToken; Console.WriteLine(string.Format("{0} {1}", "^".PadLeft(token.Position.Column), parseMessage)); } } }
public void ExplicitCheckTest() { SemanticTypeActions<MockTokenBaseExplicitChecks> actionsA = new SemanticTypeActions<MockTokenBaseExplicitChecks>(grammar); Assert.Throws<InvalidOperationException>(() => actionsA.Initialize(true, true)); SemanticTypeActions<MockTokenBaseExplicitChecks> actionsB = new SemanticTypeActions<MockTokenBaseExplicitChecks>(grammar); Assert.Throws<InvalidOperationException>(() => actionsB.Initialize(true, false)); }
public SemanticProcessorTest() { actions = new SemanticTypeActions<TestToken>(EgtCompiledGrammarTest.LoadEgtTestGrammar()); actions.Initialize(false); }
public void ExplicitNoCheckTest() { SemanticTypeActions<MockTokenBaseExplicitNoChecks> actionsA = new SemanticTypeActions<MockTokenBaseExplicitNoChecks>(grammar); Assert.DoesNotThrow(() => actionsA.Initialize(true, true)); SemanticTypeActions<MockTokenBaseExplicitNoChecks> actionsB = new SemanticTypeActions<MockTokenBaseExplicitNoChecks>(grammar); Assert.DoesNotThrow(() => actionsB.Initialize(true, false)); }