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);
}
}
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);
}
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));
}
}
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 (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 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 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 Initializes() {
SemanticTypeActions<MockTokenBase> actions = new SemanticTypeActions<MockTokenBase>(grammar);
Assert.DoesNotThrow(actions.Initialize);
}
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 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));
}
public SemanticProcessorTest() {
actions = new SemanticTypeActions<TestToken>(EgtCompiledGrammarTest.LoadEgtTestGrammar());
actions.Initialize(false);
}
