Untitled

let rec parse_expr toks = parse_or toks

and parse_or toks =
  let (t, lhs) = parse_and toks in
  match lookahead t with
  | Tok_Or ->
      let t = match_token t Tok_Or in
      let (t, rhs) = parse_or t in
      (t, Or(lhs, rhs))
  | _ -> (t, lhs)

and parse_and toks =
  let (t, lhs) = parse_equality toks in
  match lookahead t with
  | Tok_And ->
      let t = match_token t Tok_And in
      let (t, rhs) = parse_and t in
      (t, And(lhs, rhs))
  | _ -> (t, lhs)

and parse_equality toks =
  let (t, lhs) = parse_relational toks in
  match lookahead t with
  | Tok_Equal ->
      let t = match_token t Tok_Equal in
      let (t, rhs) = parse_equality t in
      (t, Equal(lhs, rhs))
  | Tok_NotEqual ->
      let t = match_token t Tok_NotEqual in
      let (t, rhs) = parse_equality t in
      (t, NotEqual(lhs, rhs))
  | _ -> (t, lhs)

and parse_relational toks =
  let (t, lhs) = parse_additive toks in
  match lookahead t with
  | Tok_Less ->
      let t = match_token t Tok_Less in
      let (t, rhs) = parse_relational t in
      (t, Less(lhs, rhs))
  | Tok_Greater ->
      let t = match_token t Tok_Greater in
      let (t, rhs) = parse_relational t in
      (t, Greater(lhs, rhs))
  | Tok_LessEqual ->
      let t = match_token t Tok_LessEqual in
      let (t, rhs) = parse_relational t in
      (t, LessEqual(lhs, rhs))
  | Tok_GreaterEqual ->
      let t = match_token t Tok_GreaterEqual in
      let (t, rhs) = parse_relational t in
      (t, GreaterEqual(lhs, rhs))
  | _ -> (t, lhs)

and parse_additive toks =
  let (t, lhs) = parse_multiplicative toks in
  match lookahead t with
  | Tok_Add ->
      let t = match_token t Tok_Add in
      let (t, rhs) = parse_additive t in
      (t, Add(lhs, rhs))
  | Tok_Sub ->
      let t = match_token t Tok_Sub in
      let (t, rhs) = parse_additive t in
      (t, Sub(lhs, rhs))
  | _ -> (t, lhs)

and parse_multiplicative toks =
  let (t, lhs) = parse_power toks in
  match lookahead t with
  | Tok_Mult ->
      let t = match_token t Tok_Mult in
      let (t, rhs) = parse_multiplicative t in
      (t, Mult(lhs, rhs))
  | Tok_Div ->
      let t = match_token t Tok_Div in
      let (t, rhs) = parse_multiplicative t in
      (t, Div(lhs, rhs))
  | _ -> (t, lhs)

and parse_power toks =
  let (t, lhs) = parse_unary toks in
  match lookahead t with
  | Tok_Pow ->
      let t = match_token t Tok_Pow in
      let (t, rhs) = parse_power t in
      (t, Pow(lhs, rhs))
  | _ -> (t, lhs)

and parse_unary toks =
  match lookahead toks with
  | Tok_Not ->
      let t = match_token toks Tok_Not in
      let (t, e) = parse_unary t in
      (t, Not e)
  | _ -> parse_primary toks

and parse_primary toks =
  match lookahead toks with
  | Tok_Int i ->
      let t = match_token toks (Tok_Int i) in
      (t, Int i)
  | Tok_Bool b ->
      let t = match_token toks (Tok_Bool b) in
      (t, Bool b)
  | Tok_ID id ->
      let t = match_token toks (Tok_ID id) in
      (t, ID id)
  | Tok_LParen ->
      let t = match_token toks Tok_LParen in
      let (t', e) = parse_expr t in
      let t'' = match_token t' Tok_RParen in
      (t'', e)
  | _ -> raise (InvalidInputException "Invalid primary expression")