1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use crate::lexer::token::Token;
use crate::common::{ KeywordType, OperatorType };


pub fn ignore (t: &Token) -> bool {
  t.is_ignore()
}

pub fn nil (t: &Token) -> bool {
  t.is_nil()
}

pub fn ident (t: &Token) -> bool {
  t.is_ident()
}

pub fn ident_or_ignore (t: &Token) -> bool {
  t.is_ident_or_ignore()
}

pub fn boolean (t: &Token) -> bool {
  t.is_boolean()
}

pub fn number (t: &Token) -> bool {
  t.is_number()
}

pub fn string (t: &Token) -> bool {
  t.is_string()
}

pub fn literal (t: &Token) -> bool {
  t.is_literal()
}

pub fn literal_or_ignore (t: &Token) -> bool {
  t.is_literal_or_ignore()
}

pub fn primary (t: &Token) -> bool {
  t.is_primary()
}

pub fn primary_or_ignore (t: &Token) -> bool {
  t.is_primary_or_ignore()
}

pub fn any_op (t: &Token) -> bool {
  t.is_any_op()
}

pub fn any_kw (t: &Token) -> bool {
  t.is_any_kw()
}



pub fn specific_op (op: OperatorType) -> impl Fn (&Token) -> bool {
  move |t| t.is_specific_op(op)
}

pub fn specific_kw (kw: KeywordType) -> impl Fn (&Token) -> bool {
  move |t| t.is_specific_kw(kw)
}

pub fn or (mut a: impl FnMut (&Token) -> bool, mut b: impl FnMut (&Token) -> bool) -> impl FnMut (&Token) -> bool {
  move |t| a(t) || b(t)
}

pub fn and (mut a: impl FnMut (&Token) -> bool, mut b: impl FnMut (&Token) -> bool) -> impl FnMut (&Token) -> bool {
  move |t| a(t) && b(t)
}

pub fn not (mut b: impl FnMut (&Token) -> bool) -> impl FnMut (&Token) -> bool {
  move |t| !b(t)
}

pub fn any_op_of (ops: &'static [OperatorType]) -> impl Fn (&Token) -> bool {
  move |t| t.is_any_op_of(ops)
}

pub fn any_kw_of (kws: &'static [KeywordType]) -> impl Fn (&Token) -> bool {
  move |t| t.is_any_kw_of(kws)
}

pub fn or_many (preds: &'static mut [impl FnMut (&Token) -> bool]) -> impl FnMut (&Token) -> bool {
  move |t| {
    for pred in preds.iter_mut() {
      if pred(t) { return true }
    }

    false
  }
}

pub fn and_many (preds: &'static mut [impl FnMut (&Token) -> bool]) -> impl FnMut (&Token) -> bool {
  move |t| {
    for pred in preds.iter_mut() {
      if !pred(t) { return false }
    }

    true
  }
}


pub fn pair_counter (mut a: impl FnMut (&Token) -> bool, mut b: impl FnMut (&Token) -> bool) -> impl FnMut (&Token) -> bool {
  let mut counter = 1usize;

  move |t| {
    if a(t) { counter += 1; }
    else if b(t) { counter -= 1; }

    counter == 0
  }
}


pub fn contextual (mut a: impl FnMut (&Token) -> bool, mut b: impl FnMut (&Token) -> bool, mut ctx: impl FnMut (&Token) -> bool) -> impl FnMut (&Token) -> bool {
  let mut counter = 1usize;

  move |t| {
    if a(t) { counter += 1; }
    else if b(t) { counter -=1; }

    (counter == 1 && ctx(t)) || counter == 0
  }
}