using Nemerle.Collections;
using Nemerle.Text;
using Nemerle.Utility;

using System;
using System.Collections.Generic;
using System.Console;
using System.Linq;
using ExprParser;
using Nemerle.Peg;

module Program
{
  Main() : void
  {
    def parser = ExprParser();
    mutable text = "2 + -5";
    
    WriteLine(text);
    do
    {
      match (parser.Parse(text))
      {
        | Some(tokens) =>
          def parser = Pratt();
          def ast    = parser.Parse(tokens);
          WriteLine(ast);
          
        | None => 
          def (pos, rules) = parser.GetMaxRollbackPosAndNames();
          WriteLine(string(' ', pos) + "^");
          WriteLine($"Expected: ..$rules");
      }
      
      text = Console.ReadLine();
    }
    while (text != "");
  }
}

using Nemerle.Collections;
using Nemerle.Text;
using Nemerle.Utility;

using System;
using System.Collections.Generic;
using System.Linq;

namespace ExprParser
{
  public variant Token
  {
    | Ident          { Name : string; }
    | Num            { Value : int; }
    | Operator       { Text : string; }
    | Parentheses    { Children : List[Token]; }
    | Expr           { Value : PExpr; }
    | Eof
    
    public override ToString() : string
    {
      match (this)
      {
        | Ident       (name)     => $"'$name'"
        | Num         (value)    => $"'$value'"
        | Parentheses (children) => $"(..$children)"
        | Operator    (text)     => $"'$text'"
        | Expr        (value)    => value.ToString()
        | Eof                    => <#"EOF"#>
      }
    }
  }
}

using Nemerle.Collections;
using Nemerle.Peg;
using Nemerle.Text;
using Nemerle.Utility;

using System;
using System.Collections.Generic;
using System.Linq;

namespace ExprParser
{
  [PegGrammar(
    start,
    grammar {
      any                     = ['\u0000'..'\uFFFF'];
      start : List[Token]     = expr !any;
      //semicolon : NToken      = ";"s;
      //semicolonOpt            = (";"s)?;

      #region Line terminators

      newLineCharacter = '\n'
                        / '\r'
                        / '\u2028'    /*  line separator       */
                        / '\u2029';   /*  paragraph separator  */
      newLine   = "\r\n" / newLineCharacter;

      #endregion

      #region White space

      whitespace = [Zs]
                / '\t'
                / '\v'        /*  vertial tab          */
                / '\f';       /*  form feed            */

      #endregion

      #region Spacer

      space = whitespace / newLine;

      [InlineAllSubrules]
      s : void = space*;                      /* optional spacer          */

      #endregion
      
      inentStartChar = ['A'..'Z', 'a'..'z'] / '_';
      identPartChar  = inentStartChar / ['0'..'9'];
      identCars      = inentStartChar identPartChar*;
      operatorChar = '+' / '-' / '\\' / '*' / '.' / '!' / '~' / '<' / '>' / '=' / '&' / '|' / '^' / '%' / '#' / '$' / '/';
      openBracket     : NToken = "("s;
      closeBracket    : NToken = ")"s;

      ifExpr          : Token       = "if"s openBracket expr closeBracket expr "else"s expr;

      num             : Token       = ['0'..'9']+ s;
      ident           : Token       = identCars s;
      operatorRef     : string      = operatorChar+ s;
      simpleExpr      : Token       = ifExpr / num / parenthesesExpr / ident;
      parenthesesExpr : Token       = openBracket expr closeBracket;
      expr            : List[Token] = simpleExpr? (operatorRef+ simpleExpr)* operatorRef*;
    }
  )]
  class ExprParser
  {
    operatorRef(op : NToken) : string
    {
      GetText(op)
    }
    ident(text : NToken) : Token
    {
      Token.Ident(GetText(text))
    }
    num(text : NToken) : Token
    {
      Token.Num(int.Parse(GetText(text)))
    }
    
    parenthesesExpr(_ : NToken, expr : List[Token], _ : NToken) : Token
    {
      //Token.Parentheses(expr)
      def parser = Pratt();
      def res = parser.Parse(expr);
      Token.Expr(res)
    }
    
