module Language.Drasil.Code.Expr.Precedence (precA, precB, eprec) where

import Language.Drasil.Code.Expr (CodeExpr(..), UFuncVV, UFuncVN, UFuncB(..),
    UFunc(..), AssocBoolOper(..), AssocArithOper(..), VVNBinOp,
    VVVBinOp, OrdBinOp, LABinOp, BoolBinOp, EqBinOp, ArithBinOp(..))

-- These precedences are inspired from Haskell/F# 
-- as documented at http://kevincantu.org/code/operators.html
-- They are all multiplied by 10, to leave room to weave things in between

-- | prec2Arith - precedence for arithmetic-related binary operations.
prec2Arith :: ArithBinOp -> Int
prec2Arith :: ArithBinOp -> Int
prec2Arith Frac = 190
prec2Arith Pow = 200
prec2Arith Subt = 180

-- | prec2Bool - precedence for boolean-related binary operations.
prec2Bool :: BoolBinOp -> Int
prec2Bool :: BoolBinOp -> Int
prec2Bool _ = 130

-- | prec2Eq - precedence for equality-related binary operations.
prec2Eq :: EqBinOp -> Int
prec2Eq :: EqBinOp -> Int
prec2Eq _  = 130

-- | prec2LA - precedence for access-related binary operations.
prec2LA :: LABinOp -> Int
prec2LA :: LABinOp -> Int
prec2LA _ = 250

-- | prec2Ord - precedence for order-related binary operations.
prec2Ord :: OrdBinOp -> Int
prec2Ord :: OrdBinOp -> Int
prec2Ord _  = 130

-- | prec2VVV - precedence for Vec->Vec->Vec-related binary operations.
prec2VVV :: VVVBinOp -> Int
prec2VVV :: VVVBinOp -> Int
prec2VVV _ = 190

-- | prec2VVN - precedence for Vec->Vec->Num-related binary operations.
prec2VVN :: VVNBinOp -> Int
prec2VVN :: VVNBinOp -> Int
prec2VVN _ = 190

-- | precA - precedence for arithmetic-related Binary-Associative (Commutative) operators.
precA :: AssocArithOper -> Int
precA :: AssocArithOper -> Int
precA MulI = 190
precA MulRe = 190
precA AddI = 180
precA AddRe = 180

-- | precB - precedence for boolean-related Binary-Associative (Commutative) operators.
precB :: AssocBoolOper -> Int
precB :: AssocBoolOper -> Int
precB And = 120
precB Or = 110

-- | prec1 - precedence of unary operators.
prec1 :: UFunc -> Int
prec1 :: UFunc -> Int
prec1 Neg = 230
prec1 Exp = 200
prec1 _ = 250

-- | prec1B - precedence of boolean-related unary operators.
prec1B :: UFuncB -> Int
prec1B :: UFuncB -> Int
prec1B Not = 230

-- | prec1VV - precedence of vector-vector-related unary operators.
prec1VV :: UFuncVV -> Int
prec1VV :: UFuncVV -> Int
prec1VV _ = 250

-- | prec1VN - precedence of vector-number-related unary operators.
prec1VN :: UFuncVN -> Int
prec1VN :: UFuncVN -> Int
prec1VN _ = 230

-- | eprec - "Expression" precedence.
eprec :: CodeExpr -> Int
eprec :: CodeExpr -> Int
eprec Lit{}                  = 500
eprec (AssocA op :: AssocArithOper
op _)          = AssocArithOper -> Int
precA AssocArithOper
op
eprec (AssocB op :: AssocBoolOper
op _)          = AssocBoolOper -> Int
precB AssocBoolOper
op
eprec C{}                    = 500
eprec FCall{}                = 210
eprec New{}                  = 210
eprec Message{}              = 210
eprec Field{}                = 210
eprec Case{}                 = 200
eprec Matrix{}               = 220
eprec (UnaryOp fn :: UFunc
fn _)         = UFunc -> Int
prec1 UFunc
fn
eprec (UnaryOpB fn :: UFuncB
fn _)        = UFuncB -> Int
prec1B UFuncB
fn
eprec (UnaryOpVV fn :: UFuncVV
fn _)       = UFuncVV -> Int
prec1VV UFuncVV
fn
eprec (UnaryOpVN fn :: UFuncVN
fn _)       = UFuncVN -> Int
prec1VN UFuncVN
fn
eprec (Operator o :: AssocArithOper
o _ _)       = AssocArithOper -> Int
precA AssocArithOper
o
eprec (ArithBinaryOp bo :: ArithBinOp
bo _ _) = ArithBinOp -> Int
prec2Arith ArithBinOp
bo
eprec (BoolBinaryOp bo :: BoolBinOp
bo _ _)  = BoolBinOp -> Int
prec2Bool BoolBinOp
bo
eprec (EqBinaryOp bo :: EqBinOp
bo _ _)    = EqBinOp -> Int
prec2Eq EqBinOp
bo
eprec (LABinaryOp bo :: LABinOp
bo _ _)    = LABinOp -> Int
prec2LA LABinOp
bo
eprec (OrdBinaryOp bo :: OrdBinOp
bo _ _)   = OrdBinOp -> Int
prec2Ord OrdBinOp
bo
eprec (VVVBinaryOp bo :: VVVBinOp
bo _ _)   = VVVBinOp -> Int
prec2VVV VVVBinOp
bo
eprec (VVNBinaryOp bo :: VVNBinOp
bo _ _)   = VVNBinOp -> Int
prec2VVN VVNBinOp
bo
eprec RealI{}                = 170