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

//! This module defines grammar rules. Each rule in a context-free grammar
//! consists of a single symbol on its left-hand side and an array of symbols
//! on its right-hand side. In this library, each rule carries additional
//! value called "history."

pub mod builder;
pub mod container;

use symbol::Symbol;

/// Trait for rules of a context-free grammar.
pub trait GrammarRule {
    /// The type of history carried with the rule.
    type History;

    /// Returns the rule's left-hand side.
    fn lhs(&self) -> Symbol;
    /// Returns the rule's right-hand side.
    fn rhs(&self) -> &[Symbol];
    /// Returns a reference to the history carried with the rule.
    fn history(&self) -> &Self::History;
}

impl<'a, R> GrammarRule for &'a R
    where R: GrammarRule
{
    type History = R::History;

    fn lhs(&self) -> Symbol {
        (**self).lhs()
    }
    fn rhs(&self) -> &[Symbol] {
        (**self).rhs()
    }
    fn history(&self) -> &Self::History {
        (**self).history()
    }
}

/// Typical grammar rule representation.
#[derive(Clone, Debug)]
pub struct Rule<H> {
    lhs: Symbol,
    /// The rule's right-hand side.
    pub rhs: Vec<Symbol>,
    /// The rule's history.
    pub history: H,
}

impl<H> GrammarRule for Rule<H> {
    type History = H;

    fn lhs(&self) -> Symbol {
        self.lhs
    }

    fn rhs(&self) -> &[Symbol] {
        &self.rhs
    }

    fn history(&self) -> &H {
        &self.history
    }
}

impl<H> Rule<H> {
    /// Creates a new rule.
    pub fn new(lhs: Symbol, rhs: Vec<Symbol>, history: H) -> Self {
        Rule {
            lhs: lhs,
            rhs: rhs,
            history: history,
        }
    }
}

/// References rule's components.
pub struct RuleRef<'a, H: 'a> {
    /// Left-hand side.
    pub lhs: Symbol,
    /// Right-hand side.
    pub rhs: &'a [Symbol],
    /// The rule's history.
    pub history: &'a H,
}

// Can't derive because of the type parameter.
impl<'a, H> Copy for RuleRef<'a, H> {}

// Can't derive because of the where clause.
impl<'a, H> Clone for RuleRef<'a, H> {
    fn clone(&self) -> Self {
        *self
    }
}

impl<'a, H> GrammarRule for RuleRef<'a, H> {
    type History = H;

    fn lhs(&self) -> Symbol {
        self.lhs
    }

    fn rhs(&self) -> &[Symbol] {
        self.rhs
    }

    fn history(&self) -> &H {
        &self.history
    }
}