blob: e4ff7630b8e81fcc03da7ec466977cd9173aad4e (
plain)
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
#!/usr/bin/ruby
# encoding: utf-8
require 'antlr3/test/functional'
class TestProfileMode < ANTLR3::Test::Functional
compile_options :profile => true
inline_grammar( <<-'END' )
grammar SimpleC;
options { language = Ruby; }
program
: declaration+
;
/** In this rule, the functionHeader left prefix on the last two
* alternatives is not LL(k) for a fixed k. However, it is
* LL(*). The LL(*) algorithm simply scans ahead until it sees
* either the ';' or the '{' of the block and then it picks
* the appropriate alternative. Lookhead can be arbitrarily
* long in theory, but is <=10 in most cases. Works great.
* Use ANTLRWorks to see the lookahead use (step by Location)
* and look for blue tokens in the input window pane. :)
*/
declaration
: variable
| functionHeader ';'
| functionHeader block
;
variable
: type declarator ';'
;
declarator
: ID
;
functionHeader
: type ID '(' ( formalParameter ( ',' formalParameter )* )? ')'
;
formalParameter
: type declarator
;
type
: 'int'
| 'char'
| 'void'
| ID
;
block
: '{'
variable*
stat*
'}'
;
stat: forStat
| expr ';'
| block
| assignStat ';'
| ';'
;
forStat
: 'for' '(' assignStat ';' expr ';' assignStat ')' block
;
assignStat
: ID '=' expr
;
expr: condExpr
;
condExpr
: aexpr ( ('==' | '<') aexpr )?
;
aexpr
: atom ( '+' atom )*
;
atom
: ID
| INT
| '(' expr ')'
;
ID : ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*
;
INT : ('0'..'9')+
;
WS : ( ' '
| '\t'
| '\r'
| '\n'
)+
{ $channel=HIDDEN; }
;
END
example 'profile mode output' do
input = <<-END.fixed_indent( 0 )
char c;
int x;
void bar(int x);
int foo(int y, char d) {
int i;
for (i=0; i<3; i=i+1) {
x=3;
y=5;
}
}
END
lexer = SimpleC::Lexer.new( input )
tokens = ANTLR3::CommonTokenStream.new( lexer )
parser = SimpleC::Parser.new( tokens )
parser.program
profile_data = parser.profile
profile_data.rule_invocations.should == 60
profile_data.guessing_rule_invocations.should == 0
profile_data.rule_invocation_depth.should == 12
profile_data.fixed_decisions.should == 40
fixed_data = profile_data.fixed_looks
fixed_data.min.should == 1
fixed_data.max.should == 2
fixed_data.average.should == 1.075
fixed_data.standard_deviation.should == 0.26674678283691855
profile_data.cyclic_decisions.should == 4
cyclic_data = profile_data.cyclic_looks
cyclic_data.min.should == 3
cyclic_data.max.should == 10
cyclic_data.average.should == 5.75
cyclic_data.standard_deviation.should == 3.4034296427770228
profile_data.syntactic_predicates.should == 0
profile_data.memoization_cache_entries.should == 0
profile_data.memoization_cache_hits.should == 0
profile_data.memoization_cache_misses.should == 0
profile_data.semantic_predicates.should == 0
profile_data.tokens.should == 77
profile_data.hidden_tokens.should == 24
profile_data.characters_matched.should == 118
profile_data.hidden_characters_matched.should == 40
profile_data.reported_errors.should == 0
end
end
|
