parser_pda/
parser_nondet_pda.rs

1
2use crate::defs::{ SegmentDelimSyms::*, SegmentTypes, 
3    ParserCtx, PDAStackCtx, ParsedSegment };
4
5fsm!( ParserNonDetPDA<ParserCtx, PDAStackCtx> [
6    Idle on Start          
7        => NewSentence on LeftBracket  => PlainSegment,
8    
9    NewSentence on RightBracket => InvalidSegment,
10    NewSentence on Letter(char) 
11        => PlainSegment on LeftBracket 
12        => PlainSegment on RightBracket => ?,
13
14    PlainSegment on EndOfSentence => NewSentence,   
15    _ on EndOfSentence => NewSentence,
16    _ on EndOfInput => Idle,
17    ],
18    [
19        Idle entry, NewSentence exit
20    ]
21);
22
23on_state_handler!( Idle entry for ParserNonDetPDA {
24    data.index = 0;
25});
26on_state_handler!( NewSentence exit for ParserNonDetPDA {
27    stack.push(PDAStackCtx { sym: SentenceStart, seg_start: data.index} );
28});
29    
30transition_handler!( Idle on Start for ParserNonDetPDA {
31});
32
33transition_handler!( NewSentence on Letter(char) for ParserNonDetPDA {
34});
35
36transition_handler!( NewSentence on LeftBracket for ParserNonDetPDA {
37    stack.push(PDAStackCtx { sym: Bracket, seg_start: data.index } );
38});
39
40transition_handler!( NewSentence on RightBracket for ParserNonDetPDA {
41});
42
43
44transition_handler!( PlainSegment on LeftBracket for ParserNonDetPDA {
45    let top = stack.last().unwrap();
46    if top.sym == SegmentStart || top.sym == SentenceStart {
47        data.segments.push(ParsedSegment { 
48            tp: SegmentTypes::Plain, 
49            seg: (top.seg_start, data.index),
50            rank: stack.len(), 
51        });
52    }
53    stack.push(PDAStackCtx { sym: Bracket, seg_start: data.index} );
54});
55
56conditional_handler!(PlainSegment on RightBracket for ParserNonDetPDA {
57    if &Bracket == stack.last().unwrap() {
58        let top = stack.pop().unwrap();
59        data.segments.push(ParsedSegment { 
60            tp: SegmentTypes::Bracketed, 
61            seg: (top.seg_start + 1, data.index),
62            rank: stack.len(), 
63        });
64        PlainSegment            
65    } else {
66        let top = stack.last().unwrap();
67        data.segments.push(ParsedSegment { 
68            tp: SegmentTypes::Plain, 
69            seg: (top.seg_start, data.index),
70            rank: stack.len(),
71        });
72        stack.push(PDAStackCtx { sym: SegmentStart, seg_start: data.index } );
73        InvalidSegment                
74    }
75});
76
77transition_handler!(PlainSegment on EndOfSentence for ParserNonDetPDA {
78    if let Some(_) = stack.last() {
79        let top = stack.pop().unwrap();
80        let tp = if SentenceStart == top {
81            SegmentTypes::Sentence
82        } else if SegmentStart == top {
83            SegmentTypes::Plain
84        } else { unimplemented!(); };
85        data.segments.push(ParsedSegment { 
86            tp, 
87            seg: (top.seg_start, data.index),
88            rank: stack.len(),
89        });        
90    }
91});
92
93transition_handler!(_ on EndOfSentence for ParserNonDetPDA {
94    Self::drain_unbalanced(data, stack);
95});
96
97transition_handler!( _ on EndOfInput for ParserNonDetPDA {
98    if let Some(top) = stack.last() {
99        if &SentenceStart == top {
100            data.segments.push(ParsedSegment { 
101                tp: SegmentTypes::Tail, 
102                seg: (stack.pop().unwrap().seg_start, data.index),
103                rank: stack.len(),
104            });
105        } else {
106            Self::drain_unbalanced(data, stack);
107        }
108    }
109});
110
111transition_handler!( NewSentence on EndOfSentence for ParserNonDetPDA {
112});
113
114impl ParserNonDetPDA {
115    pub fn start(&mut self) {
116        self.signal(&Start);
117    }
118    pub fn next(&mut self, signal: &ParserNonDetPDASignals) {
119        self.signal(signal);
120        self.data.index += 1;
121    }
122    pub fn stop(&mut self) {
123        self.signal(&EndOfInput);
124    }
125
126    fn drain_unbalanced(
127        data: &mut <Self as ParserNonDetPDATrait>::DataItem, 
128        stack: &mut Vec<<Self as ParserNonDetPDATrait>::StackSymbolItem>,
129    ) {
130        while let Some(top) = stack.pop() {
131            let tp = 
132                if Bracket == top {  SegmentTypes::UnbalancedLeftBracket } 
133                else if SegmentStart == top { SegmentTypes::UnbalancedRightSth}
134                else if SentenceStart == top { SegmentTypes::InvalidSentence}
135                else {
136                    unimplemented!();
137                };
138            data.segments.push(ParsedSegment { 
139                tp, 
140                seg: (top.seg_start, data.index),
141                rank: stack.len(),
142            });
143        }
144    }
145}    
146
parser_pda/parser_nondet_pda.rs

parser_pda/
parser_nondet_pda.rs
