/usr/lib/ruby/vendor_ruby/treetop/compiler/metagrammar.treetop is in ruby-treetop 1.4.10-5.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 | module Treetop
module Compiler
grammar Metagrammar
rule treetop_file
requires:(space? require_statement)* prefix:space? module_or_grammar suffix:space? {
def compile
requires.text_value + prefix.text_value + module_or_grammar.compile + suffix.text_value
end
}
end
rule require_statement
prefix:space? "require" [ \t]+ [^\n\r]+ [\n\r]
end
rule module_or_grammar
module_declaration / grammar
end
rule module_declaration
prefix:('module' space name:([A-Z] alphanumeric_char* ('::' [A-Z] alphanumeric_char*)*) space) module_contents:(module_declaration / grammar) suffix:(space 'end') {
def compile
prefix.text_value + module_contents.compile + suffix.text_value
end
def parser_name
prefix.name.text_value+'::'+module_contents.parser_name
end
}
end
rule grammar
'grammar' space grammar_name space ('do' space)? declaration_sequence space? 'end' <Grammar>
end
rule grammar_name
([A-Z] alphanumeric_char*)
end
rule declaration_sequence
head:declaration tail:(space declaration)* <DeclarationSequence> {
def declarations
[head] + tail
end
def tail
super.elements.map { |elt| elt.declaration }
end
}
/
'' {
def compile(builder)
end
}
end
rule declaration
parsing_rule / include_declaration
end
rule include_declaration
'include' space [A-Z] (alphanumeric_char / '::')* {
def compile(builder)
builder << text_value
end
}
end
rule parsing_rule
'rule' space nonterminal space ('do' space)? parsing_expression space 'end' <ParsingRule>
end
rule parsing_expression
choice / sequence / primary
end
rule choice
head:alternative tail:(space? '/' space? alternative)+ <Choice> {
def alternatives
[head] + tail
end
def tail
super.elements.map {|elt| elt.alternative}
end
def inline_modules
(alternatives.map {|alt| alt.inline_modules }).flatten
end
}
end
rule sequence
head:labeled_sequence_primary tail:(space labeled_sequence_primary)+ node_class_declarations <Sequence> {
def sequence_elements
[head] + tail
end
def tail
super.elements.map {|elt| elt.labeled_sequence_primary }
end
def inline_modules
(sequence_elements.map {|elt| elt.inline_modules}).flatten +
[sequence_element_accessor_module] +
node_class_declarations.inline_modules
end
def inline_module_name
node_class_declarations.inline_module_name
end
}
end
rule alternative
sequence / primary
end
rule primary
prefix atomic {
def compile(address, builder, parent_expression=nil)
prefix.compile(address, builder, self)
end
def prefixed_expression
atomic
end
def inline_modules
atomic.inline_modules
end
def inline_module_name
nil
end
}
/
prefix space? predicate_block {
def compile(address, builder, parent_expression=nil)
prefix.compile(address, builder, self)
end
def prefixed_expression
predicate_block
end
def inline_modules
[]
end
}
/
atomic suffix node_class_declarations {
def compile(address, builder, parent_expression=nil)
suffix.compile(address, builder, self)
end
def optional_expression
atomic
end
def node_class_name
node_class_declarations.node_class_name
end
def inline_modules
atomic.inline_modules + node_class_declarations.inline_modules
end
def inline_module_name
node_class_declarations.inline_module_name
end
}
/
atomic node_class_declarations {
def compile(address, builder, parent_expression=nil)
atomic.compile(address, builder, self)
end
def node_class_name
node_class_declarations.node_class_name
end
def inline_modules
atomic.inline_modules + node_class_declarations.inline_modules
end
def inline_module_name
node_class_declarations.inline_module_name
end
}
end
rule labeled_sequence_primary
label sequence_primary {
def compile(lexical_address, builder)
sequence_primary.compile(lexical_address, builder)
end
def inline_modules
sequence_primary.inline_modules
end
def label_name
if label.name
label.name
elsif sequence_primary.instance_of?(Nonterminal)
sequence_primary.text_value
else
nil
end
end
}
end
rule label
(alpha_char alphanumeric_char*) ':' {
def name
elements[0].text_value
end
}
/
'' {
def name
nil
end
}
end
rule sequence_primary
prefix atomic {
def compile(lexical_address, builder)
prefix.compile(lexical_address, builder, self)
end
def prefixed_expression
elements[1]
end
def inline_modules
atomic.inline_modules
end
def inline_module_name
nil
end
}
/
prefix space? predicate_block {
def compile(address, builder, parent_expression=nil)
prefix.compile(address, builder, self)
end
def prefixed_expression
predicate_block
end
def inline_modules
[]
end
}
/
atomic suffix {
def compile(lexical_address, builder)
suffix.compile(lexical_address, builder, self)
end
def node_class_name
nil
end
def inline_modules
atomic.inline_modules
end
def inline_module_name
nil
end
}
/
atomic
end
rule suffix
repetition_suffix / optional_suffix
end
rule optional_suffix
'?' <Optional>
end
rule node_class_declarations
node_class_expression trailing_inline_module {
def node_class_name
node_class_expression.node_class_name
end
def inline_modules
trailing_inline_module.inline_modules
end
def inline_module
trailing_inline_module.inline_module
end
def inline_module_name
inline_module.module_name if inline_module
end
}
end
rule repetition_suffix
'+' <OneOrMore> / '*' <ZeroOrMore> / occurrence_range
end
rule occurrence_range
space? min:([0-9])* '..' max:([0-9])* <OccurrenceRange>
end
rule prefix
'&' <AndPredicate> / '!' <NotPredicate> / '~' <TransientPrefix>
end
rule atomic
terminal
/
nonterminal
/
parenthesized_expression
end
rule parenthesized_expression
'(' space? parsing_expression space? ')' <ParenthesizedExpression> {
def inline_modules
parsing_expression.inline_modules
end
}
end
rule nonterminal
!keyword_inside_grammar (alpha_char alphanumeric_char*) <Nonterminal>
end
rule terminal
quoted_string / character_class / anything_symbol
end
rule quoted_string
(single_quoted_string / double_quoted_string) {
def string
super.text_value
end
}
end
rule double_quoted_string
'"' string:(!'"' ("\\\\" / '\"' / .))* '"' <Terminal>
end
rule single_quoted_string
"'" string:(!"'" ("\\\\" / "\\'" / .))* "'" <Terminal>
end
rule character_class
'[' characters:(!']' ('\\' . /!'\\' .))+ ']' <CharacterClass> {
def characters
super.text_value
end
}
end
rule anything_symbol
'.' <AnythingSymbol>
end
rule node_class_expression
space '<' (!'>' .)+ '>' {
def node_class_name
elements[2].text_value
end
}
/
'' {
def node_class_name
nil
end
}
end
rule trailing_inline_module
space inline_module {
def inline_modules
[inline_module]
end
def inline_module_name
inline_module.module_name
end
}
/
'' {
def inline_modules
[]
end
def inline_module
nil
end
def inline_module_name
nil
end
}
end
rule predicate_block
'' inline_module <PredicateBlock>
end
rule inline_module
'{' (inline_module / ![{}] .)* '}' <InlineModule>
end
rule keyword_inside_grammar
('rule' / 'end') !non_space_char
end
rule non_space_char
!space .
end
rule alpha_char
[A-Za-z_]
end
rule alphanumeric_char
alpha_char / [0-9]
end
rule space
(white / comment_to_eol)+
end
rule comment_to_eol
'#' (!"\n" .)*
end
rule white
[ \t\n\r]
end
end
end
end
|