nailgun 0.1.0

A PEG parser generator.
Documentation 
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

// Copyright 2014 Strahinja Val Markovic
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
pub use self::not::NotEx;
pub use self::and::And;
pub use self::fuse::Fuse;
pub use self::char_class::CharClass;
pub use self::literal::Literal;
pub use self::dot::Dot;
pub use self::option::OptionEx;
pub use self::star::Star;
pub use self::plus::Plus;
pub use self::or::Or;
pub use self::sequence::Sequence;
pub use self::wrap::WrapEx;
pub use self::node::{Node, NodeContents, Data, Children, PreOrderNodes};


mod node;
#[cfg(test)]
#[macro_use]
pub mod test_utils;

#[macro_use]
mod literal;
#[macro_use]
mod char_class;
#[macro_use]
mod not;
#[macro_use]
mod and;
mod dot;
#[macro_use]
mod option;
#[macro_use]
mod star;
#[macro_use]
mod plus;
#[macro_use]
mod or;
#[macro_use]
mod fuse;
#[macro_use]
mod sequence;
#[macro_use]
mod wrap;
mod unicode;


#[doc(hidden)]
#[derive(Debug, Clone, PartialEq, Copy)]
pub struct ParseState<'a> {
  pub input: &'a [u8],  // Unconsumed input from "main" slice.
  pub offset: usize  // Offset of 'input' from start of "main" slice.
}


impl<'a> ParseState<'a> {
  fn advanceTo( &self, new_offset: usize ) -> ParseState<'a> {
    let mut clone = self.clone();
    clone.input = &clone.input[ new_offset - clone.offset .. ];
    clone.offset = new_offset;
    clone
  }

  fn sliceTo( &self, new_offset: usize ) -> &'a [u8] {
    &self.input[ .. new_offset - self.offset ]
  }

  fn offsetToResult( &self, new_offset: usize )
      -> Option< ParseResult<'a> > {
    Some( ParseResult::oneNode(
            Node::withoutName( self.offset,
                               new_offset,
                               Data( self.sliceTo( new_offset ) ) ),
            self.advanceTo( new_offset ) ) )
  }
}

#[doc(hidden)]
pub struct ParseResult<'a> {
  pub nodes: Vec< Node<'a> >,
  pub parse_state: ParseState<'a>
}


impl<'a> ParseResult<'a> {
  pub fn oneNode( node: Node<'a>, parse_state: ParseState<'a> )
      -> ParseResult<'a> {
    ParseResult { nodes: vec!( node ), parse_state: parse_state }
  }

  pub fn fromParseState( parse_state: ParseState<'a> ) -> ParseResult<'a> {
    ParseResult { nodes: vec!(), parse_state: parse_state }
  }
}


pub trait Expression {
  fn apply<'a>( &self, parse_state: &ParseState<'a> )
      -> Option< ParseResult<'a> >;
}

pub type Rule = for<'a> fn( &ParseState<'a> ) -> Option< ParseResult<'a> >;