    expr(exprOpt : option[Token], instrs : List[List[string] * Token], tailOps : List[string]) : List[Token]
    {
      def res = List();
      
      when (exprOpt is Some(expr))
        res.Add(expr);
      
      foreach ((operators, expr) in instrs)
      {
        foreach (op in operators)
          res.Add(Token.Operator(op));
          
        res.Add(expr);
      }

      foreach (op in tailOps)
        res.Add(Token.Operator(op));
        
      res
    }
    
    ifExpr(_ : NToken, _ : NToken, condTokens : List[Token], _ : NToken, e1Tokens : List[Token], _ : NToken, e2Tokens : List[Token]) : Token
    {
      def parser = Pratt();
      def cond = parser.Parse(condTokens);
      def e1   = parser.Parse(e1Tokens);
      def e2   = parser.Parse(e2Tokens);
      Token.Expr(PExpr.If(cond, e1, e2))
    }
  }
}

using Nemerle.Collections;
using Nemerle.Text;
using Nemerle.Utility;

using System;
using System.Collections.Generic;
using System.Linq;

namespace ExprParser
{
  public variant PExpr
  {
    | BinOperator     { LeftExpr : PExpr; Op : string; RightExpr : PExpr; }
    | PrefixOperator  { Op : string; Expr : PExpr; }
    | PostfixOperator { Op : string; Expr : PExpr; }
    | Ident           { Name : string; }
    | Num             { Value : int; }
    | If              { Cond : PExpr; Expr1 : PExpr; Expr2 : PExpr; }
    | Error           { Msg : string; }

    public override ToString() : string
    {
      match (this)
      {
        | BinOperator    (leftExpr, op, rightExpr) => $"$op($leftExpr, $rightExpr)"
        | If             (cond, e1, e2)            => $"o:if($cond, $e1, $e2)"
        | PrefixOperator (op, expr)                => $"p:$op($expr)"
        | PostfixOperator(op, expr)                => $"s:$op($expr)"
        | Ident          (name)                    => $"$name"
        | Num            (value)                   => $"$value"
        | Error          (msg)                     => $"'Error: $msg'"
      }
    }
    
  }
}

using Nemerle.Collections;
using Nemerle.Text;
using Nemerle.Utility;

using System;
using System.Console;
using System.Collections.Generic;
using System.Linq;

namespace ExprParser
{
  public class Pratt
  {
    public Parse(tokens : List[Token]) : PExpr
    {
      mutable currentIndex = 0;
      def getLeftBindingPower(tok : Token, prefix : bool) : int
      {
        match (tok)
        { // это надо формировать динамически
          | Ident                 => 0
          | Num                   => 0
          | Expr                  => 0
          | Operator   ("&&")     => 30
          | Operator   ("||")     => 30
          | Operator   ("+")      => 50
          | Operator   ("-")      => if (prefix) 100 else 50
          | Operator   ("*")      => 60
          | Operator   ("/")      => 60
          | Operator   (".")      => 80
          | Operator   (_)        => assert(false)
          | Parentheses           => 0
          | Eof                   => int.MinValue
        }
      }
      def next()
      {
        if (currentIndex < tokens.Count)
        {
          def tok = tokens[currentIndex];
          ++currentIndex;
          tok
        }
        else
          Token.Eof()
      }
      
      mutable token = next();
      
      def expression(rbp) : PExpr
      {
        mutable t     = token;
                token = next();
        mutable left  = nud(t);
        
        while (rbp < getLeftBindingPower(token, false))
        {
          t = token;
          token = next();
          left = led(left, t);
        }
        
        left;
      }      
      and nud(tok : Token) : PExpr
      {
        | Ident      (name)     => PExpr.Ident(name)
        | Num        (value)    => PExpr.Num(value)
        | Operator   ("-")      => PExpr.PrefixOperator("-", expression(getLeftBindingPower(tok, true)))
        | Operator   (_)        => assert(false)
        | Parentheses(children) => Parse(children)
        | Expr(expr)            => expr
        | Eof                   => PExpr.Error("Expected simple expressoin.")
      }
      and led(left : PExpr, tok : Token) : PExpr
      {
        match (tok)
        {
          | Operator   (op) => PExpr.BinOperator(left, op, expression(getLeftBindingPower(tok, false)))
          | _ => assert(false) 
        }
      }
      
      expression(0)
    }
  }
}