source: branches/Benchmark Generator/Benchmark Generator/ExpressionGrammar.cs @ 10059

using System;
using Irony.Interpreter;
using Irony.Interpreter.Ast;
using Irony.Interpreter.Evaluator;
using Irony.Parsing;

namespace Benchmark_Generator {
  public class ExpressionGrammar : InterpretedLanguageGrammar {
    public ExpressionGrammar() : this(caseSensitive: false) { }

    public ExpressionGrammar(bool caseSensitive)
      : base(caseSensitive) {
      // Define terminals
      var number = new NumberLiteral("Number") {
        DefaultIntTypes = new[] { TypeCode.Int32, TypeCode.Int64 },
        DefaultFloatType = TypeCode.Double
      };
      var variable = new IdentifierTerminal("Variable");
      var stringLit = new StringLiteral("String");

      // Define non-terminals
      var term = new NonTerminal("Term");
      var binExpr = new NonTerminal("BinExpr", typeof(BinaryOperatorMethod));
      var binOp = new NonTerminal("BinOp", "operator");
      var unExpr = new NonTerminal("UnExpr", typeof(UnaryOperatorMethod));
      var unOp = new NonTerminal("UnOp", "operator");
      var expr = new NonTerminal("Expr");
      var parExpr = new NonTerminal("ParExpr");
      var statement = new NonTerminal("Statement");
      var program = new NonTerminal("Program", typeof(StatementListNode));

      // BNF rules
      expr.Rule = term | unExpr | binExpr;
      term.Rule = number | parExpr | stringLit | variable;
      parExpr.Rule = "(" + expr + ")";
      unExpr.Rule = unOp + term;
      unOp.Rule = ToTerm("+") | "-";
      binExpr.Rule = expr + binOp + expr;
      binOp.Rule = ToTerm("+") | "-" | "*" | "/" | "^"; // add, sub, mul, div, pow
      statement.Rule = expr | Empty;
      program.Rule = MakePlusRule(program, NewLine, statement);
      this.Root = program;

      // Operators precedence
      RegisterOperators(1, "+", "-");
      RegisterOperators(2, "*", "/");
      RegisterOperators(3, Associativity.Right, "^");

      // Punctuation and braces
      MarkPunctuation("(", ")", "[", "]");
      RegisterBracePair("(", ")");
      RegisterBracePair("[", "]");
      MarkTransient(term, expr, binOp, unOp, parExpr);
      // Language flags                         
      //      LanguageFlags = LanguageFlags.NewLineBeforeEOF | LanguageFlags.CreateAst;
      LanguageFlags = LanguageFlags.NewLineBeforeEOF;
    }

    public override LanguageRuntime CreateRuntime(LanguageData language) {
      return new ExpressionEvaluatorRuntime(language);
    }

    #region Running in Grammar Explorer
    private static ExpressionEvaluator evaluator;
    public override string RunSample(RunSampleArgs args) {
      if (evaluator == null) {
        evaluator = new ExpressionEvaluator(this);
        evaluator.Globals.Add("null", evaluator.Runtime.NoneValue);
        evaluator.Globals.Add("true", true);
        evaluator.Globals.Add("false", false);

      }
      evaluator.ClearOutput();
      evaluator.Evaluate(args.ParsedSample);
      return evaluator.GetOutput();
    }
    #endregion
  }
}